Subzero: Replace global pointers to allocation functions

src/IceASanInstrumentation.cpp

 //===- subzero/src/IceASanInstrumentation.cpp - ASan ------------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 81 matching lines @@
   // Global holding sizes of all redzones
   auto *RzSizes = VariableDeclaration::create(&NewGlobals);
 
   RzArray->setName(Ctx, RzArrayName);
   RzSizes->setName(Ctx, RzSizesName);
   RzArray->setIsConstant(true);
   RzSizes->setIsConstant(true);
   NewGlobals.push_back(RzArray);
   NewGlobals.push_back(RzSizes);
 
+  using PrototypeMap = std::unordered_map<std::string, FunctionDeclaration *>;
+  PrototypeMap ProtoSubstitutions;
   for (VariableDeclaration *Global : Globals) {
     assert(Global->getAlignment() <= RzSize);
     VariableDeclaration *RzLeft = VariableDeclaration::create(&NewGlobals);
+    VariableDeclaration *NewGlobal = Global;
     VariableDeclaration *RzRight = VariableDeclaration::create(&NewGlobals);
     RzLeft->setName(Ctx, nextRzName());
     RzRight->setName(Ctx, nextRzName());
     SizeT Alignment = std::max(RzSize, Global->getAlignment());
     SizeT RzLeftSize = Alignment;
     SizeT RzRightSize =
         RzSize + Utils::OffsetToAlignment(Global->getNumBytes(), Alignment);
-    if (Global->hasNonzeroInitializer()) {
+    if (!Global->hasNonzeroInitializer()) {

[Jim Stichnoth, 2016/08/16 17:54:55]

I prefer to structure these things like this:

  if (C) A; else B;

instead of:

  if (!C) B; else A;

+      RzLeft->addInitializer(VariableDeclaration::ZeroInitializer::create(
+          &NewGlobals, RzLeftSize));
+      RzRight->addInitializer(VariableDeclaration::ZeroInitializer::create(
+          &NewGlobals, RzRightSize));
+    } else {
       RzLeft->addInitializer(VariableDeclaration::DataInitializer::create(
           &NewGlobals, llvm::NaClBitcodeRecord::RecordVector(RzLeftSize, 'R')));
       RzRight->addInitializer(VariableDeclaration::DataInitializer::create(
           &NewGlobals,
           llvm::NaClBitcodeRecord::RecordVector(RzRightSize, 'R')));
-    } else {
-      RzLeft->addInitializer(VariableDeclaration::ZeroInitializer::create(
-          &NewGlobals, RzLeftSize));
-      RzRight->addInitializer(VariableDeclaration::ZeroInitializer::create(
-          &NewGlobals, RzRightSize));
+
+      // replace any pointers to allocator functions
+      NewGlobal = VariableDeclaration::create(&NewGlobals);
+      NewGlobal->setName(Global->getName());
+      std::vector<VariableDeclaration::Initializer *> GlobalInits =
+          Global->getInitializers();
+      for (VariableDeclaration::Initializer *Init : GlobalInits) {
+        auto *RelocInit =
+            llvm::dyn_cast<VariableDeclaration::RelocInitializer>(Init);
+        if (RelocInit == nullptr) {
+          NewGlobal->addInitializer(Init);
+          continue;
+        }
+        const GlobalDeclaration *TargetDecl = RelocInit->getDeclaration();
+        const auto *TargetFunc =
+            llvm::dyn_cast<FunctionDeclaration>(TargetDecl);
+        if (TargetFunc == nullptr) {
+          NewGlobal->addInitializer(Init);
+          continue;
+        }
+        std::string TargetName = TargetDecl->getName().toStringOrEmpty();
+        StringMap::const_iterator Subst = FuncSubstitutions.find(TargetName);
+        if (Subst == FuncSubstitutions.end()) {
+          NewGlobal->addInitializer(Init);
+          continue;
+        }
+        std::string SubstName = Subst->second;
+        PrototypeMap::iterator SubstProtoEntry =

[Jim Stichnoth, 2016/08/16 17:54:55]

Optional: I'm usually happy to use "auto" instead of "XXX::iterator".

+            ProtoSubstitutions.find(SubstName);
+        FunctionDeclaration *SubstProto;
+        if (SubstProtoEntry != ProtoSubstitutions.end())
+          SubstProto = SubstProtoEntry->second;
+        else {
+          constexpr bool IsProto = true;
+          SubstProto = FunctionDeclaration::create(
+              Ctx, TargetFunc->getSignature(), TargetFunc->getCallingConv(),
+              llvm::GlobalValue::ExternalLinkage, IsProto);
+          SubstProto->setName(Ctx, SubstName);
+          ProtoSubstitutions.insert({SubstName, SubstProto});
+        }
+
+        NewGlobal->addInitializer(VariableDeclaration::RelocInitializer::create(
+            &NewGlobals, SubstProto, RelocOffsetArray(0)));
+      }
     }
+
     RzLeft->setIsConstant(Global->getIsConstant());
+    NewGlobal->setIsConstant(Global->getIsConstant());
     RzRight->setIsConstant(Global->getIsConstant());
     RzLeft->setAlignment(Alignment);
-    Global->setAlignment(Alignment);
+    NewGlobal->setAlignment(Alignment);
     RzRight->setAlignment(1);
     RzArray->addInitializer(VariableDeclaration::RelocInitializer::create(
         &NewGlobals, RzLeft, RelocOffsetArray(0)));
     RzArray->addInitializer(VariableDeclaration::RelocInitializer::create(
         &NewGlobals, RzRight, RelocOffsetArray(0)));
     RzSizes->addInitializer(VariableDeclaration::DataInitializer::create(
         &NewGlobals, sizeToByteVec(RzLeftSize)));
     RzSizes->addInitializer(VariableDeclaration::DataInitializer::create(
         &NewGlobals, sizeToByteVec(RzRightSize)));
 
     NewGlobals.push_back(RzLeft);
-    NewGlobals.push_back(Global);
+    NewGlobals.push_back(NewGlobal);
     NewGlobals.push_back(RzRight);
     RzGlobalsNum += 2;
 
-    GlobalSizes.insert({Global->getName(), Global->getNumBytes()});
+    GlobalSizes.insert({NewGlobal->getName(), NewGlobal->getNumBytes()});
   }
 
   // Replace old list of globals, without messing up arena allocators
   Globals.clear();
   Globals.merge(&NewGlobals);
   DidProcessGlobals = true;
 
   // Log the new set of globals
   if (BuildDefs::dump() && (getFlags().getVerbose() & IceV_GlobalInit)) {
     OstreamLocker _(Ctx);
@@ skipping 251 matching lines @@
   Call->addArg(Ctx->getConstantSym(0, Ctx->getGlobalString(RzSizesName)));
 }
 
 // TODO(tlively): make this more efficient with swap idiom
 void ASanInstrumentation::finishFunc(Cfg *) {
   ICE_TLS_GET_FIELD(LocalVars)->clear();
   ICE_TLS_GET_FIELD(LocalDtors)->clear();
 }
 
 } // end of namespace Ice