Introduce the notion of function addresses in Subzero.

src/IceConverter.cpp

 //===- subzero/src/IceConverter.cpp - Converts LLVM to Ice  ---------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the LLVM to ICE converter.
@@ skipping 16 matching lines @@
 #include "IceConverter.h"
 #include "IceDefs.h"
 #include "IceGlobalContext.h"
 #include "IceGlobalInits.h"
 #include "IceInst.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 #include "IceTypes.h"
 #include "IceTypeConverter.h"
 
+// TODO(kschimpf): Remove two namespaces being visible at once.
 using namespace llvm;
 
 namespace {
 
 // Debugging helper
 template <typename T> static std::string LLVMObjectAsString(const T *O) {
   std::string Dump;
   raw_string_ostream Stream(Dump);
   O->print(Stream);
   return Stream.str();
 }
 
 // Base class for converting LLVM to ICE.
 class LLVM2ICEConverter {
   LLVM2ICEConverter(const LLVM2ICEConverter &) = delete;
   LLVM2ICEConverter &operator=(const LLVM2ICEConverter &) = delete;
 
 public:
-  LLVM2ICEConverter(Ice::GlobalContext *Ctx, LLVMContext &LLVMContext)
-      : Ctx(Ctx), TypeConverter(LLVMContext) {}
+  LLVM2ICEConverter(Ice::Converter &Converter)
+      : Converter(Converter), Ctx(Converter.getContext()),
+        TypeConverter(Converter.getModule()->getContext()) {}
+
+  Ice::Converter &getConverter() const { return Converter; }
 
 protected:
-  // Data
+  Ice::Converter &Converter;
   Ice::GlobalContext *Ctx;
   const Ice::TypeConverter TypeConverter;
 };
 
 // Converter from LLVM functions to ICE. The entry point is the
 // convertFunction method.
 //
 // Note: this currently assumes that the given IR was verified to be
 // valid PNaCl bitcode. Otherwise, the behavior is undefined.
 class LLVM2ICEFunctionConverter : LLVM2ICEConverter {
   LLVM2ICEFunctionConverter(const LLVM2ICEFunctionConverter &) = delete;
   LLVM2ICEFunctionConverter &
   operator=(const LLVM2ICEFunctionConverter &) = delete;
 
 public:
-  LLVM2ICEFunctionConverter(Ice::GlobalContext *Ctx, LLVMContext &LLVMContext)
-      : LLVM2ICEConverter(Ctx, LLVMContext), Func(NULL) {}
+  LLVM2ICEFunctionConverter(Ice::Converter &Converter)
+      : LLVM2ICEConverter(Converter), Func(nullptr) {}
 
   // Caller is expected to delete the returned Ice::Cfg object.
   Ice::Cfg *convertFunction(const Function *F) {
     VarMap.clear();
     NodeMap.clear();
     Func = new Ice::Cfg(Ctx);
     Func->setFunctionName(F->getName());
     Func->setReturnType(convertToIceType(F->getReturnType()));
     Func->setInternal(F->hasInternalLinkage());
     Ice::TimerMarker T(Ice::TimerStack::TT_llvmConvert, Func);
@@ skipping 32 matching lines @@
       } else {
         return Ctx->getConstantInt32(Ty, CI->getSExtValue());
       }
     } else if (const auto CFP = dyn_cast<ConstantFP>(Const)) {
       Ice::Type Type = convertToIceType(CFP->getType());
       if (Type == Ice::IceType_f32)
         return Ctx->getConstantFloat(CFP->getValueAPF().convertToFloat());
       else if (Type == Ice::IceType_f64)
         return Ctx->getConstantDouble(CFP->getValueAPF().convertToDouble());
       llvm_unreachable("Unexpected floating point type");
-      return NULL;
+      return nullptr;
     } else if (const auto CU = dyn_cast<UndefValue>(Const)) {
       return Ctx->getConstantUndef(convertToIceType(CU->getType()));
     } else {
       llvm_unreachable("Unhandled constant type");
-      return NULL;
+      return nullptr;
     }
   }
 
 private:
   // LLVM values (instructions, etc.) are mapped directly to ICE variables.
   // mapValueToIceVar has a version that forces an ICE type on the variable,
   // and a version that just uses convertToIceType on V.
   Ice::Variable *mapValueToIceVar(const Value *V, Ice::Type IceTy) {
     if (IceTy == Ice::IceType_void)
-      return NULL;
+      return nullptr;
     if (VarMap.find(V) == VarMap.end()) {
       VarMap[V] = Func->makeVariable(IceTy, V->getName());
     }
     return VarMap[V];
   }
 
   Ice::Variable *mapValueToIceVar(const Value *V) {
     return mapValueToIceVar(V, convertToIceType(V->getType()));
   }
 
   Ice::CfgNode *mapBasicBlockToNode(const BasicBlock *BB) {
     if (NodeMap.find(BB) == NodeMap.end()) {
       NodeMap[BB] = Func->makeNode(BB->getName());
     }
     return NodeMap[BB];
   }
 
   Ice::Type convertToIceType(Type *LLVMTy) const {
     Ice::Type IceTy = TypeConverter.convertToIceType(LLVMTy);
     if (IceTy == Ice::IceType_NUM)
       report_fatal_error(std::string("Invalid PNaCl type ") +
                          LLVMObjectAsString(LLVMTy));
     return IceTy;
   }
 
   // Given an LLVM instruction and an operand number, produce the
   // Ice::Operand this refers to. If there's no such operand, return
-  // NULL.
+  // nullptr.
   Ice::Operand *convertOperand(const Instruction *Inst, unsigned OpNum) {
     if (OpNum >= Inst->getNumOperands()) {
-      return NULL;
+      return nullptr;
     }
     const Value *Op = Inst->getOperand(OpNum);
     return convertValue(Op);
   }
 
   Ice::Operand *convertValue(const Value *Op) {
     if (const auto Const = dyn_cast<Constant>(Op)) {
       return convertConstant(Const);
     } else {
       return mapValueToIceVar(Op);
@@ skipping 99 matching lines @@
     case Instruction::Alloca:
       return convertAllocaInstruction(cast<AllocaInst>(Inst));
     case Instruction::Unreachable:
       return convertUnreachableInstruction(cast<UnreachableInst>(Inst));
     default:
       report_fatal_error(std::string("Invalid PNaCl instruction: ") +
                          LLVMObjectAsString(Inst));
     }
 
     llvm_unreachable("convertInstruction");
-    return NULL;
+    return nullptr;
   }
 
   Ice::Inst *convertLoadInstruction(const LoadInst *Inst) {
     Ice::Operand *Src = convertOperand(Inst, 0);
     Ice::Variable *Dest = mapValueToIceVar(Inst);
     return Ice::InstLoad::create(Func, Dest, Src);
   }
 
   Ice::Inst *convertStoreInstruction(const StoreInst *Inst) {
     Ice::Operand *Addr = convertOperand(Inst, 1);
@@ skipping 211 matching lines @@
     }
     return Switch;
   }
 
   Ice::Inst *convertCallInstruction(const CallInst *Inst) {
     Ice::Variable *Dest = mapValueToIceVar(Inst);
     Ice::Operand *CallTarget = convertValue(Inst->getCalledValue());
     unsigned NumArgs = Inst->getNumArgOperands();
     // Note: Subzero doesn't (yet) do anything special with the Tail
     // flag in the bitcode, i.e. CallInst::isTailCall().
-    Ice::InstCall *NewInst = NULL;
-    const Ice::Intrinsics::FullIntrinsicInfo *Info = NULL;
+    Ice::InstCall *NewInst = nullptr;
+    const Ice::Intrinsics::FullIntrinsicInfo *Info = nullptr;
 
     if (const auto Target = dyn_cast<Ice::ConstantRelocatable>(CallTarget)) {
       // Check if this direct call is to an Intrinsic (starts with "llvm.")
       static const char LLVMPrefix[] = "llvm.";
       const size_t LLVMPrefixLen = strlen(LLVMPrefix);
       Ice::IceString Name = Target->getName();
       if (Name.substr(0, LLVMPrefixLen) == LLVMPrefix) {
         Ice::IceString NameSuffix = Name.substr(LLVMPrefixLen);
         Info = Ctx->getIntrinsicsInfo().find(NameSuffix);
         if (!Info) {
           report_fatal_error(std::string("Invalid PNaCl intrinsic call: ") +
                              LLVMObjectAsString(Inst));
         }
         NewInst = Ice::InstIntrinsicCall::create(Func, NumArgs, Dest,
                                                  CallTarget, Info->Info);
       }
     }
 
     // Not an intrinsic call.
-    if (NewInst == NULL) {
+    if (NewInst == nullptr) {
       NewInst = Ice::InstCall::create(Func, NumArgs, Dest, CallTarget,
                                       Inst->isTailCall());
     }
     for (unsigned i = 0; i < NumArgs; ++i) {
       NewInst->addArg(convertOperand(Inst, i));
     }
     if (Info) {
       validateIntrinsicCall(NewInst, Info);
     }
     return NewInst;
@@ skipping 70 matching lines @@
 // convertGlobalsToIce method.
 //
 // Note: this currently assumes that the given IR was verified to be
 // valid PNaCl bitcode. Othewise, the behavior is undefined.
 class LLVM2ICEGlobalsConverter : public LLVM2ICEConverter {
   LLVM2ICEGlobalsConverter(const LLVM2ICEGlobalsConverter &) = delete;
   LLVM2ICEGlobalsConverter &
   operator-(const LLVM2ICEGlobalsConverter &) = delete;
 
 public:
-  LLVM2ICEGlobalsConverter(Ice::GlobalContext *Ctx, LLVMContext &LLVMContext)
-      : LLVM2ICEConverter(Ctx, LLVMContext) {}
+  LLVM2ICEGlobalsConverter(Ice::Converter &Converter)
+      : LLVM2ICEConverter(Converter) {}
 
-  ~LLVM2ICEGlobalsConverter() { DeleteContainerSeconds(GlobalVarAddressMap); }
-
-  /// Converts global variables, and their initializers into ICE global
-  /// addresses, for module Mod. Puts corresponding converted global
-  /// addresses into GlobalAddresses.
-  void convertGlobalsToIce(Module *Mod,
-                           Ice::Translator::GlobalAddressList &GlobalAddresses);
+  /// Converts global variables, and their initializers into ICE
+  /// global variable declarations, for module Mod. Puts corresponding
+  /// converted declarations into VariableDeclarations.
+  void convertGlobalsToIce(
+      Module *Mod,
+      Ice::Translator::VariableDeclarationListType &VariableDeclarations);
 
 private:
-  typedef std::map<const GlobalVariable *, Ice::GlobalAddress *>
-      GlobalVarAddressMapType;
-  // Map from global variables to their corresponding global address.
-  GlobalVarAddressMapType GlobalVarAddressMap;
-
-  // Adds the Initializer to the list of initializers for Global address.
-  void addGlobalInitializer(Ice::GlobalAddress &Global,
+  // Adds the Initializer to the list of initializers for the Global
+  // variable declaraation.
+  void addGlobalInitializer(Ice::VariableDeclaration &Global,
                             const Constant *Initializer) {
     const bool HasOffset = false;
-    const Ice::GlobalAddress::RelocOffsetType Offset = 0;
+    const Ice::VariableDeclaration::RelocOffsetType Offset = 0;
     addGlobalInitializer(Global, Initializer, HasOffset, Offset);
   }
 
-  // Adds Initializer to the list of initializers for Global
-  // address. HasOffset is true only if Initializer is a relocation
-  // initializer and Offset should be added to the relocation.
-  void addGlobalInitializer(Ice::GlobalAddress &Global,
+  // Adds Initializer to the list of initializers for Global variable
+  // declaration.  HasOffset is true only if Initializer is a
+  // relocation initializer and Offset should be added to the
+  // relocation.
+  void addGlobalInitializer(Ice::VariableDeclaration &Global,
                             const Constant *Initializer, bool HasOffset,
-                            Ice::GlobalAddress::RelocOffsetType Offset);
-
-  // Returns the global address associated with global variable GV.
-  Ice::GlobalAddress *getGlobalVarAddress(const GlobalVariable *GV) {
-    if (GlobalVarAddressMap.find(GV) == GlobalVarAddressMap.end())
-      GlobalVarAddressMap[GV] = new Ice::GlobalAddress();
-    return GlobalVarAddressMap[GV];
-  }
+                            Ice::VariableDeclaration::RelocOffsetType Offset);
 
   // Converts the given constant C to the corresponding integer
   // literal it contains.
-  Ice::GlobalAddress::RelocOffsetType
+  Ice::VariableDeclaration::RelocOffsetType
   getIntegerLiteralConstant(const Value *C) {
     const auto CI = dyn_cast<ConstantInt>(C);
     if (CI && CI->getType()->isIntegerTy(32))
       return CI->getSExtValue();
 
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "Constant not i32 literal: " << *C;
     report_fatal_error(StrBuf.str());
     return 0;
   }
 };
 
 void LLVM2ICEGlobalsConverter::convertGlobalsToIce(
-    Module *Mod, Ice::Translator::GlobalAddressList &GlobalAddresses) {
+    Module *Mod,
+    Ice::Translator::VariableDeclarationListType &VariableDeclarations) {
   for (Module::const_global_iterator I = Mod->global_begin(),
                                      E = Mod->global_end();
        I != E; ++I) {
     if (!I->hasInitializer() && Ctx->getFlags().AllowUninitializedGlobals)
       continue;
 
-    const auto GV = dyn_cast<GlobalVariable>(I);
-    assert(GV);
+    const GlobalVariable *GV = I;
     Ice::IceString Name = GV->getName();
     if (!GV->hasInternalLinkage()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Can't define external global address: " << Name;
+      StrBuf << "Can't define external global declaration: " << Name;
       report_fatal_error(StrBuf.str());
     }
 
-    Ice::GlobalAddress *Addr = getGlobalVarAddress(GV);
-    GlobalAddresses.push_back(Addr);
-    Addr->setAlignment(GV->getAlignment());
-    Addr->setIsConstant(GV->isConstant());
-    // Note: We allow external for cross tests.
-    Addr->setIsInternal(!GV->isExternallyInitialized());
-    Addr->setName(Name);
+    Ice::GlobalDeclaration *Var = getConverter().getGlobalDeclaration(GV);
+    Ice::VariableDeclaration* VarDecl = cast<Ice::VariableDeclaration>(Var);
+    VariableDeclarations.push_back(VarDecl);
 
     const Constant *Initializer = GV->getInitializer();
     if (const auto CompoundInit = dyn_cast<ConstantStruct>(Initializer)) {
       for (ConstantStruct::const_op_iterator I = CompoundInit->op_begin(),
                                              E = CompoundInit->op_end();
            I != E; ++I) {
         if (const auto Init = dyn_cast<Constant>(I)) {
-          addGlobalInitializer(*Addr, Init);
+          addGlobalInitializer(*VarDecl, Init);
         }
       }
     } else {
-      addGlobalInitializer(*Addr, Initializer);
+      addGlobalInitializer(*VarDecl, Initializer);
     }
   }
 }
 
 void LLVM2ICEGlobalsConverter::addGlobalInitializer(
-    Ice::GlobalAddress &Global, const Constant *Initializer, bool HasOffset,
-    Ice::GlobalAddress::RelocOffsetType Offset) {
+    Ice::VariableDeclaration &Global, const Constant *Initializer,
+    bool HasOffset, Ice::VariableDeclaration::RelocOffsetType Offset) {
+  (void)HasOffset;
   assert(HasOffset || Offset == 0);
 
   if (const auto CDA = dyn_cast<ConstantDataArray>(Initializer)) {
     assert(!HasOffset && isa<IntegerType>(CDA->getElementType()) &&
            (cast<IntegerType>(CDA->getElementType())->getBitWidth() == 8));
-    Global.addInitializer(new Ice::GlobalAddress::DataInitializer(
+    Global.addInitializer(new Ice::VariableDeclaration::DataInitializer(
         CDA->getRawDataValues().data(), CDA->getNumElements()));
     return;
   }
 
   if (isa<ConstantAggregateZero>(Initializer)) {
     if (const auto AT = dyn_cast<ArrayType>(Initializer->getType())) {
       assert(!HasOffset && isa<IntegerType>(AT->getElementType()) &&
              (cast<IntegerType>(AT->getElementType())->getBitWidth() == 8));
       Global.addInitializer(
-          new Ice::GlobalAddress::ZeroInitializer(AT->getNumElements()));
+          new Ice::VariableDeclaration::ZeroInitializer(AT->getNumElements()));
     } else {
       llvm_unreachable("Unhandled constant aggregate zero type");
     }
     return;
   }
 
   if (const auto Exp = dyn_cast<ConstantExpr>(Initializer)) {
     switch (Exp->getOpcode()) {
     case Instruction::Add:
       assert(!HasOffset);
       addGlobalInitializer(Global, Exp->getOperand(0), true,
                            getIntegerLiteralConstant(Exp->getOperand(1)));
       return;
     case Instruction::PtrToInt: {
       assert(TypeConverter.convertToIceType(Exp->getType()) ==
              TypeConverter.getIcePointerType());
       const auto GV = dyn_cast<GlobalValue>(Exp->getOperand(0));
       assert(GV);
-      if (const auto Fcn = dyn_cast<Function>(GV)) {
-        Ice::GlobalAddress::RelocationAddress Addr(Fcn);
-        Global.addInitializer(
-            new Ice::GlobalAddress::RelocInitializer(Addr, Offset));
-        return;
-      } else if (const auto Var = dyn_cast<GlobalVariable>(GV)) {
-        Ice::GlobalAddress::RelocationAddress Addr(getGlobalVarAddress(Var));
-        Global.addInitializer(
-            new Ice::GlobalAddress::RelocInitializer(Addr, Offset));
-        return;
-      }
-      break;
+      const Ice::GlobalDeclaration *Addr =
+          getConverter().getGlobalDeclaration(GV);
+      Global.addInitializer(
+          new Ice::VariableDeclaration::RelocInitializer(Addr, Offset));
+      return;
     }
     default:
       break;
     }
   }
 
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Unhandled global initializer: " << Initializer;
   report_fatal_error(StrBuf.str());
 }
 
 } // end of anonymous namespace
 
 namespace Ice {
 
+void Converter::nameUnnamedGlobalVariables(Module *Mod) {
+  const IceString &GlobalPrefix = Flags.DefaultGlobalPrefix;
+  if (GlobalPrefix.empty())
+    return;
+  uint32_t NameIndex = 0;
+  Ostream &errs = Ctx->getStrDump();
+  for (auto V = Mod->global_begin(), E = Mod->global_end(); V != E; ++V) {
+    if (!V->hasName()) {
+      V->setName(createUnnamedName(GlobalPrefix, NameIndex));
+      ++NameIndex;
+    } else {
+      checkIfUnnamedNameSafe(V->getName(), "global", GlobalPrefix, errs);
+    }
+  }
+}
+
+void Converter::nameUnnamedFunctions(Module *Mod) {
+  const IceString &FunctionPrefix = Flags.DefaultFunctionPrefix;
+  if (FunctionPrefix.empty())
+    return;
+  uint32_t NameIndex = 0;
+  Ostream &errs = Ctx->getStrDump();
+  for (Function &F : *Mod) {
+    if (!F.hasName()) {
+      F.setName(createUnnamedName(FunctionPrefix, NameIndex));
+      ++NameIndex;
+    } else {
+      checkIfUnnamedNameSafe(F.getName(), "function", FunctionPrefix, errs);
+    }
+  }
+}
+
 void Converter::convertToIce() {
   TimerMarker T(TimerStack::TT_convertToIce, Ctx);
-  nameUnnamedGlobalAddresses(Mod);
+  nameUnnamedGlobalVariables(Mod);
   nameUnnamedFunctions(Mod);
+  installGlobalDeclarations(Mod);
   convertGlobals(Mod);
   convertFunctions();
 }
 
+GlobalDeclaration *Converter::getGlobalDeclaration(const GlobalValue *V) {
+  GlobalDeclarationMapType::const_iterator Pos = GlobalDeclarationMap.find(V);
+  if (Pos == GlobalDeclarationMap.end()) {
+    std::string Buffer;
+    raw_string_ostream StrBuf(Buffer);
+    StrBuf << "Can't find global declaration for: " << V->getName();
+    report_fatal_error(StrBuf.str());
+  }
+  return Pos->second;
+}
+
+void Converter::installGlobalDeclarations(Module *Mod) {
+  const TypeConverter Converter(Mod->getContext());
+  // Install function declarations.
+  for (const Function &Func : *Mod) {
+    FuncSigType Signature;
+    FunctionType *FuncType = Func.getFunctionType();
+    Signature.setReturnType(
+        Converter.convertToIceType(FuncType->getReturnType()));
+    for (size_t I = 0; I < FuncType->getNumParams(); ++I) {
+      Signature.appendArgType(
+          Converter.convertToIceType(FuncType->getParamType(I)));
+    }
+    FunctionDeclaration *IceFunc = FunctionDeclaration::create(
+        Ctx, Signature, Func.getCallingConv(), Func.getLinkage(), Func.empty());
+    IceFunc->setName(Func.getName());
+    GlobalDeclarationMap[&Func] = IceFunc;
+  }
+  // Install global variable declarations.
+  for (Module::const_global_iterator I = Mod->global_begin(),
+                                     E = Mod->global_end();
+       I != E; ++I) {
+    const GlobalVariable *GV = I;
+    VariableDeclaration *Var = VariableDeclaration::create(Ctx);
+    Var->setName(GV->getName());
+    Var->setAlignment(GV->getAlignment());
+    Var->setIsConstant(GV->isConstant());
+    // Note: We allow external for cross tests.
+    // TODO(kschimpf) Put behind flag AllowUninitializedGlobals.
+    Var->setIsInternal(!GV->isExternallyInitialized());
+    GlobalDeclarationMap[GV] = Var;
+  }
+}
+
 void Converter::convertGlobals(Module *Mod) {
-  LLVM2ICEGlobalsConverter GlobalsConverter(Ctx, Mod->getContext());
-  Translator::GlobalAddressList GlobalAddresses;
-  GlobalsConverter.convertGlobalsToIce(Mod, GlobalAddresses);
-  lowerGlobals(GlobalAddresses);
+  LLVM2ICEGlobalsConverter GlobalsConverter(*this);
+  Translator::VariableDeclarationListType VariableDeclarations;
+  GlobalsConverter.convertGlobalsToIce(Mod, VariableDeclarations);
+  lowerGlobals(VariableDeclarations);
 }
 
 void Converter::convertFunctions() {
   TimerStackIdT StackID = GlobalContext::TSK_Funcs;
   for (const Function &I : *Mod) {
     if (I.empty())
       continue;
 
     TimerIdT TimerID = 0;
     if (Ctx->getFlags().TimeEachFunction) {
       TimerID = Ctx->getTimerID(StackID, I.getName());
       Ctx->pushTimer(TimerID, StackID);
     }
-    LLVM2ICEFunctionConverter FunctionConverter(Ctx, Mod->getContext());
+    LLVM2ICEFunctionConverter FunctionConverter(*this);
 
     Cfg *Fcn = FunctionConverter.convertFunction(&I);
     translateFcn(Fcn);
     if (Ctx->getFlags().TimeEachFunction)
       Ctx->popTimer(TimerID, StackID);
   }
 
   emitConstants();
 }
 
 } // end of namespace Ice