[AsmParser][AsmWriter] Default to dso_local for function definitions

[MaskRay]

Rebase

llvm/lib/AsmParser/LLParser.h

private:
     bool parseOptionalProgramAddrSpace(unsigned &AddrSpace) {
       return parseOptionalAddrSpace(
           AddrSpace, M->getDataLayout().getProgramAddressSpace());
     };
     bool parseOptionalParamAttrs(AttrBuilder &B);
     bool parseOptionalReturnAttrs(AttrBuilder &B);
     bool parseOptionalLinkage(unsigned &Res, bool &HasLinkage,
                               unsigned &Visibility, unsigned &DLLStorageClass,
-                              bool &DSOLocal);
-    void parseOptionalDSOLocal(bool &DSOLocal);
+                              bool &ExplicitDSOPreemption, bool &DSOLocal);
+    void parseOptionalDSOLocal(bool &ExplicitDSOPreemption, bool &DSOLocal);
     void parseOptionalVisibility(unsigned &Res);
     void parseOptionalDLLStorageClass(unsigned &Res);
     bool parseOptionalCallingConv(unsigned &CC);
     bool parseOptionalAlignment(MaybeAlign &Alignment,
                                 bool AllowParens = false);
     bool parseOptionalDerefAttrBytes(lltok::Kind AttrKind, uint64_t &Bytes);
     bool parseScopeAndOrdering(bool IsAtomic, SyncScope::ID &SSID,
                                AtomicOrdering &Ordering);

llvm/lib/AsmParser/LLParser.cpp

if (Lex.getKind() == lltok::GlobalID) {
     Lex.Lex(); // eat GlobalID;
 
     if (parseToken(lltok::equal, "expected '=' after name"))
       return true;
   }
 
   bool HasLinkage;
   unsigned Linkage, Visibility, DLLStorageClass;
-  bool DSOLocal;
+  bool ExplicitDSOPreemption, DSOLocal;
   GlobalVariable::ThreadLocalMode TLM;
   GlobalVariable::UnnamedAddr UnnamedAddr;
   if (parseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
-                           DSOLocal) ||
+                           ExplicitDSOPreemption, 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,
                        DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
 
   return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
                              DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
 }
 
 /// parseNamedGlobal:
 ///   GlobalVar '=' OptionalVisibility (ALIAS | IFUNC) ...
 ///   GlobalVar '=' 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();
 
   bool HasLinkage;
   unsigned Linkage, Visibility, DLLStorageClass;
-  bool DSOLocal;
+  bool ExplicitDSOPreemption, DSOLocal;
   GlobalVariable::ThreadLocalMode TLM;
   GlobalVariable::UnnamedAddr UnnamedAddr;
   if (parseToken(lltok::equal, "expected '=' in global variable") ||
       parseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
-                           DSOLocal) ||
+                           ExplicitDSOPreemption, 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,
                        DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
 
   return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,

 ///   ::= 'linkonce_odr'
 ///   ::= 'available_externally'
 ///   ::= 'appending'
 ///   ::= 'common'
 ///   ::= 'extern_weak'
 ///   ::= 'external'
 bool LLParser::parseOptionalLinkage(unsigned &Res, bool &HasLinkage,
                                     unsigned &Visibility,
-                                    unsigned &DLLStorageClass, bool &DSOLocal) {
+                                    unsigned &DLLStorageClass,
+                                    bool &ExplicitDSOPreemption,
+                                    bool &DSOLocal) {
   Res = parseOptionalLinkageAux(Lex.getKind(), HasLinkage);
   if (HasLinkage)
     Lex.Lex();
-  parseOptionalDSOLocal(DSOLocal);
+  parseOptionalDSOLocal(ExplicitDSOPreemption, DSOLocal);
   parseOptionalVisibility(Visibility);
   parseOptionalDLLStorageClass(DLLStorageClass);
 
   if (DSOLocal && DLLStorageClass == GlobalValue::DLLImportStorageClass) {
     return error(Lex.getLoc(), "dso_location and DLL-StorageClass mismatch");
   }
 
   return false;
 }
 
-void LLParser::parseOptionalDSOLocal(bool &DSOLocal) {
+void LLParser::parseOptionalDSOLocal(bool &ExplicitDSOPreemption,
+                                     bool &DSOLocal) {
   switch (Lex.getKind()) {
   default:
+    ExplicitDSOPreemption = false;
     DSOLocal = false;
     break;
   case lltok::kw_dso_local:
+    ExplicitDSOPreemption = true;
     DSOLocal = true;
     Lex.Lex();
     break;
   case lltok::kw_dso_preemptable:
+    ExplicitDSOPreemption = true;
     DSOLocal = false;
     Lex.Lex();
     break;
   }
 }
 
 /// parseOptionalVisibility
 ///   ::= /*empty*/

 ///       '(' ArgList ')' OptAddrSpace OptFuncAttrs OptSection OptionalAlign
 ///       OptGC OptionalPrefix OptionalPrologue OptPersonalityFn
 bool LLParser::parseFunctionHeader(Function *&Fn, bool IsDefine) {
   // parse the linkage.
   LocTy LinkageLoc = Lex.getLoc();
   unsigned Linkage;
   unsigned Visibility;
   unsigned DLLStorageClass;
-  bool DSOLocal;
+  bool ExplicitDSOPreemption, DSOLocal;
   AttrBuilder RetAttrs;
   unsigned CC;
   bool HasLinkage;
   Type *RetType = nullptr;
   LocTy RetTypeLoc = Lex.getLoc();
   if (parseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
-                           DSOLocal) ||
+                           ExplicitDSOPreemption, 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:
     break; // always ok.
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->setLinkage((GlobalValue::LinkageTypes)Linkage);
-  maybeSetDSOLocal(DSOLocal, *Fn);
+  Fn->setDSOLocal(ExplicitDSOPreemption ? DSOLocal : IsDefine);
   Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility);
   Fn->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
   Fn->setCallingConv(CC);
   Fn->setAttributes(PAL);
   Fn->setUnnamedAddr(UnnamedAddr);
   Fn->setAlignment(MaybeAlign(Alignment));
   Fn->setSection(Section);
   Fn->setPartition(Partition);

llvm/lib/IR/AsmWriter.cpp

static void PrintVisibility(GlobalValue::VisibilityTypes Vis,
   case GlobalValue::DefaultVisibility: break;
   case GlobalValue::HiddenVisibility:    Out << "hidden "; break;
   case GlobalValue::ProtectedVisibility: Out << "protected "; break;
   }
 }
 
 static void PrintDSOLocation(const GlobalValue &GV,
                              formatted_raw_ostream &Out) {
-  if (GV.isDSOLocal() && !GV.isImplicitDSOLocal())
+  bool Default =
+      GV.isImplicitDSOLocal() || (isa<Function>(GV) && !GV.isDeclaration());
+  if (GV.isDSOLocal()) {
+    if (!Default)
       Out << "dso_local ";
+  } else {
+    if (Default)
+      Out << "dso_preemptable ";
+  }
 }
 
 static void PrintDLLStorageClass(GlobalValue::DLLStorageClassTypes SCT,
                                  formatted_raw_ostream &Out) {
   switch (SCT) {
   case GlobalValue::DefaultStorageClass: break;
   case GlobalValue::DLLImportStorageClass: Out << "dllimport "; break;
   case GlobalValue::DLLExportStorageClass: Out << "dllexport "; break;