[constant-folding] Teach constant folding how to remove (int_to_ptr (ptr_to_int)).

I put in a little bit of infrastructure that should provide the appropriate
places for adding information about other cases where we can run into this with
other casts.

The reason I added this is that the codegen around condfail_message has changed
slightly and thus has this round trip in it, messing with various pattern
matching routines.

Example:

```
%x = string_literal
%x1 = ptr_to_int %x    // <=== This messes with pattern matching from
%x2 = int_to_ptr %x1   // <=== the cond_fail to %x.
cond_fail(%x2)
```

=>

```
%x = string_literal    // <=== Happiness = ).
cond_fail(%x)
```

Author: gottesmm

lib/SILOptimizer/Utils/ConstantFolding.cpp

@@ -1298,6 +1298,34 @@ case BuiltinValueKind::id:
     return foldFPToIntConversion(BI, Builtin, ResultsInError);
   }
 
+  case BuiltinValueKind::IntToPtr: {
+    if (auto *op = dyn_cast<BuiltinInst>(BI->getOperand(0))) {
+      if (auto kind = op->getBuiltinKind()) {
+        // If we have a single int_to_ptr user and all of the types line up, we
+        // can simplify this instruction.
+        if (*kind == BuiltinValueKind::PtrToInt &&
+            op->getOperand(0)->getType() == BI->getResult(0)->getType()) {
+          return op->getOperand(0);
+        }
+      }
+    }
+    break;
+  }
+
+  case BuiltinValueKind::PtrToInt: {
+    if (auto *op = dyn_cast<BuiltinInst>(BI->getOperand(0))) {
+      if (auto kind = op->getBuiltinKind()) {
+        // If we have a single int_to_ptr user and all of the types line up, we
+        // can simplify this instruction.
+        if (*kind == BuiltinValueKind::IntToPtr &&
+            op->getOperand(0)->getType() == BI->getResult(0)->getType()) {
+          return op->getOperand(0);
+        }
+      }
+    }
+    break;
+  }
+
   case BuiltinValueKind::AssumeNonNegative: {
     auto *V = dyn_cast<IntegerLiteralInst>(Args[0]);
     if (!V)
@@ -1418,7 +1446,8 @@ static bool isApplyOfStringConcat(SILInstruction &I) {
 }
 
 static bool isFoldable(SILInstruction *I) {
-  return isa<IntegerLiteralInst>(I) || isa<FloatLiteralInst>(I);
+  return isa<IntegerLiteralInst>(I) || isa<FloatLiteralInst>(I) ||
+         isa<StringLiteralInst>(I);
 }
 
 bool ConstantFolder::constantFoldStringConcatenation(ApplyInst *AI) {
@@ -1550,6 +1579,29 @@ void ConstantFolder::initializeWorklist(SILFunction &F) {
   }
 }
 
+/// Returns true if \p i is an instruction that has a stateless inverse. We want
+/// to visit such instructions to eliminate such round-trip unnecessary
+/// operations.
+///
+/// As an example, consider casts, inttoptr, ptrtoint and friends.
+static bool isReadNoneAndInvertible(SILInstruction *i) {
+  if (auto *bi = dyn_cast<BuiltinInst>(i)) {
+    // Look for ptrtoint and inttoptr for now.
+    if (auto kind = bi->getBuiltinKind()) {
+      switch (*kind) {
+      default:
+        return false;
+      case BuiltinValueKind::PtrToInt:
+      case BuiltinValueKind::IntToPtr:
+        return true;
+      }
+    }
+  }
+
+  // Be conservative and return false if we do not have any information.
+  return false;
+}
+
 SILAnalysis::InvalidationKind
 ConstantFolder::processWorkList() {
   LLVM_DEBUG(llvm::dbgs() << "*** ConstPropagation processing: \n");
@@ -1721,6 +1773,17 @@ ConstantFolder::processWorkList() {
         if (isa<CondFailInst>(User))
           FoldedUsers.insert(User);
 
+        // See if we have an instruction that is read none and has a stateless
+        // inverse. If we do, add it to the worklist so we can check its users
+        // for the inverse operation and see if we can perform constant folding
+        // on the inverse operation. This can eliminate annoying "round trip"s.
+        //
+        // NOTE: We are assuming on purpose that our inverse will be read none,
+        // since otherwise we wouldn't be able to constant fold it this way.
+        if (isReadNoneAndInvertible(User)) {
+          WorkList.insert(User);
+        }
+
         // Initialize ResultsInError as a None optional.
         //
         // We are essentially using this optional to represent 3 states: true,

test/SILOptimizer/constant_propagation.sil

@@ -954,3 +954,37 @@ bb0:
 // String.init(_builtinStringLiteral:utf8CodeUnitCount:isASCII:)
 // The semantics attribute is used by the constant folder.
 sil [serialized] [always_inline] [readonly] [_semantics "string.makeUTF8"] @$sSS21_builtinStringLiteral17utf8CodeUnitCount7isASCIISSBp_BwBi1_tcfC : $@convention(method) (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> @owned String
+
+// CHECK-LABEL: sil @string_ptr_to_int_round_trip : $@convention(thin) () -> Builtin.RawPointer {
+// CHECK-NOT: builtin
+// CHECK: } // end sil function 'string_ptr_to_int_round_trip'
+sil @string_ptr_to_int_round_trip : $@convention(thin) () -> Builtin.RawPointer {
+bb0:
+  %0 = string_literal utf8 "constant"
+  %1 = builtin "ptrtoint_Word"(%0 : $Builtin.RawPointer) : $Builtin.Word
+  %2 = builtin "inttoptr_Word"(%1 : $Builtin.Word) : $Builtin.RawPointer
+  return %2 : $Builtin.RawPointer
+}
+
+// CHECK-LABEL: sil @string_ptr_to_int_round_trip_2 : $@convention(thin) () -> Builtin.Word {
+// CHECK-NOT: builtin
+// CHECK: } // end sil function 'string_ptr_to_int_round_trip_2'
+sil @string_ptr_to_int_round_trip_2 : $@convention(thin) () -> Builtin.Word {
+bb0:
+  %0 = integer_literal $Builtin.Word, 0
+  %1 = builtin "inttoptr_Word"(%0 : $Builtin.Word) : $Builtin.RawPointer
+  %2 = builtin "ptrtoint_Word"(%1 : $Builtin.RawPointer) : $Builtin.Word
+  return %2 : $Builtin.Word
+}
+
+// CHECK-LABEL: sil @string_ptr_to_int_round_trip_no_match : $@convention(thin) () -> Builtin.Int32 {
+// CHECK: builtin
+// CHECK: builtin
+// CHECK: } // end sil function 'string_ptr_to_int_round_trip_no_match'
+sil @string_ptr_to_int_round_trip_no_match : $@convention(thin) () -> Builtin.Int32 {
+bb0:
+  %0 = integer_literal $Builtin.Word, 0
+  %1 = builtin "inttoptr_Word"(%0 : $Builtin.Word) : $Builtin.RawPointer
+  %2 = builtin "ptrtoint_Int32"(%1 : $Builtin.RawPointer) : $Builtin.Int32
+  return %2 : $Builtin.Int32
+}