remove now unused utilities

* StaticInitCloner
* some APIs in SILGlobalVariable

Author: eeckstein

include/swift/SIL/SILGlobalVariable.h

@@ -181,16 +181,6 @@ class SILGlobalVariable
   const_iterator begin() const { return StaticInitializerBlock.begin(); }
   const_iterator end() const { return StaticInitializerBlock.end(); }
 
-  /// Returns true if \p I is a valid instruction to be contained in the
-  /// static initializer.
-  static bool isValidStaticInitializerInst(const SILInstruction *I,
-                                           SILModule &M);
-
-  /// Returns the usub_with_overflow builtin if \p TE extracts the result of
-  /// such a subtraction, which is required to have an integer_literal as right
-  /// operand.
-  static BuiltinInst *getOffsetSubtract(const TupleExtractInst *TE, SILModule &M);
-
   void dropAllReferences() {
     StaticInitializerBlock.dropAllReferences();
   }
@@ -290,10 +280,8 @@ SILFunction *findInitializer(SILFunction *AddrF, BuiltinInst *&CallToOnce);
 ///
 /// Given a global initializer, InitFunc, return the GlobalVariable that it
 /// statically initializes or return nullptr if it isn't an obvious static
-/// initializer. If a global variable is returned, InitVal is initialized to the
-/// the instruction producing the global's initial value.
-SILGlobalVariable *getVariableOfStaticInitializer(
-  SILFunction *InitFunc, SingleValueInstruction *&InitVal);
+/// initializer.
+SILGlobalVariable *getVariableOfStaticInitializer(SILFunction *InitFunc);
 
 } // namespace swift
 

include/swift/SILOptimizer/Utils/BasicBlockOptUtils.h

@@ -344,84 +344,6 @@ class CloneCollector {
   }
 };
 
-/// Utility class for cloning init values into the static initializer of a
-/// SILGlobalVariable.
-class StaticInitCloner : public SILCloner<StaticInitCloner> {
-  friend class SILInstructionVisitor<StaticInitCloner>;
-  friend class SILCloner<StaticInitCloner>;
-
-  /// The number of not yet cloned operands for each instruction.
-  llvm::DenseMap<SILInstruction *, int> numOpsToClone;
-
-  /// List of instructions for which all operands are already cloned (or which
-  /// don't have any operands).
-  llvm::SmallVector<SILInstruction *, 8> readyToClone;
-
-  SILDebugLocation insertLoc;
-
-  SILInstruction *firstClonedInst = nullptr;
-
-public:
-  StaticInitCloner(SILGlobalVariable *gVar)
-      : SILCloner<StaticInitCloner>(gVar),
-        insertLoc(ArtificialUnreachableLocation(), nullptr) {}
-
-  StaticInitCloner(SILInstruction *insertionPoint)
-      : SILCloner<StaticInitCloner>(*insertionPoint->getFunction()),
-        insertLoc(insertionPoint->getDebugLocation()) {
-    Builder.setInsertionPoint(insertionPoint);
-  }
-
-  StaticInitCloner(const SILBuilder &builder)
-    : SILCloner<StaticInitCloner>(builder.getFunction()),
-      insertLoc(ArtificialUnreachableLocation(), nullptr) {
-    Builder.setInsertionPoint(builder.getInsertionBB(), builder.getInsertionPoint());
-    if (builder.getInsertionPoint() != builder.getInsertionBB()->end())
-      insertLoc = builder.getInsertionPoint()->getDebugLocation();
-  }
-
-  /// Add \p InitVal and all its operands (transitively) for cloning.
-  ///
-  /// Note: all init values must are added, before calling clone().
-  /// Returns false if cloning is not possible, e.g. if we would end up cloning
-  /// a reference to a private function into a function which is serialized.
-  bool add(SILValue initVal);
-
-  /// Clone \p InitVal and all its operands into the initializer of the
-  /// SILGlobalVariable.
-  ///
-  /// \return Returns the cloned instruction in the SILGlobalVariable.
-  SILValue clone(SILValue initVal);
-
-  SILInstruction *getFirstClonedInst() const { return firstClonedInst; }
-
-  /// Convenience function to clone a single \p InitVal.
-  static void appendToInitializer(SILGlobalVariable *gVar,
-                                  SingleValueInstruction *initVal) {
-    StaticInitCloner cloner(gVar);
-    bool success = cloner.add(initVal);
-    (void)success;
-    assert(success && "adding initVal cannot fail for a global variable");
-    cloner.clone(initVal);
-  }
-
-protected:
-
-  void postProcess(SILInstruction *Orig, SILInstruction *Cloned) {
-    if (!firstClonedInst)
-      firstClonedInst = Cloned;
-    SILCloner<StaticInitCloner>::postProcess(Orig, Cloned);
-  }
-
-  SILLocation remapLocation(SILLocation loc) {
-    return insertLoc.getLocation();
-  }
-
-  const SILDebugScope *remapScope(const SILDebugScope *DS) {
-    return insertLoc.getScope();
-  }
-};
-
 } // namespace swift
 
 #endif

lib/IRGen/GenConstant.cpp

@@ -155,6 +155,32 @@ llvm::Constant *emitConstantStructOrTuple(IRGenModule &IGM, InstTy inst,
 }
 } // end anonymous namespace
 
+/// Returns the usub_with_overflow builtin if \p TE extracts the result of
+/// such a subtraction, which is required to have an integer_literal as right
+/// operand.
+static BuiltinInst *getOffsetSubtract(const TupleExtractInst *TE, SILModule &M) {
+  // Match the pattern:
+  // tuple_extract(usub_with_overflow(x, integer_literal, integer_literal 0), 0)
+
+  if (TE->getFieldIndex() != 0)
+    return nullptr;
+
+  auto *BI = dyn_cast<BuiltinInst>(TE->getOperand());
+  if (!BI)
+    return nullptr;
+  if (M.getBuiltinInfo(BI->getName()).ID != BuiltinValueKind::USubOver)
+    return nullptr;
+
+  if (!isa<IntegerLiteralInst>(BI->getArguments()[1]))
+    return nullptr;
+
+  auto *overflowFlag = dyn_cast<IntegerLiteralInst>(BI->getArguments()[2]);
+  if (!overflowFlag || !overflowFlag->getValue().isNullValue())
+    return nullptr;
+
+  return BI;
+}
+
 llvm::Constant *irgen::emitConstantValue(IRGenModule &IGM, SILValue operand) {
   if (auto *SI = dyn_cast<StructInst>(operand)) {
     // The only way to get a struct's stored properties (which we need to map to
@@ -200,8 +226,7 @@ llvm::Constant *irgen::emitConstantValue(IRGenModule &IGM, SILValue operand) {
           // Handle StringObjectOr(tuple_extract(usub_with_overflow(x, offset)), bits)
           // This pattern appears in UTF8 String literal construction.
           // Generate the equivalent: add(x, sub(bits - offset)
-          BuiltinInst *SubtrBI =
-            SILGlobalVariable::getOffsetSubtract(TE, IGM.getSILModule());
+          BuiltinInst *SubtrBI = getOffsetSubtract(TE, IGM.getSILModule());
           assert(SubtrBI && "unsupported argument of StringObjectOr");
           auto *ptr = emitConstantValue(IGM, SubtrBI->getArguments()[0]);
           auto *offset = emitConstantValue(IGM, SubtrBI->getArguments()[1]);

lib/SIL/IR/SILGlobalVariable.cpp

@@ -86,116 +86,6 @@ SILInstruction *SILGlobalVariable::getStaticInitializerValue() {
   return &StaticInitializerBlock.back();
 }
 
-BuiltinInst *SILGlobalVariable::getOffsetSubtract(const TupleExtractInst *TE,
-                                                  SILModule &M) {
-
-  // Match the pattern:
-  // tuple_extract(usub_with_overflow(x, integer_literal, integer_literal 0), 0)
-
-  if (TE->getFieldIndex() != 0)
-    return nullptr;
-
-  auto *BI = dyn_cast<BuiltinInst>(TE->getOperand());
-  if (!BI)
-    return nullptr;
-  if (M.getBuiltinInfo(BI->getName()).ID != BuiltinValueKind::USubOver)
-    return nullptr;
-
-  if (!isa<IntegerLiteralInst>(BI->getArguments()[1]))
-    return nullptr;
-
-  auto *overflowFlag = dyn_cast<IntegerLiteralInst>(BI->getArguments()[2]);
-  if (!overflowFlag || !overflowFlag->getValue().isNullValue())
-    return nullptr;
-
-  return BI;
-}
-
-bool SILGlobalVariable::isValidStaticInitializerInst(const SILInstruction *I,
-                                                     SILModule &M) {
-  for (const Operand &op : I->getAllOperands()) {
-    // Rule out SILUndef and SILArgument.
-    if (!isa<SingleValueInstruction>(op.get()))
-      return false;
-  }
-  switch (I->getKind()) {
-    case SILInstructionKind::BuiltinInst: {
-      auto *bi = cast<BuiltinInst>(I);
-      switch (M.getBuiltinInfo(bi->getName()).ID) {
-        case BuiltinValueKind::ZeroInitializer: {
-          auto type = bi->getType().getASTType();
-          if (auto vector = dyn_cast<BuiltinVectorType>(type))
-            type = vector.getElementType();
-          return isa<BuiltinIntegerType>(type) || isa<BuiltinFloatType>(type);
-        }
-        case BuiltinValueKind::PtrToInt:
-          if (isa<LiteralInst>(bi->getArguments()[0]))
-            return true;
-          break;
-        case BuiltinValueKind::StringObjectOr:
-          // The first operand can be a string literal (i.e. a pointer), but the
-          // second operand must be a constant. This enables creating a
-          // a pointer+offset relocation.
-          // Note that StringObjectOr requires the or'd bits in the first
-          // operand to be 0, so the operation is equivalent to an addition.
-          if (isa<IntegerLiteralInst>(bi->getArguments()[1]))
-            return true;
-          break;
-        case BuiltinValueKind::ZExtOrBitCast:
-          return true;
-        case BuiltinValueKind::USubOver: {
-          // Handle StringObjectOr(tuple_extract(usub_with_overflow(x, offset)), bits)
-          // This pattern appears in UTF8 String literal construction.
-          auto *TE = bi->getSingleUserOfType<TupleExtractInst>();
-          return TE && getOffsetSubtract(TE, M);
-        }
-        case BuiltinValueKind::OnFastPath:
-          return true;
-        default:
-          break;
-      }
-      return false;
-    }
-    case SILInstructionKind::TupleExtractInst: {
-      // Handle StringObjectOr(tuple_extract(usub_with_overflow(x, offset)), bits)
-      // This pattern appears in UTF8 String literal construction.
-      auto *TE = cast<TupleExtractInst>(I);
-      if (!getOffsetSubtract(TE, M))
-        return false;
-      auto *BI = TE->getSingleUserOfType<BuiltinInst>();
-      return BI &&
-        M.getBuiltinInfo(BI->getName()).ID == BuiltinValueKind::StringObjectOr;
-    }
-    case SILInstructionKind::StringLiteralInst:
-      switch (cast<StringLiteralInst>(I)->getEncoding()) {
-        case StringLiteralInst::Encoding::Bytes:
-        case StringLiteralInst::Encoding::UTF8:
-          return true;
-        case StringLiteralInst::Encoding::ObjCSelector:
-          // Objective-C selector string literals cannot be used in static
-          // initializers.
-          return false;
-      }
-      return false;
-    case SILInstructionKind::FunctionRefInst:
-      // TODO: support async function pointers in static globals.
-      if (cast<FunctionRefInst>(I)->getReferencedFunction()->isAsync())
-        return false;
-      return true;
-    case SILInstructionKind::StructInst:
-    case SILInstructionKind::TupleInst:
-    case SILInstructionKind::IntegerLiteralInst:
-    case SILInstructionKind::FloatLiteralInst:
-    case SILInstructionKind::ObjectInst:
-    case SILInstructionKind::ValueToBridgeObjectInst:
-    case SILInstructionKind::ConvertFunctionInst:
-    case SILInstructionKind::ThinToThickFunctionInst:
-      return true;
-    default:
-      return false;
-  }
-}
-
 /// Return whether this variable corresponds to a Clang node.
 bool SILGlobalVariable::hasClangNode() const {
   return (VDecl ? VDecl->hasClangNode() : false);
@@ -244,11 +134,7 @@ SILGlobalVariable *swift::getVariableOfGlobalInit(SILFunction *AddrF) {
   if (!InitF)
     return nullptr;
 
-  // If the globalinit_func is trivial, continue; otherwise bail.
-  SingleValueInstruction *dummyInitVal;
-  auto *SILG = getVariableOfStaticInitializer(InitF, dummyInitVal);
-
-  return SILG;
+  return getVariableOfStaticInitializer(InitF);
 }
 
 SILFunction *swift::getCalleeOfOnceCall(BuiltinInst *BI) {
@@ -297,48 +183,17 @@ SILFunction *swift::findInitializer(SILFunction *AddrF,
   return callee;
 }
 
-SILGlobalVariable *
-swift::getVariableOfStaticInitializer(SILFunction *InitFunc,
-                                      SingleValueInstruction *&InitVal) {
-  InitVal = nullptr;
-  SILGlobalVariable *GVar = nullptr;
+SILGlobalVariable *swift::getVariableOfStaticInitializer(SILFunction *InitFunc) {
   // We only handle a single SILBasicBlock for now.
   if (InitFunc->size() != 1)
     return nullptr;
 
-  SILBasicBlock *BB = &InitFunc->front();
-  GlobalAddrInst *SGA = nullptr;
-  bool HasStore = false;
-  for (auto &I : *BB) {
-    // Make sure we have a single GlobalAddrInst and a single StoreInst.
-    // And the StoreInst writes to the GlobalAddrInst.
-    if (isa<AllocGlobalInst>(&I) || isa<ReturnInst>(&I)
-        || isa<DebugValueInst>(&I) || isa<DebugStepInst>(&I)) {
-      continue;
-    } else if (auto *sga = dyn_cast<GlobalAddrInst>(&I)) {
-      if (SGA)
-        return nullptr;
-      SGA = sga;
-      GVar = SGA->getReferencedGlobal();
-    } else if (auto *SI = dyn_cast<StoreInst>(&I)) {
-      if (HasStore || SI->getDest() != SGA)
-        return nullptr;
-      HasStore = true;
-      InitVal = cast<SingleValueInstruction>(SI->getSrc());
-    } else if (auto *mt = dyn_cast<MetatypeInst>(&I)) {
-      // Unused meta_type instructions are sometimes generated by SILGen.
-      // Handle this case to not require to run DeadCodeElimination before
-      // MandatoryGlobalOpt.
-      if (!mt->use_empty())
-        return nullptr;
-    } else if (!SILGlobalVariable::isValidStaticInitializerInst(&I,
-                                                             I.getModule())) {
-      return nullptr;
+  for (auto &inst : InitFunc->front()) {
+    if (auto *agi = dyn_cast<AllocGlobalInst>(&inst)) {
+      return agi->getReferencedGlobal();
     }
   }
-  if (!InitVal)
-    return nullptr;
-  return GVar;
+  return nullptr;
 }
 
 SILType

lib/SIL/Verifier/SILVerifier.cpp

@@ -6870,8 +6870,6 @@ void SILGlobalVariable::verify() const {
 
   // Verify the static initializer.
   for (const SILInstruction &I : StaticInitializerBlock) {
-    assert(isValidStaticInitializerInst(&I, getModule()) &&
-           "illegal static initializer");
     auto init = cast<SingleValueInstruction>(&I);
     if (init == &StaticInitializerBlock.back()) {
       assert(init->use_empty() && "Init value must not have another use");