[RFC-ONLY][SKETCH][NOREVIEW] Heterogenous LLVM-IR modules

[jdoerfert]

Summary

Allow to specify devices with their target triples.
Add an optional device number to global values. .ll/.bc reader/writers.

llvm/include/llvm/Bitcode/LLVMBitCodes.h

enum ModuleCodes {
   // SOURCE_FILENAME: [namechar x N]
   MODULE_CODE_SOURCE_FILENAME = 16,
 
   // HASH: [5*i32]
   MODULE_CODE_HASH = 17,
 
   // IFUNC: [ifunc value type, addrspace, resolver val#, linkage, visibility]
   MODULE_CODE_IFUNC = 18,
+
+  MODULE_CODE_DEVICE_TRIPLE = 19,      // TRIPLE:      [no, strchr x N]
 };
 
 /// PARAMATTR blocks have code for defining a parameter attribute set.
 enum AttributeCodes {
   // Deprecated, but still needed to read old bitcode files.
   PARAMATTR_CODE_ENTRY_OLD = 1, // ENTRY: [paramidx0, attr0,
                                 //         paramidx1, attr1...]
   PARAMATTR_CODE_ENTRY = 2,     // ENTRY: [attrgrp0, attrgrp1, ...]

llvm/include/llvm/IR/GlobalValue.h

 protected:
   GlobalValue(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
               LinkageTypes Linkage, const Twine &Name, unsigned AddressSpace)
       : Constant(PointerType::get(Ty, AddressSpace), VTy, Ops, NumOps),
         ValueType(Ty), Visibility(DefaultVisibility),
         UnnamedAddrVal(unsigned(UnnamedAddr::None)),
         DllStorageClass(DefaultStorageClass), ThreadLocal(NotThreadLocal),
         HasLLVMReservedName(false), IsDSOLocal(false), HasPartition(false),
-        IntID((Intrinsic::ID)0U), Parent(nullptr) {
+        DeviceNo(0), IntID((Intrinsic::ID)0U), Parent(nullptr) {
     setLinkage(Linkage);
     setName(Name);
   }
 
   Type *ValueType;
 
-  static const unsigned GlobalValueSubClassDataBits = 16;
+  static const unsigned GlobalValueSubClassDataBits = 11;
 
   // All bitfields use unsigned as the underlying type so that MSVC will pack
   // them.
   unsigned Linkage : 4;       // The linkage of this global
   unsigned Visibility : 2;    // The visibility style of this global
   unsigned UnnamedAddrVal : 2; // This value's address is not significant
   unsigned DllStorageClass : 2; // DLL storage class
 
   unsigned ThreadLocal : 3; // Is this symbol "Thread Local", if so, what is
                             // the desired model?
 
   /// True if the function's name starts with "llvm.".  This corresponds to the
   /// value of Function::isIntrinsic(), which may be true even if
   /// Function::intrinsicID() returns Intrinsic::not_intrinsic.
   unsigned HasLLVMReservedName : 1;
 
   /// If true then there is a definition within the same linkage unit and that
   /// definition cannot be runtime preempted.
   unsigned IsDSOLocal : 1;
 
   /// True if this symbol has a partition name assigned (see
   /// https://lld.llvm.org/Partitions.html).
   unsigned HasPartition : 1;
 
+  /// The device # this global is associated with, 0 for host/default device,
+  /// 1-31 for other devices. A device is in this context a reference to a
+  /// different target (triple).
+  unsigned DeviceNo : 5;
+
 private:
   // Give subclasses access to what otherwise would be wasted padding.
-  // (16 + 4 + 2 + 2 + 2 + 3 + 1 + 1 + 1) == 32.
+  // (11 + 4 + 2 + 2 + 2 + 3 + 1 + 1 + 1 + 5) == 32.
   unsigned SubClassData : GlobalValueSubClassDataBits;
 
   friend class Constant;
 
   void destroyConstantImpl();
   Value *handleOperandChangeImpl(Value *From, Value *To);
 
   /// Returns true if the definition of this global may be replaced by a
public:
 
   bool hasComdat() const { return getComdat() != nullptr; }
   const Comdat *getComdat() const;
   Comdat *getComdat() {
     return const_cast<Comdat *>(
                            static_cast<const GlobalValue *>(this)->getComdat());
   }
 
+  /// Return the device number this global is associated with, 0 for
+  /// host/default device.
+  unsigned char getDeviceNo() const { return DeviceNo; }
+
+  /// Set the device number this global is associated with.
+  void setDeviceNo(unsigned DeviceNo) {
+    assert(DeviceNo < 32 && "device numbers have to be between 0 and 31");
+    this->DeviceNo = DeviceNo;
+  }
+
   VisibilityTypes getVisibility() const { return VisibilityTypes(Visibility); }
   bool hasDefaultVisibility() const { return Visibility == DefaultVisibility; }
   bool hasHiddenVisibility() const { return Visibility == HiddenVisibility; }
   bool hasProtectedVisibility() const {
     return Visibility == ProtectedVisibility;
   }
   void setVisibility(VisibilityTypes V) {
     assert((!hasLocalLinkage() || V == DefaultVisibility) &&

llvm/include/llvm/IR/Module.h

private:
   LLVMContext &Context;           ///< The LLVMContext from which types and
                                   ///< constants are allocated.
   GlobalListType GlobalList;      ///< The Global Variables in the module
   FunctionListType FunctionList;  ///< The Functions in the module
   AliasListType AliasList;        ///< The Aliases in the module
   IFuncListType IFuncList;        ///< The IFuncs in the module
   NamedMDListType NamedMDList;    ///< The named metadata in the module
   std::string GlobalScopeAsm;     ///< Inline Asm at global scope.
-  std::unique_ptr<ValueSymbolTable> ValSymTab; ///< Symbol table for values
+  SmallVector<std::unique_ptr<ValueSymbolTable>, 2>
+      ValSymTab;                  ///< Symbol table(s) for values
   ComdatSymTabType ComdatSymTab;  ///< Symbol table for COMDATs
   std::unique_ptr<MemoryBuffer>
   OwnedMemoryBuffer;              ///< Memory buffer directly owned by this
                                   ///< module, for legacy clients only.
   std::unique_ptr<GVMaterializer>
   Materializer;                   ///< Used to materialize GlobalValues
   std::string ModuleID;           ///< Human readable identifier for the module
   std::string SourceFileName;     ///< Original source file name for module,
                                   ///< recorded in bitcode.
-  std::string TargetTriple;       ///< Platform target triple Module compiled on
+  SmallVector<std::string, 1>
+  TargetTriples;                  ///< Platform target triple Module compiled on
                                   ///< Format: (arch)(sub)-(vendor)-(sys0-(abi)
   NamedMDSymTabType NamedMDSymTab;  ///< NamedMDNode names.
   DataLayout DL;                  ///< DataLayout associated with the module
 
   friend class Constant;
 
 /// @}
 /// @name Constructors
/// @{
   /// equivalent to getDataLayout()->getStringRepresentation().
   const std::string &getDataLayoutStr() const {
     return DL.getStringRepresentation();
   }
 
   /// Get the data layout for the module's target platform.
   const DataLayout &getDataLayout() const;
 
-  /// Get the target triple which is a string describing the target host.
+  /// Get the target triple which is a string describing the target device with
+  /// number \p DeviceNo. If more than a single device is present in the module the
+  /// device number is required, otherwise it can be ommited.
+  ///
   /// @returns a string containing the target triple.
-  const std::string &getTargetTriple() const { return TargetTriple; }
+  const std::string &getTargetTriple(int DeviceNo = 0) const {
+    return TargetTriples[DeviceNo];
+  }
 
   /// Get the global data context.
   /// @returns LLVMContext - a container for LLVM's global information
   LLVMContext &getContext() const { return Context; }
 
   /// Get any module-scope inline assembly blocks.
   /// @returns a string containing the module-scope inline assembly blocks.
   const std::string &getModuleInlineAsm() const { return GlobalScopeAsm; }
/// @{
   /// Set the module's original source file name.
   void setSourceFileName(StringRef Name) { SourceFileName = std::string(Name); }
 
   /// Set the data layout
   void setDataLayout(StringRef Desc);
   void setDataLayout(const DataLayout &Other);
 
   /// Set the target triple.
-  void setTargetTriple(StringRef T) { TargetTriple = std::string(T); }
+  void setTargetTriple(StringRef T, int DeviceNo = 0);
+
+  /// TODO
+  size_t getNumTargetTriples() const { return TargetTriples.size(); }
 
   /// Set the module-scope inline assembly blocks.
   /// A trailing newline is added if the input doesn't have one.
   void setModuleInlineAsm(StringRef Asm) {
     GlobalScopeAsm = std::string(Asm);
     if (!GlobalScopeAsm.empty() && GlobalScopeAsm.back() != '\n')
       GlobalScopeAsm += '\n';
   }
 
   /// Append to the module-scope inline assembly blocks.
   /// A trailing newline is added if the input doesn't have one.
   void appendModuleInlineAsm(StringRef Asm) {
     GlobalScopeAsm += Asm;
     if (!GlobalScopeAsm.empty() && GlobalScopeAsm.back() != '\n')
       GlobalScopeAsm += '\n';
   }
 
 /// @}
 /// @name Generic Value Accessors
 /// @{
 
   /// Return the global value in the module with the specified name, of
   /// arbitrary type. This method returns null if a global with the specified
   /// name is not found.
-  GlobalValue *getNamedValue(StringRef Name) const;
+  GlobalValue *getNamedValue(StringRef Name, unsigned DeviceNo = 0) const;
 
   /// Return a unique non-zero ID for the specified metadata kind. This ID is
   /// uniqued across modules in the current LLVMContext.
   unsigned getMDKindID(StringRef Name) const;
 
   /// Populate client supplied SmallVector with the name for custom metadata IDs
   /// registered in this LLVMContext.
   void getMDKindNames(SmallVectorImpl<StringRef> &Result) const;

 /// @}
 /// @name Global Variable Accessors
 /// @{
 
   /// Look up the specified global variable in the module symbol table. If it
   /// does not exist, return null. If AllowInternal is set to true, this
   /// function will return types that have InternalLinkage. By default, these
   /// types are not returned.
-  GlobalVariable *getGlobalVariable(StringRef Name) const {
-    return getGlobalVariable(Name, false);
+  GlobalVariable *getGlobalVariable(StringRef Name, unsigned DeviceNo = 0) const {
+    return getGlobalVariable(Name, false, DeviceNo);
   }
 
-  GlobalVariable *getGlobalVariable(StringRef Name, bool AllowInternal) const;
+  GlobalVariable *getGlobalVariable(StringRef Name, bool AllowInternal, unsigned DeviceNo = 0) const;
 
   GlobalVariable *getGlobalVariable(StringRef Name,
-                                    bool AllowInternal = false) {
+                                    bool AllowInternal = false, unsigned DeviceNo = 0) {
     return static_cast<const Module *>(this)->getGlobalVariable(Name,
-                                                                AllowInternal);
+                                                                AllowInternal, DeviceNo);
   }
 
   /// Return the global variable in the module with the specified name, of
   /// arbitrary type. This method returns null if a global with the specified
   /// name is not found.
-  const GlobalVariable *getNamedGlobal(StringRef Name) const {
-    return getGlobalVariable(Name, true);
+  const GlobalVariable *getNamedGlobal(StringRef Name, unsigned DeviceNo = 0) const {
+    return getGlobalVariable(Name, true, DeviceNo);
   }
-  GlobalVariable *getNamedGlobal(StringRef Name) {
+  GlobalVariable *getNamedGlobal(StringRef Name, unsigned DeviceNo = 0) {
     return const_cast<GlobalVariable *>(
-                       static_cast<const Module *>(this)->getNamedGlobal(Name));
+                       static_cast<const Module *>(this)->getNamedGlobal(Name, DeviceNo));
   }
 
   /// Look up the specified global in the module symbol table.
   /// If it does not exist, invoke a callback to create a declaration of the
   /// global and return it. The global is constantexpr casted to the expected
   /// type if necessary.
   Constant *
   getOrInsertGlobal(StringRef Name, Type *Ty,
/// @{
   /// Get the Module's list of named metadata.
   NamedMDListType        &getNamedMDList()            { return NamedMDList; }
 
   static NamedMDListType Module::*getSublistAccess(NamedMDNode*) {
     return &Module::NamedMDList;
   }
 
   /// Get the symbol table of global variable and function identifiers
-  const ValueSymbolTable &getValueSymbolTable() const { return *ValSymTab; }
+  const ValueSymbolTable &getValueSymbolTable(unsigned DeviceNo = 0) const { return *(ValSymTab[DeviceNo]); }
   /// Get the Module's symbol table of global variable and function identifiers.
-  ValueSymbolTable       &getValueSymbolTable()       { return *ValSymTab; }
+  ValueSymbolTable       &getValueSymbolTable(unsigned DeviceNo = 0)       { return *(ValSymTab[DeviceNo]); }
 
   /// Get the Module's symbol table for COMDATs (constant).
   const ComdatSymTabType &getComdatSymbolTable() const { return ComdatSymTab; }
   /// Get the Module's symbol table for COMDATs.
   ComdatSymTabType &getComdatSymbolTable() { return ComdatSymTab; }
 
 /// @}
 /// @name Global Variable Iteration

llvm/lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(to);
   KEYWORD(caller);
   KEYWORD(within);
   KEYWORD(from);
   KEYWORD(tail);
   KEYWORD(musttail);
   KEYWORD(notail);
   KEYWORD(target);
+  KEYWORD(device);
   KEYWORD(triple);
   KEYWORD(source_filename);
   KEYWORD(unwind);
   KEYWORD(deplibs);             // FIXME: Remove in 4.0.
   KEYWORD(datalayout);
   KEYWORD(volatile);
   KEYWORD(atomic);
   KEYWORD(unordered);

llvm/lib/AsmParser/LLParser.h

private:
     bool ParseOptionalUnnamedAddr(GlobalVariable::UnnamedAddr &UnnamedAddr);
     bool ParseOptionalAddrSpace(unsigned &AddrSpace, unsigned DefaultAS = 0);
     bool ParseOptionalProgramAddrSpace(unsigned &AddrSpace) {
       return ParseOptionalAddrSpace(
           AddrSpace, M->getDataLayout().getProgramAddressSpace());
     };
     bool ParseOptionalParamAttrs(AttrBuilder &B);
     bool ParseOptionalReturnAttrs(AttrBuilder &B);
+    bool ParseOptionalDevice(unsigned &DeviceNo);
     bool ParseOptionalLinkage(unsigned &Res, bool &HasLinkage,
                               unsigned &Visibility, unsigned &DLLStorageClass,
                               bool &DSOLocal);
     void ParseOptionalDSOLocal(bool &DSOLocal);
     void ParseOptionalVisibility(unsigned &Res);
     void ParseOptionalDLLStorageClass(unsigned &Res);
     bool ParseOptionalCallingConv(unsigned &CC);
     bool ParseOptionalAlignment(MaybeAlign &Alignment,
private:
     }
 
     // Top-Level Entities
     bool ParseTopLevelEntities();
     bool ValidateEndOfModule(bool UpgradeDebugInfo);
     bool ValidateEndOfIndex();
     bool ParseTargetDefinitions();
     bool ParseTargetDefinition();
+    bool ParseDeviceDefinition();
     bool ParseModuleAsm();
     bool ParseSourceFileName();
     bool ParseDepLibs();        // FIXME: Remove in 4.0.
     bool ParseUnnamedType();
     bool ParseNamedType();
     bool ParseDeclare();
     bool ParseDefine();
 
     bool ParseGlobalType(bool &IsConstant);
     bool ParseUnnamedGlobal();
     bool ParseNamedGlobal();
-    bool ParseGlobal(const std::string &Name, LocTy NameLoc, unsigned Linkage,
-                     bool HasLinkage, unsigned Visibility,
+    bool ParseGlobal(const std::string &Name, LocTy NameLoc, unsigned DeviceNo,
+                     unsigned Linkage, bool HasLinkage, unsigned Visibility,
                      unsigned DLLStorageClass, bool DSOLocal,
                      GlobalVariable::ThreadLocalMode TLM,
                      GlobalVariable::UnnamedAddr UnnamedAddr);
     bool parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
-                             unsigned L, unsigned Visibility,
+                             unsigned DeviceNo, unsigned L, unsigned Visibility,
                              unsigned DLLStorageClass, bool DSOLocal,
                              GlobalVariable::ThreadLocalMode TLM,
                              GlobalVariable::UnnamedAddr UnnamedAddr);
     bool parseComdat();
     bool ParseStandaloneMetadata();
     bool ParseNamedMetadata();
     bool ParseMDString(MDString *&Result);
     bool ParseMDNodeID(MDNode *&Result);

llvm/lib/AsmParser/LLParser.cpp

 
 bool LLParser::ParseTargetDefinitions() {
   while (true) {
     switch (Lex.getKind()) {
     case lltok::kw_target:
       if (ParseTargetDefinition())
         return true;
       break;
+    case lltok::kw_device:
+      if (ParseDeviceDefinition())
+        return true;
+      break;
     case lltok::kw_source_filename:
       if (ParseSourceFileName())
         return true;
       break;
     default:
       return false;
     }
   }
if (ParseToken(lltok::equal, "expected '=' after target datalayout") ||
         ParseStringConstant(Str))
       return true;
     M->setDataLayout(Str);
     return false;
   }
 }
 
 /// toplevelentity
+///   ::= ['device' uint32] 'triple' '=' STRINGCONSTANT
+bool LLParser::ParseDeviceDefinition() {
+  assert(Lex.getKind() == lltok::kw_device);
+  unsigned DeviceNo = 0;
+  if (ParseOptionalDevice(DeviceNo))
+    return true;
+  std::string Str;
+  switch (Lex.getKind()) {
+  default: return TokError("unknown target property");
+  case lltok::kw_triple:
+    Lex.Lex();
+    if (ParseToken(lltok::equal, "expected '=' after target triple") ||
+        ParseStringConstant(Str))
+      return true;
+    M->setTargetTriple(Str, DeviceNo);
+    return false;
+  }
+}
+
+/// toplevelentity
 ///   ::= 'source_filename' '=' STRINGCONSTANT
 bool LLParser::ParseSourceFileName() {
   assert(Lex.getKind() == lltok::kw_source_filename);
   Lex.Lex();
   if (ParseToken(lltok::equal, "expected '=' after source_filename") ||
       ParseStringConstant(SourceFileName))
     return true;
   if (M)
bool LLParser::ParseOptionalUnnamedAddr(
   return false;
 }
 
 /// ParseUnnamedGlobal:
 ///   OptionalVisibility (ALIAS | IFUNC) ...
 ///   OptionalLinkage OptionalPreemptionSpecifier OptionalVisibility
 ///   OptionalDLLStorageClass
 ///                                                     ...   -> global variable
-///   GlobalID '=' OptionalVisibility (ALIAS | IFUNC) ...
-///   GlobalID '=' OptionalLinkage OptionalPreemptionSpecifier OptionalVisibility
-///                OptionalDLLStorageClass
+///   GlobalID '=' OptionalDevice OptionalVisibility (ALIAS | IFUNC) ...
+///   GlobalID '=' OptionalDevice OptionalLinkage OptionalPreemptionSpecifier
+///                OptionalVisibility OptionalDLLStorageClass
 ///                                                     ...   -> global variable
 bool LLParser::ParseUnnamedGlobal() {
   unsigned VarID = NumberedVals.size();
   std::string Name;
   LocTy NameLoc = Lex.getLoc();
 
   // Handle the GlobalID form.
   if (Lex.getKind() == lltok::GlobalID) {
     if (Lex.getUIntVal() != VarID)
       return Error(Lex.getLoc(), "variable expected to be numbered '%" +
                    Twine(VarID) + "'");
     Lex.Lex(); // eat GlobalID;
 
     if (ParseToken(lltok::equal, "expected '=' after name"))
       return true;
   }
 
+  unsigned DeviceNo;
   bool HasLinkage;
   unsigned Linkage, Visibility, DLLStorageClass;
   bool DSOLocal;
   GlobalVariable::ThreadLocalMode TLM;
   GlobalVariable::UnnamedAddr UnnamedAddr;
-  if (ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
+  if (ParseOptionalDevice(DeviceNo) ||
+      ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
                            DSOLocal) ||
       ParseOptionalThreadLocal(TLM) || ParseOptionalUnnamedAddr(UnnamedAddr))
     return true;
 
   if (Lex.getKind() != lltok::kw_alias && Lex.getKind() != lltok::kw_ifunc)
-    return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
+    return ParseGlobal(Name, NameLoc, DeviceNo, Linkage, HasLinkage, Visibility,
                        DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
 
-  return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
+  return parseIndirectSymbol(Name, NameLoc, DeviceNo, Linkage, Visibility,
                              DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
 }
 
 /// ParseNamedGlobal:
-///   GlobalVar '=' OptionalVisibility (ALIAS | IFUNC) ...
-///   GlobalVar '=' OptionalLinkage OptionalPreemptionSpecifier
+///   GlobalVar '=' OptionalDevice OptionalVisibility (ALIAS | IFUNC) ...
+///   GlobalVar '=' OptionalDevice OptionalLinkage OptionalPreemptionSpecifier
 ///                 OptionalVisibility OptionalDLLStorageClass
 ///                                                     ...   -> global variable
 bool LLParser::ParseNamedGlobal() {
   assert(Lex.getKind() == lltok::GlobalVar);
   LocTy NameLoc = Lex.getLoc();
   std::string Name = Lex.getStrVal();
   Lex.Lex();
 
+  unsigned DeviceNo;
   bool HasLinkage;
   unsigned Linkage, Visibility, DLLStorageClass;
   bool DSOLocal;
   GlobalVariable::ThreadLocalMode TLM;
   GlobalVariable::UnnamedAddr UnnamedAddr;
   if (ParseToken(lltok::equal, "expected '=' in global variable") ||
+      ParseOptionalDevice(DeviceNo) ||
       ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
                            DSOLocal) ||
       ParseOptionalThreadLocal(TLM) || ParseOptionalUnnamedAddr(UnnamedAddr))
     return true;
 
   if (Lex.getKind() != lltok::kw_alias && Lex.getKind() != lltok::kw_ifunc)
-    return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
+    return ParseGlobal(Name, NameLoc, DeviceNo, Linkage, HasLinkage, Visibility,
                        DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
 
-  return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
+  return parseIndirectSymbol(Name, NameLoc, DeviceNo, Linkage, Visibility,
                              DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
 }
 
 bool LLParser::parseComdat() {
   assert(Lex.getKind() == lltok::ComdatVar);
   std::string Name = Lex.getStrVal();
   LocTy NameLoc = Lex.getLoc();
   Lex.Lex();

 ///   ::= TypeAndValue
 ///
 /// IndirectSymbolAttr
 ///   ::= ',' 'partition' StringConstant
 ///
 /// Everything through OptionalUnnamedAddr has already been parsed.
 ///
 bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
-                                   unsigned L, unsigned Visibility,
+                                   unsigned DeviceNo, unsigned L,
+                                   unsigned Visibility,
                                    unsigned DLLStorageClass, bool DSOLocal,
                                    GlobalVariable::ThreadLocalMode TLM,
                                    GlobalVariable::UnnamedAddr UnnamedAddr) {
   bool IsAlias;
   if (Lex.getKind() == lltok::kw_alias)
     IsAlias = true;
   else if (Lex.getKind() == lltok::kw_ifunc)
     IsAlias = false;
bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
   if (IsAlias)
     GA.reset(GlobalAlias::create(Ty, AddrSpace,
                                  (GlobalValue::LinkageTypes)Linkage, Name,
                                  Aliasee, /*Parent*/ nullptr));
   else
     GA.reset(GlobalIFunc::create(Ty, AddrSpace,
                                  (GlobalValue::LinkageTypes)Linkage, Name,
                                  Aliasee, /*Parent*/ nullptr));
+  GA->setDeviceNo(DeviceNo);
   GA->setThreadLocalMode(TLM);
   GA->setVisibility((GlobalValue::VisibilityTypes)Visibility);
   GA->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
   GA->setUnnamedAddr(UnnamedAddr);
   maybeSetDSOLocal(DSOLocal, *GA);
 
   // At this point we've parsed everything except for the IndirectSymbolAttrs.
   // Now parse them if there are any.

 ///       OptionalDLLStorageClass OptionalThreadLocal OptionalUnnamedAddr
 ///       OptionalAddrSpace OptionalExternallyInitialized GlobalType Type
 ///       Const OptionalAttrs
 ///
 /// Everything up to and including OptionalUnnamedAddr has been parsed
 /// already.
 ///
 bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
-                           unsigned Linkage, bool HasLinkage,
+                           unsigned DeviceNo, unsigned Linkage, bool HasLinkage,
                            unsigned Visibility, unsigned DLLStorageClass,
                            bool DSOLocal, GlobalVariable::ThreadLocalMode TLM,
                            GlobalVariable::UnnamedAddr UnnamedAddr) {
   if (!isValidVisibilityForLinkage(Visibility, Linkage))
     return Error(NameLoc,
                  "symbol with local linkage must have default visibility");
 
   unsigned AddrSpace;
bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
 
   if (Name.empty())
     NumberedVals.push_back(GV);
 
   // Set the parsed properties on the global.
   if (Init)
     GV->setInitializer(Init);
   GV->setConstant(IsConstant);
+  GV->setDeviceNo(DeviceNo);
   GV->setLinkage((GlobalValue::LinkageTypes)Linkage);
   maybeSetDSOLocal(DSOLocal, *GV);
   GV->setVisibility((GlobalValue::VisibilityTypes)Visibility);
   GV->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
   GV->setExternallyInitialized(IsExternallyInitialized);
   GV->setThreadLocalMode(TLM);
   GV->setUnnamedAddr(UnnamedAddr);
 
case lltok::kw_common:
     return GlobalValue::CommonLinkage;
   case lltok::kw_extern_weak:
     return GlobalValue::ExternalWeakLinkage;
   case lltok::kw_external:
     return GlobalValue::ExternalLinkage;
   }
 }
 
+/// ParseOptionalDevice
+///   ::= /*empty*/
+///   ::= 'device uint32 '
+bool LLParser::ParseOptionalDevice(unsigned &DeviceNo) {
+  DeviceNo = 0;
+  if (!EatIfPresent(lltok::kw_device))
+    return false;
+  const auto &DeviceNoLoc = Lex.getLoc();
+  if (ParseUInt32(DeviceNo))
+    return true;
+  if (DeviceNo == 0 || DeviceNo > 31)
+    return Error(DeviceNoLoc, "device numbers have to be between 1 and 31");
+  return false;
+}
+
 /// ParseOptionalLinkage
 ///   ::= /*empty*/
 ///   ::= 'private'
 ///   ::= 'internal'
 ///   ::= 'weak'
 ///   ::= 'weak_odr'
 ///   ::= 'linkonce'
 ///   ::= 'linkonce_odr'
bool LLParser::ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
   if (ParseTypeAndValue(V, PFS)) return true;
   if (!isa<BasicBlock>(V))
     return Error(Loc, "expected a basic block");
   BB = cast<BasicBlock>(V);
   return false;
 }
 
 /// FunctionHeader
-///   ::= OptionalLinkage OptionalPreemptionSpecifier OptionalVisibility
-///       OptionalCallingConv OptRetAttrs OptUnnamedAddr Type GlobalName
-///       '(' ArgList ')' OptAddrSpace OptFuncAttrs OptSection OptionalAlign
-///       OptGC OptionalPrefix OptionalPrologue OptPersonalityFn
+///   ::= OptionalDevice OptionalLinkage OptionalPreemptionSpecifier
+///       OptionalVisibility OptionalCallingConv OptRetAttrs OptUnnamedAddr Type
+///       GlobalName '(' ArgList ')' OptAddrSpace OptFuncAttrs OptSection
+///       OptionalAlign OptGC OptionalPrefix OptionalPrologue OptPersonalityFn
 bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
   // Parse the linkage.
   LocTy LinkageLoc = Lex.getLoc();
+  unsigned DeviceNo;
   unsigned Linkage;
   unsigned Visibility;
   unsigned DLLStorageClass;
   bool DSOLocal;
   AttrBuilder RetAttrs;
   unsigned CC;
   bool HasLinkage;
   Type *RetType = nullptr;
   LocTy RetTypeLoc = Lex.getLoc();
-  if (ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
+  if (ParseOptionalDevice(DeviceNo) ||
+      ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
                            DSOLocal) ||
       ParseOptionalCallingConv(CC) || ParseOptionalReturnAttrs(RetAttrs) ||
       ParseType(RetType, RetTypeLoc, true /*void allowed*/))
     return true;
 
   // Verify that the linkage is ok.
   switch ((GlobalValue::LinkageTypes)Linkage) {
   case GlobalValue::ExternalLinkage:
bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
   else // Move the forward-reference to the correct spot in the module.
     M->getFunctionList().splice(M->end(), M->getFunctionList(), Fn);
 
   assert(Fn->getAddressSpace() == AddrSpace && "Created function in wrong AS");
 
   if (FunctionName.empty())
     NumberedVals.push_back(Fn);
 
+  Fn->setDeviceNo(DeviceNo);
   Fn->setLinkage((GlobalValue::LinkageTypes)Linkage);
   maybeSetDSOLocal(DSOLocal, *Fn);
   Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility);
   Fn->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
   Fn->setCallingConv(CC);
   Fn->setAttributes(PAL);
   Fn->setUnnamedAddr(UnnamedAddr);
   Fn->setAlignment(MaybeAlign(Alignment));

llvm/lib/AsmParser/LLToken.h

enum Kind {
   kw_caller,
   kw_within,
   kw_from,
   kw_tail,
   kw_musttail,
   kw_notail,
   kw_target,
   kw_triple,
+  kw_device,
   kw_source_filename,
   kw_unwind,
   kw_deplibs, // FIXME: Remove in 4.0
   kw_datalayout,
   kw_volatile,
   kw_atomic,
   kw_unordered,
   kw_monotonic,

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

if (GV->hasLocalLinkage() ||
       (!GV->hasDefaultVisibility() && !GV->hasExternalWeakLinkage()))
     GV->setDSOLocal(true);
 }
 
 Error BitcodeReader::parseGlobalVarRecord(ArrayRef<uint64_t> Record) {
   // v1: [pointer type, isconst, initid, linkage, alignment, section,
   // visibility, threadlocal, unnamed_addr, externally_initialized,
   // dllstorageclass, comdat, attributes, preemption specifier,
-  // partition strtab offset, partition strtab size] (name in VST)
+  // partition strtab offset, partition strtab size, device #] (name in VST)
   // v2: [strtab_offset, strtab_size, v1]
   StringRef Name;
   std::tie(Name, Record) = readNameFromStrtab(Record);
 
   if (Record.size() < 6)
     return error("Invalid record");
   Type *FullTy = getFullyStructuredTypeByID(Record[0]);
   Type *Ty = flattenPointerTypes(FullTy);
if (Record.size() > 13) {
     NewGV->setDSOLocal(getDecodedDSOLocal(Record[13]));
   }
   inferDSOLocal(NewGV);
 
   // Check whether we have enough values to read a partition name.
   if (Record.size() > 15)
     NewGV->setPartition(StringRef(Strtab.data() + Record[14], Record[15]));
 
+  if (Record.size() > 16) {
+    if (Record[16] <= 0 || Record[16] > 31)
+      return error("Invalid ID");
+    NewGV->setDeviceNo(Record[16]);
+  }
+
   return Error::success();
 }
 
 Error BitcodeReader::parseFunctionRecord(ArrayRef<uint64_t> Record) {
   // v1: [type, callingconv, isproto, linkage, paramattr, alignment, section,
   // visibility, gc, unnamed_addr, prologuedata, dllstorageclass, comdat,
-  // prefixdata,  personalityfn, preemption specifier, addrspace] (name in VST)
+  // prefixdata,  personalityfn, preemption specifier, addrspace,
+  // device #] (name in VST)
   // v2: [strtab_offset, strtab_size, v1]
   StringRef Name;
   std::tie(Name, Record) = readNameFromStrtab(Record);
 
   if (Record.size() < 8)
     return error("Invalid record");
   Type *FullFTy = getFullyStructuredTypeByID(Record[0]);
   Type *FTy = flattenPointerTypes(FullFTy);
Error BitcodeReader::parseFunctionRecord(ArrayRef<uint64_t> Record) {
 
   // If this is a function with a body, remember the prototype we are
   // creating now, so that we can match up the body with them later.
   if (!isProto) {
     Func->setIsMaterializable(true);
     FunctionsWithBodies.push_back(Func);
     DeferredFunctionInfo[Func] = 0;
   }
+
+  if (Record.size() > 19) {
+    if (Record[19] <= 0 || Record[19] > 31)
+      return error("Invalid ID");
+    Func->setDeviceNo(Record[19]);
+  }
+
   return Error::success();
 }
 
 Error BitcodeReader::parseGlobalIndirectSymbolRecord(
     unsigned BitCode, ArrayRef<uint64_t> Record) {
   // v1 ALIAS_OLD: [alias type, aliasee val#, linkage] (name in VST)
   // v1 ALIAS: [alias type, addrspace, aliasee val#, linkage, visibility,
   // dllstorageclass, threadlocal, unnamed_addr,
-  // preemption specifier] (name in VST)
+  // preemption specifier, device #] (name in VST)
   // v1 IFUNC: [alias type, addrspace, aliasee val#, linkage,
   // visibility, dllstorageclass, threadlocal, unnamed_addr,
-  // preemption specifier] (name in VST)
+  // preemption specifier, device #] (name in VST)
   // v2: [strtab_offset, strtab_size, v1]
   StringRef Name;
   std::tie(Name, Record) = readNameFromStrtab(Record);
 
   bool NewRecord = BitCode != bitc::MODULE_CODE_ALIAS_OLD;
   if (Record.size() < (3 + (unsigned)NewRecord))
     return error("Invalid record");
   unsigned OpNum = 0;
Error BitcodeReader::parseGlobalIndirectSymbolRecord(
 
   // Check whether we have enough values to read a partition name.
   if (OpNum + 1 < Record.size()) {
     NewGA->setPartition(
         StringRef(Strtab.data() + Record[OpNum], Record[OpNum + 1]));
     OpNum += 2;
   }
 
+  if (Record.size() > OpNum) {
+    if (Record[OpNum] <= 0 || Record[OpNum] > 31)
+      return error("Invalid ID");
+    NewGA->setDeviceNo(Record[OpNum]);
+  }
+
   FullTy = PointerType::get(FullTy, AddrSpace);
   assert(NewGA->getType() == flattenPointerTypes(FullTy) &&
          "Incorrect fully structured type provided for GlobalIndirectSymbol");
   ValueList.push_back(NewGA, FullTy);
   IndirectSymbolInits.push_back(std::make_pair(NewGA, Val));
   return Error::success();
 }
 
case bitc::MODULE_CODE_TRIPLE: {  // TRIPLE: [strchr x N]
       if (ResolvedDataLayout)
         return error("target triple too late in module");
       std::string S;
       if (convertToString(Record, 0, S))
         return error("Invalid record");
       TheModule->setTargetTriple(S);
       break;
     }
+    case bitc::MODULE_CODE_DEVICE_TRIPLE: {  // DEVICE TRIPLE:      [no, strchr x N]
+      if (Record.size() < 1)
+        return error("Invalid record");
+      uint64_t DeviceNo = Record.back();
+      if (DeviceNo == 0)
+        return error("device numbers shall be positive");
+      std::string S;
+      if (convertToString(ArrayRef<uint64_t>(&Record[0], Record.size() - 1), 0, S))
+        return error("Invalid record");
+      TheModule->setTargetTriple(S, DeviceNo);
+      break;
+    }
     case bitc::MODULE_CODE_DATALAYOUT: {  // DATALAYOUT: [strchr x N]
       if (ResolvedDataLayout)
         return error("datalayout too late in module");
       std::string S;
       if (convertToString(Record, 0, S))
         return error("Invalid record");
       TheModule->setDataLayout(S);
       break;

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

if (AbbrevToUse && !BitCodeAbbrevOp::isChar6(Str[i]))
       AbbrevToUse = 0;
     Vals.push_back(Str[i]);
   }
 
   // Emit the finished record.
   Stream.EmitRecord(Code, Vals, AbbrevToUse);
 }
 
+static void writeNumberedStringRecord(BitstreamWriter &Stream, unsigned Code,
+                                      StringRef Str, unsigned No,
+                                      unsigned AbbrevToUse) {
+  SmallVector<unsigned, 64> Vals;
+
+  // Code: [No, strchar x N]
+  for (unsigned i = 0, e = Str.size(); i != e; ++i) {
+    if (AbbrevToUse && !BitCodeAbbrevOp::isChar6(Str[i]))
+      AbbrevToUse = 0;
+    Vals.push_back(Str[i]);
+  }
+
+  Vals.push_back(No);
+
+  // Emit the finished record.
+  Stream.EmitRecord(Code, Vals, AbbrevToUse);
+}
+
 static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
   switch (Kind) {
   case Attribute::Alignment:
     return bitc::ATTR_KIND_ALIGNMENT;
   case Attribute::AllocSize:
     return bitc::ATTR_KIND_ALLOC_SIZE;
   case Attribute::AlwaysInline:
     return bitc::ATTR_KIND_ALWAYS_INLINE;

 /// Emit top-level description of module, including target triple, inline asm,
 /// descriptors for global variables, and function prototype info.
 /// Returns the bit offset to backpatch with the location of the real VST.
 void ModuleBitcodeWriter::writeModuleInfo() {
   // Emit various pieces of data attached to a module.
   if (!M.getTargetTriple().empty())
     writeStringRecord(Stream, bitc::MODULE_CODE_TRIPLE, M.getTargetTriple(),
                       0 /*TODO*/);
+  for (unsigned u = 1, e = M.getNumTargetTriples(); u < e; u++)
+    if (!M.getTargetTriple(u).empty())
+      writeNumberedStringRecord(Stream, bitc::MODULE_CODE_DEVICE_TRIPLE,
+                                M.getTargetTriple(u), u, 0 /*TODO*/);
   const std::string &DL = M.getDataLayoutStr();
   if (!DL.empty())
     writeStringRecord(Stream, bitc::MODULE_CODE_DATALAYOUT, DL, 0 /*TODO*/);
   if (!M.getModuleInlineAsm().empty())
     writeStringRecord(Stream, bitc::MODULE_CODE_ASM, M.getModuleInlineAsm(),
                       0 /*TODO*/);
 
   // Emit information about sections and GC, computing how many there are. Also
for (const GlobalVariable &GV : M.globals()) {
     Vals.push_back(Log2_32(GV.getAlignment())+1);
     Vals.push_back(GV.hasSection() ? SectionMap[std::string(GV.getSection())]
                                    : 0);
     if (GV.isThreadLocal() ||
         GV.getVisibility() != GlobalValue::DefaultVisibility ||
         GV.getUnnamedAddr() != GlobalValue::UnnamedAddr::None ||
         GV.isExternallyInitialized() ||
         GV.getDLLStorageClass() != GlobalValue::DefaultStorageClass ||
         GV.hasComdat() ||
         GV.hasAttributes() ||
         GV.isDSOLocal() ||
-        GV.hasPartition()) {
+        GV.hasPartition() ||
+        GV.getDeviceNo()) {
       Vals.push_back(getEncodedVisibility(GV));
       Vals.push_back(getEncodedThreadLocalMode(GV));
       Vals.push_back(getEncodedUnnamedAddr(GV));
       Vals.push_back(GV.isExternallyInitialized());
       Vals.push_back(getEncodedDLLStorageClass(GV));
       Vals.push_back(GV.hasComdat() ? VE.getComdatID(GV.getComdat()) : 0);
 
       auto AL = GV.getAttributesAsList(AttributeList::FunctionIndex);
       Vals.push_back(VE.getAttributeListID(AL));
 
       Vals.push_back(GV.isDSOLocal());
       Vals.push_back(addToStrtab(GV.getPartition()));
       Vals.push_back(GV.getPartition().size());
+      Vals.push_back(GV.getDeviceNo());
     } else {
       AbbrevToUse = SimpleGVarAbbrev;
     }
 
     Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals, AbbrevToUse);
     Vals.clear();
   }
 
Vals.push_back(F.hasPrefixData() ? (VE.getValueID(F.getPrefixData()) + 1)
                                      : 0);
     Vals.push_back(
         F.hasPersonalityFn() ? (VE.getValueID(F.getPersonalityFn()) + 1) : 0);
 
     Vals.push_back(F.isDSOLocal());
     Vals.push_back(F.getAddressSpace());
     Vals.push_back(addToStrtab(F.getPartition()));
     Vals.push_back(F.getPartition().size());
+    Vals.push_back(F.getDeviceNo());
 
     unsigned AbbrevToUse = 0;
     Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals, AbbrevToUse);
     Vals.clear();
   }
 
   // Emit the alias information.
   for (const GlobalAlias &A : M.aliases()) {
     // ALIAS: [strtab offset, strtab size, alias type, aliasee val#, linkage,
     //         visibility, dllstorageclass, threadlocal, unnamed_addr,
     //         DSO_Local]
     Vals.push_back(addToStrtab(A.getName()));
     Vals.push_back(A.getName().size());
     Vals.push_back(VE.getTypeID(A.getValueType()));
     Vals.push_back(A.getType()->getAddressSpace());
     Vals.push_back(VE.getValueID(A.getAliasee()));
     Vals.push_back(getEncodedLinkage(A));
     Vals.push_back(getEncodedVisibility(A));
     Vals.push_back(getEncodedDLLStorageClass(A));
     Vals.push_back(getEncodedThreadLocalMode(A));
     Vals.push_back(getEncodedUnnamedAddr(A));
     Vals.push_back(A.isDSOLocal());
     Vals.push_back(addToStrtab(A.getPartition()));
     Vals.push_back(A.getPartition().size());
+    Vals.push_back(A.getDeviceNo());
 
     unsigned AbbrevToUse = 0;
     Stream.EmitRecord(bitc::MODULE_CODE_ALIAS, Vals, AbbrevToUse);
     Vals.clear();
   }
 
   // Emit the ifunc information.
   for (const GlobalIFunc &I : M.ifuncs()) {
     // IFUNC: [strtab offset, strtab size, ifunc type, address space, resolver
     //         val#, linkage, visibility, DSO_Local]
     Vals.push_back(addToStrtab(I.getName()));
     Vals.push_back(I.getName().size());
     Vals.push_back(VE.getTypeID(I.getValueType()));
     Vals.push_back(I.getType()->getAddressSpace());
     Vals.push_back(VE.getValueID(I.getResolver()));
     Vals.push_back(getEncodedLinkage(I));
     Vals.push_back(getEncodedVisibility(I));
     Vals.push_back(I.isDSOLocal());
     Vals.push_back(addToStrtab(I.getPartition()));
     Vals.push_back(I.getPartition().size());
+    Vals.push_back(I.getDeviceNo());
     Stream.EmitRecord(bitc::MODULE_CODE_IFUNC, Vals);
     Vals.clear();
   }
 
   writeValueSymbolTableForwardDecl();
 }
 
 static uint64_t getOptimizationFlags(const Value *V) {

llvm/lib/IR/AsmWriter.cpp

if (!M->getSourceFileName().empty()) {
     Out << "\"\n";
   }
 
   const std::string &DL = M->getDataLayoutStr();
   if (!DL.empty())
     Out << "target datalayout = \"" << DL << "\"\n";
   if (!M->getTargetTriple().empty())
     Out << "target triple = \"" << M->getTargetTriple() << "\"\n";
+  for (unsigned u = 1, e = M->getNumTargetTriples(); u < e; u++)
+    if (!M->getTargetTriple(u).empty())
+      Out << "device " << u << " triple = \"" << M->getTargetTriple(u)
+          << "\"\n";
 
   if (!M->getModuleInlineAsm().empty()) {
     Out << '\n';
 
     // Split the string into lines, to make it easier to read the .ll file.
     StringRef Asm = M->getModuleInlineAsm();
     do {
       StringRef Front;

 
 void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
   if (GV->isMaterializable())
     Out << "; Materializable\n";
 
   WriteAsOperandInternal(Out, GV, &TypePrinter, &Machine, GV->getParent());
   Out << " = ";
 
+  if (unsigned DeviceNo = GV->getDeviceNo())
+    Out << "device " << DeviceNo << " ";
+
   if (!GV->hasInitializer() && GV->hasExternalLinkage())
     Out << "external ";
 
   Out << getLinkageNameWithSpace(GV->getLinkage());
   PrintDSOLocation(*GV, Out);
   PrintVisibility(GV->getVisibility(), Out);
   PrintDLLStorageClass(GV->getDLLStorageClass(), Out);
   PrintThreadLocalModel(GV->getThreadLocalMode(), Out);

 
 void AssemblyWriter::printIndirectSymbol(const GlobalIndirectSymbol *GIS) {
   if (GIS->isMaterializable())
     Out << "; Materializable\n";
 
   WriteAsOperandInternal(Out, GIS, &TypePrinter, &Machine, GIS->getParent());
   Out << " = ";
 
+  if (unsigned DeviceNo = GIS->getDeviceNo())
+    Out << "device " << DeviceNo << " ";
+
   Out << getLinkageNameWithSpace(GIS->getLinkage());
   PrintDSOLocation(*GIS, Out);
   PrintVisibility(GIS->getVisibility(), Out);
   PrintDLLStorageClass(GIS->getDLLStorageClass(), Out);
   PrintThreadLocalModel(GIS->getThreadLocalMode(), Out);
   StringRef UA = getUnnamedAddrEncoding(GIS->getUnnamedAddr());
   if (!UA.empty())
       Out << UA << ' ';
if (F->isDeclaration()) {
     Out << "declare";
     SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
     F->getAllMetadata(MDs);
     printMetadataAttachments(MDs, " ");
     Out << ' ';
   } else
     Out << "define ";
 
+  if (unsigned DeviceNo = F->getDeviceNo())
+    Out << "device " << DeviceNo << " ";
+
   Out << getLinkageNameWithSpace(F->getLinkage());
   PrintDSOLocation(*F, Out);
   PrintVisibility(F->getVisibility(), Out);
   PrintDLLStorageClass(F->getDLLStorageClass(), Out);
 
   // Print the calling convention.
   if (F->getCallingConv() != CallingConv::C) {
     PrintCallingConv(F->getCallingConv(), Out);

llvm/lib/IR/Module.cpp

 template class llvm::SymbolTableListTraits<GlobalAlias>;
 template class llvm::SymbolTableListTraits<GlobalIFunc>;
 
 //===----------------------------------------------------------------------===//
 // Primitive Module methods.
 //
 
 Module::Module(StringRef MID, LLVMContext &C)
-    : Context(C), ValSymTab(std::make_unique<ValueSymbolTable>()),
+    : Context(C),
       Materializer(), ModuleID(std::string(MID)),
       SourceFileName(std::string(MID)), DL("") {
+  ValSymTab.push_back(std::make_unique<ValueSymbolTable>());
   Context.addModule(this);
 }
 
 Module::~Module() {
   Context.removeModule(this);
   dropAllReferences();
   GlobalList.clear();
   FunctionList.clear();
   AliasList.clear();
   IFuncList.clear();
 }
 
+void Module::setTargetTriple(StringRef T, int DeviceNo) {
+  ValSymTab.resize(std::max(ValSymTab.size(), size_t(DeviceNo + 1)));
+  ValSymTab[DeviceNo] = std::make_unique<ValueSymbolTable>();
+  TargetTriples.resize(std::max(TargetTriples.size(), size_t(DeviceNo + 1)));
+  TargetTriples[DeviceNo] = std::string(T);
+}
+
 std::unique_ptr<RandomNumberGenerator>
 Module::createRNG(const StringRef Name) const {
   SmallString<32> Salt(Name);
 
   // This RNG is guaranteed to produce the same random stream only
   // when the Module ID and thus the input filename is the same. This
   // might be problematic if the input filename extension changes
   // (e.g. from .c to .bc or .ll).
   //
   // We could store this salt in NamedMetadata, but this would make
   // the parameter non-const. This would unfortunately make this
   // interface unusable by any Machine passes, since they only have a
   // const reference to their IR Module. Alternatively we can always
   // store salt metadata from the Module constructor.
   Salt += sys::path::filename(getModuleIdentifier());
 
   return std::unique_ptr<RandomNumberGenerator>(
       new RandomNumberGenerator(Salt));
 }
 
 /// getNamedValue - Return the first global value in the module with
 /// the specified name, of arbitrary type.  This method returns null
 /// if a global with the specified name is not found.
-GlobalValue *Module::getNamedValue(StringRef Name) const {
-  return cast_or_null<GlobalValue>(getValueSymbolTable().lookup(Name));
+GlobalValue *Module::getNamedValue(StringRef Name, unsigned DeviceNo) const {
+  return cast_or_null<GlobalValue>(getValueSymbolTable(DeviceNo).lookup(Name));
 }
 
 /// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
 /// This ID is uniqued across modules in the current LLVMContext.
 unsigned Module::getMDKindID(StringRef Name) const {
   return Context.getMDKindID(Name);
 }
 

 
 /// getGlobalVariable - Look up the specified global variable in the module
 /// symbol table.  If it does not exist, return null.  The type argument
 /// should be the underlying type of the global, i.e., it should not have
 /// the top-level PointerType, which represents the address of the global.
 /// If AllowLocal is set to true, this function will return types that
 /// have an local. By default, these types are not returned.
 ///
-GlobalVariable *Module::getGlobalVariable(StringRef Name,
-                                          bool AllowLocal) const {
+GlobalVariable *Module::getGlobalVariable(StringRef Name, bool AllowLocal,
+                                          unsigned DeviceNo) const {
   if (GlobalVariable *Result =
-      dyn_cast_or_null<GlobalVariable>(getNamedValue(Name)))
+      dyn_cast_or_null<GlobalVariable>(getNamedValue(Name, DeviceNo)))
     if (AllowLocal || !Result->hasLocalLinkage())
       return Result;
   return nullptr;
 }
 
 /// getOrInsertGlobal - Look up the specified global in the module symbol table.
 ///   1. If it does not exist, add a declaration of the global and return it.
 ///   2. Else, the global exists but has the wrong type: return the function

llvm/test/Bitcode/compatibility.ll

 ; Bitcode compatibility test for llvm
 ;
 ; Please update this file when making any IR changes. Information on the
 ; release process for this file is available here:
 ;
 ;     http://llvm.org/docs/DeveloperPolicy.html#ir-backwards-compatibility
 
 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
 ; RUN-PR24755: verify-uselistorder < %s
 
 target datalayout = "E"
 ; CHECK: target datalayout = "E"
 
 target triple = "x86_64-apple-macosx10.10.0"
 ; CHECK: target triple = "x86_64-apple-macosx10.10.0"
 
+device 1 triple = "mips-unknown-linux-gnu"
+; CHECK: device 1 triple = "mips-unknown-linux-gnu"
+device 2 triple = "mips-unknown-linux-gnu"
+; CHECK: device 2 triple = "mips-unknown-linux-gnu"
+device 31 triple = "nvptx64-unknown-cuda"
+; CHECK: device 31 triple = "nvptx64-unknown-cuda"
+
 ;; Module-level assembly
 module asm "beep boop"
 ; CHECK: module asm "beep boop"
 
 ;; Comdats
 $comdat.any = comdat any
 ; CHECK: $comdat.any = comdat any
 $comdat.exactmatch = comdat exactmatch

 ; CHECK: @constant.vector.f16 = constant <3 x half> <half 0xH8000, half 0xH3C00, half 0xH0000>
 @constant.vector.f16 = constant <3 x half> <half -0.0, half 1.0, half 0.0>
 ; CHECK: @constant.vector.f32 = constant <3 x float> <float -0.000000e+00, float 1.000000e+00, float 0.000000e+00>
 @constant.vector.f32 = constant <3 x float> <float -0.0, float 1.0, float 0.0>
 ; CHECK: @constant.vector.f64 = constant <3 x double> <double -0.000000e+00, double 1.000000e+00, double 0.000000e+00>
 @constant.vector.f64 = constant <3 x double> <double -0.0, double 1.0, double 0.0>
 
 ;; Global Variables
-; Format: [@<GlobalVarName> =] [Linkage] [Visibility] [DLLStorageClass]
+; Format: [@<GlobalVarName> =] [Device] [Linkage] [Visibility] [DLLStorageClass]
 ;         [ThreadLocal] [(unnamed_addr|local_unnamed_addr)] [AddrSpace] [ExternallyInitialized]
 ;         <global | constant> <Type> [<InitializerConstant>]
 ;         [, section "name"] [, comdat [($name)]] [, align <Alignment>]
 
 ; Global Variables -- Simple
 @g1 = global i32 0
 ; CHECK: @g1 = global i32 0
 @g2 = constant i32 0
 ; CHECK: @g2 = constant i32 0
 
+; Global Variables -- Device
+@g1_d31 = device 31 global i32 0
+; CHECK: @g1_d31 = device 31 global i32 0
+@g2_d1 = device 1 constant i32 0
+; CHECK: @g2_d1 =  device 1 constant i32 0
[e-mail]_d2 = device 2 private global i32 0
+; CHECK: @g.private_d2 = device 2 private global i32 0
[e-mail]_d31 = device 31 internal global i32 0
+; CHECK: @g.internal_d31 = device 31 internal global i32 0
[e-mail]_externally_d1 = device 1 available_externally global i32 0
+; CHECK: @g.available_externally_d1 = device 1 available_externally global i32 0
[e-mail]_d2 = device 2 linkonce global i32 0
+; CHECK: @g.linkonce_d2 = device 2 linkonce global i32 0
[e-mail]_d31 = device 31 weak global i32 0
+; CHECK: @g.weak_d31 = device 31 weak global i32 0
[e-mail]_d1 = device 1 common global i32 0
+; CHECK: @g.common_d1 = device 1 common global i32 0
[e-mail]_d2 = device 2 appending global [4 x i8] c"test"
+; CHECK: @g.appending_d2 = device 2 appending global [4 x i8] c"test"
[e-mail]_weak_d31 = device 31 extern_weak global i32
+; CHECK: @g.extern_weak_d31 = device 31 extern_weak global i32
[e-mail]_odr_d1 = device 1 linkonce_odr global i32 0
+; CHECK: @g.linkonce_odr_d1 = device 1 linkonce_odr global i32 0
[e-mail]_odr_d2 = device 2 weak_odr global i32 0
+; CHECK: @g.weak_odr_d2 = device 2 weak_odr global i32 0
[e-mail]_d31 = device 31 external global i32
+; CHECK: @g.external_d31 = device 31 external global i32
+
 ; Global Variables -- Linkage
 @g.private = private global i32 0
 ; CHECK: @g.private = private global i32 0
 @g.internal = internal global i32 0
 ; CHECK: @g.internal = internal global i32 0
 @g.available_externally = available_externally global i32 0
 ; CHECK: @g.available_externally = available_externally global i32 0
 @g.linkonce = linkonce global i32 0

 @llvm.compiler.used = appending global [1 x i32*] [i32* @g.used2], section "llvm.metadata"
 ; CHECK: @llvm.compiler.used = appending global [1 x i32*] [i32* @g.used2], section "llvm.metadata"
 @llvm.global_ctors = appending global [1 x %pri.func.data] [%pri.func.data { i32 0, void ()* @g.f1, i8* @g.used3 }], section "llvm.metadata"
 ; CHECK: @llvm.global_ctors = appending global [1 x %pri.func.data] [%pri.func.data { i32 0, void ()* @g.f1, i8* @g.used3 }], section "llvm.metadata"
 @llvm.global_dtors = appending global [1 x %pri.func.data] [%pri.func.data { i32 0, void ()* @g.f1, i8* @g.used3 }], section "llvm.metadata"
 ; CHECK: @llvm.global_dtors = appending global [1 x %pri.func.data] [%pri.func.data { i32 0, void ()* @g.f1, i8* @g.used3 }], section "llvm.metadata"
 
 ;; Aliases
-; Format: @<Name> = [Linkage] [Visibility] [DLLStorageClass] [ThreadLocal]
+; Format: @<Name> = [Device] [Linkage] [Visibility] [DLLStorageClass] [ThreadLocal]
 ;                   [unnamed_addr] alias <AliaseeTy> @<Aliasee>
 
+; Aliases -- Device
[e-mail]1 = device 1 private alias i32, i32* @g.private
+; CHECK: @a.private = device 1 private alias i32, i32* @g.private
[e-mail]_d2 = device 2 internal alias i32, i32* @g.internal
+; CHECK: @a.internal_d2 = device 2 internal alias i32, i32* @g.internal
[e-mail]_d31 = device 31 linkonce alias i32, i32* @g.linkonce
+; CHECK: @a.linkonce_d31 = device 31 linkonce alias i32, i32* @g.linkonce
[e-mail]_d1 = device 1 weak alias i32, i32* @g.weak
+; CHECK: @a.weak_d1 = device 1 weak alias i32, i32* @g.weak
[e-mail]_odr_d2 = device 2 linkonce_odr alias i32, i32* @g.linkonce_odr
+; CHECK: @a.linkonce_odr_d2 = device 2 linkonce_odr alias i32, i32* @g.linkonce_odr
[e-mail]_odr_d31 = device 31 weak_odr alias i32, i32* @g.weak_odr
+; CHECK: @a.weak_odr_d31 = device 31 weak_odr alias i32, i32* @g.weak_odr
[e-mail]_d1 = device 1 external alias i32, i32* @g1
+; CHECK: @a.external_d1 = device 1 alias i32, i32* @g1
+
 ; Aliases -- Linkage
 @a.private = private alias i32, i32* @g.private
 ; CHECK: @a.private = private alias i32, i32* @g.private
 @a.internal = internal alias i32, i32* @g.internal
 ; CHECK: @a.internal = internal alias i32, i32* @g.internal
 @a.linkonce = linkonce alias i32, i32* @g.linkonce
 ; CHECK: @a.linkonce = linkonce alias i32, i32* @g.linkonce
 @a.weak = weak alias i32, i32* @g.weak

 @a.local_unnamed_addr = local_unnamed_addr alias i32, i32* @g.local_unnamed_addr
 ; CHECK: @a.local_unnamed_addr = local_unnamed_addr alias i32, i32* @g.local_unnamed_addr
 
 ; Aliases -- partition
 ; CHECK: @alias.partition = alias i32, i32* @g.partition, partition "part"
 @alias.partition = alias i32, i32* @g.partition, partition "part"
 
 ;; IFunc
-; Format @<Name> = [Linkage] [Visibility] ifunc <IFuncTy>,
+; Format @<Name> = [Device] [Linkage] [Visibility] ifunc <IFuncTy>,
 ;                  <ResolverTy>* @<Resolver>
 
+; IFunc -- Device
[e-mail]_d1 = device 1 external ifunc void (), i8* ()* @ifunc_resolver
+; CHECK: @ifunc.external_d1 = device 1 ifunc void (), i8* ()* @ifunc_resolver
[e-mail]_d2 = device 2 private ifunc void (), i8* ()* @ifunc_resolver
+; CHECK: @ifunc.private_d2 = device 2 private ifunc void (), i8* ()* @ifunc_resolver
[e-mail]_d31 = device 31 internal ifunc void (), i8* ()* @ifunc_resolver
+; CHECK: @ifunc.internal_d31 = device 31 internal ifunc void (), i8* ()* @ifunc_resolver
+
 ; IFunc -- Linkage
 @ifunc.external = external ifunc void (), i8* ()* @ifunc_resolver
 ; CHECK: @ifunc.external = ifunc void (), i8* ()* @ifunc_resolver
 @ifunc.private = private ifunc void (), i8* ()* @ifunc_resolver
 ; CHECK: @ifunc.private = private ifunc void (), i8* ()* @ifunc_resolver
 @ifunc.internal = internal ifunc void (), i8* ()* @ifunc_resolver
 ; CHECK: @ifunc.internal = internal ifunc void (), i8* ()* @ifunc_resolver
 

 @ifunc.partition = ifunc void (), i8* ()* @ifunc_resolver, partition "part"
 
 define i8* @ifunc_resolver() {
 entry:
   ret i8* null
 }
 
 ;; Functions
-; Format: define [linkage] [visibility] [DLLStorageClass]
+; Format: define [device] [linkage] [visibility] [DLLStorageClass]
 ;         [cconv] [ret attrs]
 ;         <ResultType> @<FunctionName> ([argument list])
 ;         [(unnamed_addr|local_unnamed_addr)] [fn Attrs] [section "name"] [comdat [($name)]]
 ;         [align N] [gc] [prefix Constant] [prologue Constant]
 ;         [personality Constant] { ... }
 
 ; Functions -- Simple
 declare void @f1 ()
 ; CHECK: declare void @f1()
 
 define void @f2 () {
 ; CHECK: define void @f2()
 entry:
   ret void
 }
 
+; Functions -- Device
+declare device 1 void @f1_d1 ()
+; CHECK: declare device 1 void @f1_d1()
+
+define device 2 void @f2_d2 () {
+; CHECK: define device 2 void @f2_d2()
+entry:
+  ret void
+}
+
+define device 31 private void @f.private_d31() {
+; CHECK: define device 31 private void @f.private_d31()
+entry:
+  ret void
+}
+define device 1 internal void @f.internal_d1() {
+; CHECK: define device 1 internal void @f.internal_d1()
+entry:
+  ret void
+}
+define device 2 available_externally void @f.available_externally_d2() {
+; CHECK: define device 2 available_externally void @f.available_externally_d2()
+entry:
+  ret void
+}
+define device 31 linkonce void @f.linkonce_d31() {
+; CHECK: define device 31 linkonce void @f.linkonce_d31()
+entry:
+  ret void
+}
+define device 1 weak void @f.weak_d1() {
+; CHECK: define device 1 weak void @f.weak_d1()
+entry:
+  ret void
+}
+define device 2 linkonce_odr void @f.linkonce_odr_d2() {
+; CHECK: define device 2 linkonce_odr void @f.linkonce_odr_d2()
+entry:
+  ret void
+}
+define device 31 weak_odr void @f.weak_odr_d31() {
+; CHECK: define device 31 weak_odr void @f.weak_odr_d31()
+entry:
+  ret void
+}
+declare device 1 external void @f.external_d1()
+; CHECK: declare device 1 void @f.external_d1()
+declare device 2 extern_weak void @f.extern_weak_d2()
+; CHECK: declare device 2 extern_weak void @f.extern_weak_d2()
+
 ; Functions -- linkage
 define private void @f.private() {
 ; CHECK: define private void @f.private()
 entry:
   ret void
 }
 define internal void @f.internal() {
 ; CHECK: define internal void @f.internal()