Force __pnacl_pso_root to be an external declaration.

src/IceGlobalInits.h

 //===- subzero/src/IceGlobalInits.h - Global declarations -------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 136 matching lines @@
   bool isProto() const { return IsProto; }
   static bool classof(const GlobalDeclaration *Addr) {
     return Addr->getKind() == FunctionDeclarationKind;
   }
   void dumpType(Ostream &Stream) const final;
   void dump(GlobalContext *Ctx, Ostream &Stream) const final;
   bool getSuppressMangling() const final { return isExternal() && IsProto; }
 
   /// Returns true if linkage is correct for the function declaration.
   bool verifyLinkageCorrect(const GlobalContext *Ctx) const {
-    if (isPNaClABIExternalName() || isIntrinsicName(Ctx))
+    if (isIntrinsicName(Ctx))
       return Linkage == llvm::GlobalValue::ExternalLinkage;
-    return verifyLinkageDefault(Ctx);
+    else if (Linkage == llvm::GlobalValue::ExternalLinkage)
+      return isPNaClABIExternalName();
+    else
+      return verifyLinkageDefault(Ctx);
   }
 
   /// Validates that the type signature of the function is correct. Returns true
   /// if valid.
   bool validateTypeSignature(const GlobalContext *Ctx) const {
     bool IsIntrinsic;
     if (const Intrinsics::FullIntrinsicInfo *Info =
             getIntrinsicInfo(Ctx, &IsIntrinsic))
       return validateIntrinsicTypeSignature(Info);
     return !IsIntrinsic && validateRegularTypeSignature();
@@ skipping 21 matching lines @@
   bool IsProto;
 
   FunctionDeclaration(const FuncSigType &Signature,
                       llvm::CallingConv::ID CallingConv,
                       llvm::GlobalValue::LinkageTypes Linkage, bool IsProto)
       : GlobalDeclaration(FunctionDeclarationKind, Linkage),
         Signature(Signature), CallingConv(CallingConv), IsProto(IsProto) {}
 
   bool isPNaClABIExternalName() const {
     const char *Name = getName().c_str();
-    return strcmp(Name, "_start") == 0 || strcmp(Name, "__pnacl_pso_root") == 0;
+    return strcmp(Name, "_start") == 0;
   }
 
   bool isIntrinsicName(const GlobalContext *Ctx) const {
     bool IsIntrinsic;
     getIntrinsicInfo(Ctx, &IsIntrinsic);
     return IsIntrinsic;
   }
 
   bool validateRegularTypeSignature() const;
 
@@ skipping 197 matching lines @@
 
   /// Prints out type for initializer associated with the declaration to Stream.
   void dumpType(Ostream &Stream) const final;
 
   /// Prints out the definition of the global variable declaration (including
   /// initialization).
   void dump(GlobalContext *Ctx, Ostream &Stream) const final;
 
   /// Returns true if linkage is correct for the variable declaration.
   bool verifyLinkageCorrect(const GlobalContext *Ctx) const {
+    if (isPNaClABIExternalName()) {
+      return Linkage == llvm::GlobalValue::ExternalLinkage;
+    }
     return verifyLinkageDefault(Ctx);
   }
 
+  /// Returns true if the linkage was updated.
+  bool forcePNaClABILinkage() {
+    if (isPNaClABIExternalName()) {
+      // Force linkage to be external for the PNaCl ABI. PNaCl bitcode has a
+      // linkage field for Functions, but not for GlobalVariables (because the
+      // latter is not needed for pexes, so it has been removed).
+      setLinkage(llvm::GlobalValue::ExternalLinkage);
+      return true;
+    }
+    return false;
+  }
+
   static bool classof(const GlobalDeclaration *Addr) {
     return Addr->getKind() == VariableDeclarationKind;
   }
 
   bool getSuppressMangling() const final {
     if (ForceSuppressMangling)
       return true;
     return isExternal() && !hasInitializer();
   }
 
   void setSuppressMangling() { ForceSuppressMangling = true; }
 
   void discardInitializers() { Initializers = nullptr; }
 
 private:
+  bool isPNaClABIExternalName() const {
+    const char *Name = getName().c_str();

[John, 2016/02/26 18:40:53]

static constexpr char PnaclPsoRoot[] = "__pnacl_pso_root";
return getName() == PnaclPsoRoot;

[Sean Klein, 2016/02/26 19:45:04]

Done.

+    return strcmp(Name, "__pnacl_pso_root") == 0;
+  }
+
   /// List of initializers for the declared variable.
   std::unique_ptr<InitializerListType> Initializers;
   bool HasInitializer;
   /// The alignment of the declared variable.
   uint32_t Alignment;
   /// True if a declared (global) constant.
   bool IsConstant;
   /// If set to true, force getSuppressMangling() to return true.
   bool ForceSuppressMangling;
 
@@ skipping 14 matching lines @@
 template <class StreamType>
 inline StreamType &operator<<(StreamType &Stream,
                               const GlobalDeclaration &Addr) {
   Addr.dump(Stream);
   return Stream;
 }
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEGLOBALINITS_H