Swift SIL: speed up Operand.value

Instead of doing the type casts and/or conformance lookup on the swift side, do it on the C++ side.
It makes a significant performance difference because `Operand.value` is a time critical function

Author: eeckstein

SwiftCompilerSources/Sources/SIL/Value.swift

@@ -157,18 +157,21 @@ extension Value {
 extension BridgedValue {
   public func getAs<T: AnyObject>(_ valueType: T.Type) -> T { obj.getAs(T.self) }
 
+  public var value: Value { getAs(AnyObject.self) as! Value }
+}
+
+extension BridgedClassifiedValue {
   public var value: Value {
-    // This is much faster than a conformance lookup with `as! Value`.
-    let v = getAs(AnyObject.self)
-    switch v {
-      case let inst as SingleValueInstruction:
-        return inst
-      case let arg as Argument:
-        return arg
-      case let mvr as MultipleValueInstructionResult:
-        return mvr
-      case let undef as Undef:
-        return undef
+    // Doing the type check in C++ is much faster than a conformance lookup with `as! Value`.
+    switch kind {
+      case .SingleValueInstruction:
+        return obj.getAs(SingleValueInstruction.self)
+      case .Argument:
+        return obj.getAs(Argument.self)
+      case .MultipleValueInstructionResult:
+        return obj.getAs(MultipleValueInstructionResult.self)
+      case .Undef:
+        return obj.getAs(Undef.self)
       default:
         fatalError("unknown Value type")
     }

include/swift/SIL/SILBridging.h

@@ -133,6 +133,19 @@ typedef struct {
   SwiftObject obj;
 } BridgedValue;
 
+// For fast SILValue -> Value briding.
+// This is doing the type checks in C++ rather than in Swift.
+// It's used for getting the value of an Operand, which is a time critical function.
+typedef struct {
+  SwiftObject obj;
+  enum class Kind {
+    SingleValueInstruction,
+    Argument,
+    MultipleValueInstructionResult,
+    Undef
+  } kind;
+} BridgedClassifiedValue;
+
 typedef struct {
   OptionalSwiftObject obj;
 } OptionalBridgedValue;
@@ -305,7 +318,7 @@ OptionalBridgedSuccessor SILSuccessor_getNext(BridgedSuccessor succ);
 BridgedBasicBlock SILSuccessor_getTargetBlock(BridgedSuccessor succ);
 BridgedInstruction SILSuccessor_getContainingInst(BridgedSuccessor succ);
 
-BridgedValue Operand_getValue(BridgedOperand);
+BridgedClassifiedValue Operand_getValue(BridgedOperand);
 OptionalBridgedOperand Operand_nextUse(BridgedOperand);
 BridgedInstruction Operand_getUser(BridgedOperand);
 SwiftInt Operand_isTypeDependent(BridgedOperand);

lib/SIL/Utils/SILBridging.cpp

@@ -447,8 +447,21 @@ static Operand *castToOperand(BridgedOperand operand) {
   return const_cast<Operand *>(static_cast<const Operand *>(operand.op));
 }
 
-BridgedValue Operand_getValue(BridgedOperand operand) {
-  return {castToOperand(operand)->get()};
+BridgedClassifiedValue Operand_getValue(BridgedOperand operand) {
+  SILValue v = castToOperand(operand)->get();
+  BridgedClassifiedValue::Kind k;
+  if (isa<SingleValueInstruction>(v)) {
+    k = BridgedClassifiedValue::Kind::SingleValueInstruction;
+  } else if (isa<SILArgument>(v)) {
+    k = BridgedClassifiedValue::Kind::Argument;
+  } else if (isa<MultipleValueInstructionResult>(v)) {
+    k = BridgedClassifiedValue::Kind::MultipleValueInstructionResult;
+  } else if (isa<SILUndef>(v)) {
+    k = BridgedClassifiedValue::Kind::Undef;
+  } else {
+    llvm_unreachable("unknown SILValue");
+  }
+  return {castToOperand(operand)->get(), k};
 }
 
 OptionalBridgedOperand Operand_nextUse(BridgedOperand operand) {