Allow dso_local on ifunc

[• espindola]

Summary

It was never fully disallowed. We were rejecting it in the asm parser, but not in the verifier.

Currently TargetMachine::shouldAssumeDSOLocal returns true for hidden ifuncs. I considered changing it and moving the check from the asm parser to the verifier.

The reason for deciding to allow it instead is that all linkers handle a direct reference just fine. They use the plt address as the address of the function. In fact doing that means that clang doesn't have the same bug as gcc: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83782.

This patch then removes the check from the asm parser and updates the bitcode reader and writer.

[• espindola]

Rebased.

[rnk]

lgtm

Sorry for the delay, I'm on vacation.

[• espindola]

322378

llvm/include/llvm/IR/GlobalValue.h

public:
   bool hasCommonLinkage() const { return isCommonLinkage(getLinkage()); }
   bool hasValidDeclarationLinkage() const {
     return isValidDeclarationLinkage(getLinkage());
   }
 
   void setLinkage(LinkageTypes LT) {
     if (isLocalLinkage(LT)) {
       Visibility = DefaultVisibility;
-      if (getValueID() != Value::GlobalIFuncVal)
-        setDSOLocal(true);
     }
     Linkage = LT;
   }
   LinkageTypes getLinkage() const { return LinkageTypes(Linkage); }
 
   bool isDiscardableIfUnused() const {
     return isDiscardableIfUnused(getLinkage());
   }

llvm/lib/AsmParser/LLParser.cpp

bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
 
   if(IsAlias && !GlobalAlias::isValidLinkage(Linkage))
     return Error(NameLoc, "invalid linkage type for alias");
 
   if (!isValidVisibilityForLinkage(Visibility, L))
     return Error(NameLoc,
                  "symbol with local linkage must have default visibility");
 
-  if (DSOLocal && !IsAlias) {
-    return Error(NameLoc,
-                 "dso_local is invalid on ifunc");
-  }
-
   Type *Ty;
   LocTy ExplicitTypeLoc = Lex.getLoc();
   if (ParseType(Ty) ||
       ParseToken(lltok::comma, "expected comma after alias or ifunc's type"))
     return true;
 
   Constant *Aliasee;
   LocTy AliaseeLoc = Lex.getLoc();

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

Error BitcodeReader::parseGlobalIndirectSymbolRecord(
   // Old bitcode files didn't have visibility field.
   // Local linkage must have default visibility.
   if (OpNum != Record.size()) {
     auto VisInd = OpNum++;
     if (!NewGA->hasLocalLinkage())
       // FIXME: Change to an error if non-default in 4.0.
       NewGA->setVisibility(getDecodedVisibility(Record[VisInd]));
   }
+  if (BitCode == bitc::MODULE_CODE_ALIAS ||
+      BitCode == bitc::MODULE_CODE_ALIAS_OLD) {
     if (OpNum != Record.size())
       NewGA->setDLLStorageClass(getDecodedDLLStorageClass(Record[OpNum++]));
     else
       upgradeDLLImportExportLinkage(NewGA, Linkage);
     if (OpNum != Record.size())
       NewGA->setThreadLocalMode(getDecodedThreadLocalMode(Record[OpNum++]));
     if (OpNum != Record.size())
       NewGA->setUnnamedAddr(getDecodedUnnamedAddrType(Record[OpNum++]));
+  }
   if (OpNum != Record.size())
     NewGA->setDSOLocal(getDecodedDSOLocal(Record[OpNum++]));
   ValueList.push_back(NewGA);
   IndirectSymbolInits.push_back(std::make_pair(NewGA, Val));
   return Error::success();
 }
 
 Error BitcodeReader::parseModule(uint64_t ResumeBit,

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

for (const GlobalAlias &A : M.aliases()) {
     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]
+    //         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());
     Stream.EmitRecord(bitc::MODULE_CODE_IFUNC, Vals);
     Vals.clear();
   }
 
   writeValueSymbolTableForwardDecl();
 }
 
 static uint64_t getOptimizationFlags(const Value *V) {

llvm/test/Assembler/ifunc-dsolocal.ll

-; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
 
 @foo = dso_local ifunc i32 (i32), i64 ()* @foo_ifunc
-; CHECK: error: dso_local is invalid on ifunc
+; CHECK: @foo = dso_local ifunc i32 (i32), i64 ()* @foo_ifunc
 
 define internal i64 @foo_ifunc() {
 entry:
   ret i64 0
 }