Make sure that all globals are internal, except for "start" functions.

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 69 matching lines @@
 
   /// Returns true if when emitting names, we should suppress mangling.
   virtual bool getSuppressMangling() const = 0;
 
   /// Mangles name for cross tests, unless external and not defined locally (so
   /// that relocations across pnacl-sz and pnacl-llc will work).
   virtual IceString mangleName(GlobalContext *Ctx) const {
     return getSuppressMangling() ? Name : Ctx->mangleName(Name);
   }
 
+  /// Returns textual name of linkage.
+  const char *getLinkageName() const {
+    return isInternal() ? "internal" : "external";
+  }
+
 protected:
   GlobalDeclaration(GlobalDeclarationKind Kind,
                     llvm::GlobalValue::LinkageTypes Linkage)
       : Kind(Kind), Linkage(Linkage) {}
 
+  /// Returns true if linkage is defined correctly for the global declaration,
+  /// based on default rules.
+  bool verifyLinkageDefault(const GlobalContext *Ctx) const {
+    switch (Linkage) {
+    default:
+      return false;
+    case llvm::GlobalValue::InternalLinkage:
+      return true;
+    case llvm::GlobalValue::ExternalLinkage:
+      return Ctx->getFlags().getAllowExternDefinedSymbols();
+    }
+  }
+
   const GlobalDeclarationKind Kind;
   IceString Name;
   llvm::GlobalValue::LinkageTypes Linkage;
 };
 
 /// Models a function declaration. This includes the type signature of the
 /// function, its calling conventions, and its linkage.
 class FunctionDeclaration : public GlobalDeclaration {
   FunctionDeclaration() = delete;
   FunctionDeclaration(const FunctionDeclaration &) = delete;
@@ skipping 12 matching lines @@
   llvm::CallingConv::ID getCallingConv() const { return CallingConv; }
   /// isProto implies that there isn't a (local) definition for the function.
   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))
+      return Linkage == llvm::GlobalValue::ExternalLinkage;
+    return verifyLinkageDefault(Ctx);
+  }
+
 private:
   const Ice::FuncSigType Signature;
   llvm::CallingConv::ID CallingConv;
   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;
+  }
+
+  bool isIntrinsicName(const GlobalContext *Ctx) const {
+    if (!hasName())
+      return false;
+    bool BadIntrinsic;
+    return Ctx->getIntrinsicsInfo().find(getName(), BadIntrinsic) &&
+           !BadIntrinsic;
+  }
 };
 
 /// Models a global variable declaration, and its initializers.
 class VariableDeclaration : public GlobalDeclaration {
   VariableDeclaration(const VariableDeclaration &) = delete;
   VariableDeclaration &operator=(const VariableDeclaration &) = delete;
 
 public:
   /// Base class for a global variable initializer.
   class Initializer {
@@ skipping 155 matching lines @@
     HasInitializer = true;
   }
 
   /// 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 {
+    return verifyLinkageDefault(Ctx);
+  }
+
   static bool classof(const GlobalDeclaration *Addr) {
     return Addr->getKind() == VariableDeclarationKind;
   }
 
   bool getSuppressMangling() const final {
     if (ForceSuppressMangling)
       return true;
     return isExternal() && !hasInitializer();
   }
 
@@ skipping 29 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