[XCOFF] Enable symbol alias for AIX

[jasonliu]

Summary

AIX assembly's .set directive is not usable for aliasing purpose.
We need to use extra-label-at-defintion strategy to generate symbol aliasing on AIX.

Follow up items after this patch would be:

1. Investigate .set directive to see if it's needed for other purpose.
2. Use llvm-readobj to dump the relocation table and symbol table for the symbols to verify it on the integrate-as path.

[jasonliu]

Gentle ping.

[Xiangling_L]

llvm/include/llvm/Target/TargetLoweringObjectFile.h

250–251

Instead of comments, can we add an assertion for this?

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1408

I don't quite get the point of this assertion here, it seems hasVisibilityOnlyWithLinkage() will always be true if this is an XCOFF target which is exactly same as the if condition used here. Maybe a comment Visibility should be handled with emitLinkage() on AIX. is sufficient.

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2129

The same comments as above, can we add assertions here saying this only applies for GlobalObject of GlobalAlias?

llvm/test/CodeGen/PowerPC/aix-alias.ll

1–2

minor nit:
trailing whitespace

18

I feel the naming convention here is kinda messy. It seems there are mainly two kind, one is aliasing to a variable bar, the other is aliasing to a function foo_f.
I am suggesting to stick bar related alias, with bar_xxx and prabably use foo_f_xxx to refer to foo_f related alias.
[eg.
@foo_f_w = weak alias %FunTy, %FunTy* @foo_f
]

24

You can simplify the testcase by removing align 4 all over the test.

72

I am wondering any reason we want to separate the linkage emission with the alias label emission?

86

I am suggesting to also test the usage of hidden and protected alias.

[DiggerLin]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1851

if Base ->isDeclarationForLinker() is true. it should not have a alias, do we need to add assert here ?

llvm/test/CodeGen/PowerPC/aix-alias.ll

24

in the doc .https://llvm.org/docs/LangRef.html#aliases . The linkage must be one of private, internal, linkonce, weak, linkonce_odr, weak_odr, external.

Do you want to test the linkonce, weak_odr,and external by the way?

[DiggerLin]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2154–2160

I saw that you change the const GlobalValue *Function to
const GlobalValue *Func, in the patch https://reviews.llvm.org/D83875 why not change in the patch here directly ?

[DiggerLin]

llvm/test/CodeGen/PowerPC/aix-alias.ll

49

for the convenient of review . I suggest that adding two line
;ASM-NEXT: # %bb.0:
;ASM-NEXT: li 3, 0

and the reviewer will know the
.bar_f and .foo_f pointer to different position with following .test: (all two more CHECK line for .test below)

[jasonliu]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1408

The assertion here is essentially a documentation. I'd prefer to let the assertion to tell the story and comments are easier to get ignored.

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2154–2160

Sounds good.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1851

Is it necessary? We already get both clang and llc errors if we try to do that.

llvm/test/CodeGen/PowerPC/aix-alias.ll

24

Is there anything special about linkonce, weak_odr and external that would trigger a different behavior between aliasing and the actual object to make it worth testing? Additional linkage does not have any difference for emitLinkage except using label vs csect case when dealing with aliasing vs actual object.

72

We could do it with the alias label emission as well. But doing it here follows what llvm does currently for other targets. And also maybe later when we decide to handle aliasing without base global object, we do not need to filter out all the aliases that already have their linkage emitted somewhere else.

86

I think it's worth to test the function aliasing with one of the visibility attribute. i.e. hidden.
I don't think it's necessary to test all the combinations, as for aliasing purpose, they all go through similar path there. Extensive testing of visibility is already handled in visibility patch.

[DiggerLin]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1406

change if (TM.getTargetTriple().isOSBinFormatXCOFF() )
to
if (TM.getTargetTriple().isOSBinFormatXCOFF() & IsFunction)

and we do no not need
if (IsFunction)
later

[jasonliu]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1406

I'm not sure how that would work because this if statement also intends to handle GlobalVariable.

[jasonliu]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1406

I mean alias to GlobalVariable. Not just Function.

[DiggerLin]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1406

yes, you are correct. the emitGlobalIndirectSymbol also been called for the GlobalObject too.

[DiggerLin]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1406

sorry, the emitGlobalIndirectSymbol also been called for the GlobalVariable too.

[jasonliu]

Address comments.

llvm/test/CodeGen/PowerPC/aix-alias.ll

18

Agree. Renamed and reorganized the test.

[Xiangling_L]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1847

I am suggesting we add tests also for alias to alias and either one scenario of alias to ConstantExpr.

llvm/test/CodeGen/PowerPC/aix-alias.ll

86

Yeah, agree. That works as well.

[jasonliu]

Update test case to include more scenario.

[DiggerLin]

LGTM

[Xiangling_L]

LGTM with minor nit.

llvm/test/CodeGen/PowerPC/aix-alias.ll

19

Remove align 4 on #19 and #20?

[jasonliu]

llvm/test/CodeGen/PowerPC/aix-alias.ll

19

As discussed offline, the align 4 is generated by clang. It's not very intrusive and does not make the IR significantly hard to read. We could keep it here.

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

MCSection *getSectionForJumpTable(const Function &F,
                                     const TargetMachine &TM) const override;
 
   /// Given a constant with the SectionKind, return a section that it should be
   /// placed in.
   MCSection *getSectionForConstant(const DataLayout &DL, SectionKind Kind,
                                    const Constant *C,
                                    Align &Alignment) const override;
 
-  static XCOFF::StorageClass getStorageClassForGlobal(const GlobalObject *GO);
+  static XCOFF::StorageClass getStorageClassForGlobal(const GlobalValue *GV);
 
   MCSection *
   getSectionForFunctionDescriptor(const Function *F,
                                   const TargetMachine &TM) const override;
   MCSection *getSectionForTOCEntry(const MCSymbol *Sym) const override;
 
   /// For external functions, this will always return a function descriptor
   /// csect.
   MCSection *
   getSectionForExternalReference(const GlobalObject *GO,
                                  const TargetMachine &TM) const override;
 
   /// For functions, this will always return a function descriptor symbol.
   MCSymbol *getTargetSymbol(const GlobalValue *GV,
                             const TargetMachine &TM) const override;
 
-  MCSymbol *getFunctionEntryPointSymbol(const Function *F,
+  MCSymbol *getFunctionEntryPointSymbol(const GlobalValue *Func,
                                         const TargetMachine &TM) const override;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_TARGETLOWERINGOBJECTFILEIMPL_H

llvm/include/llvm/Target/TargetLoweringObjectFile.h

public:
   /// this hook to return a specialized symbol.
   virtual MCSymbol *getTargetSymbol(const GlobalValue *GV,
                                     const TargetMachine &TM) const {
     return nullptr;
   }
 
   /// If supported, return the function entry point symbol.
   /// Otherwise, returns nulltpr.
-  virtual MCSymbol *getFunctionEntryPointSymbol(const Function *F,
+  /// Func must be a function or an alias which has a function as base object.
+  virtual MCSymbol *getFunctionEntryPointSymbol(const GlobalValue *Func,
                                                 const TargetMachine &TM) const {
     return nullptr;
   }
 
 protected:
   virtual MCSection *SelectSectionForGlobal(const GlobalObject *GO,
                                             SectionKind Kind,
                                             const TargetMachine &TM) const = 0;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_TARGETLOWERINGOBJECTFILE_H

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

void AsmPrinter::emitGlobalGOTEquivs() {
 
   for (auto *GV : FailedCandidates)
     emitGlobalVariable(GV);
 }
 
 void AsmPrinter::emitGlobalIndirectSymbol(Module &M,
                                           const GlobalIndirectSymbol& GIS) {
   MCSymbol *Name = getSymbol(&GIS);
-
-  if (GIS.hasExternalLinkage() || !MAI->getWeakRefDirective())
-    OutStreamer->emitSymbolAttribute(Name, MCSA_Global);
-  else if (GIS.hasWeakLinkage() || GIS.hasLinkOnceLinkage())
-    OutStreamer->emitSymbolAttribute(Name, MCSA_WeakReference);
-  else
-    assert(GIS.hasLocalLinkage() && "Invalid alias or ifunc linkage");
-
   bool IsFunction = GIS.getValueType()->isFunctionTy();
-
   // Treat bitcasts of functions as functions also. This is important at least
   // on WebAssembly where object and function addresses can't alias each other.
   if (!IsFunction)
     if (auto *CE = dyn_cast<ConstantExpr>(GIS.getIndirectSymbol()))
       if (CE->getOpcode() == Instruction::BitCast)
         IsFunction =
           CE->getOperand(0)->getType()->getPointerElementType()->isFunctionTy();
 
+  // AIX's assembly directive `.set` is not usable for aliasing purpose,
+  // so AIX has to use the extra-label-at-definition strategy. At this
+  // point, all the extra label is emitted, we just have to emit linkage for
+  // those labels.
+  if (TM.getTargetTriple().isOSBinFormatXCOFF()) {
+    assert(!isa<GlobalIFunc>(GIS) && "IFunc is not supported on AIX.");
+    assert(MAI->hasVisibilityOnlyWithLinkage() &&
+           "Visibility should be handled with emitLinkage() on AIX.");
+    emitLinkage(&GIS, Name);
+    // If it's a function, also emit linkage for aliases of function entry
+    // point.
+    if (IsFunction)
+      emitLinkage(&GIS,
+                  getObjFileLowering().getFunctionEntryPointSymbol(&GIS, TM));
+    return;
+  }
+
+  if (GIS.hasExternalLinkage() || !MAI->getWeakRefDirective())
+    OutStreamer->emitSymbolAttribute(Name, MCSA_Global);
+  else if (GIS.hasWeakLinkage() || GIS.hasLinkOnceLinkage())
+    OutStreamer->emitSymbolAttribute(Name, MCSA_WeakReference);
+  else
+    assert(GIS.hasLocalLinkage() && "Invalid alias or ifunc linkage");
+
   // Set the symbol type to function if the alias has a function type.
   // This affects codegen when the aliasee is not a function.
   if (IsFunction)
     OutStreamer->emitSymbolAttribute(Name, isa<GlobalIFunc>(GIS)
                                                ? MCSA_ELF_TypeIndFunction
                                                : MCSA_ELF_TypeFunction);
 
   emitVisibility(Name, GIS.getVisibility());

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

 }
 
 const MCExpr *TargetLoweringObjectFileXCOFF::lowerRelativeReference(
     const GlobalValue *LHS, const GlobalValue *RHS,
     const TargetMachine &TM) const {
   report_fatal_error("XCOFF not yet implemented.");
 }
 
-XCOFF::StorageClass TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(
-    const GlobalObject *GO) {
-  switch (GO->getLinkage()) {
+XCOFF::StorageClass
+TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(const GlobalValue *GV) {
+  assert(!isa<GlobalIFunc>(GV) && "GlobalIFunc is not supported on AIX.");
+
+  switch (GV->getLinkage()) {
   case GlobalValue::InternalLinkage:
   case GlobalValue::PrivateLinkage:
     return XCOFF::C_HIDEXT;
   case GlobalValue::ExternalLinkage:
   case GlobalValue::CommonLinkage:
   case GlobalValue::AvailableExternallyLinkage:
     return XCOFF::C_EXT;
   case GlobalValue::ExternalWeakLinkage:
   case GlobalValue::LinkOnceAnyLinkage:
   case GlobalValue::LinkOnceODRLinkage:
   case GlobalValue::WeakAnyLinkage:
   case GlobalValue::WeakODRLinkage:
     return XCOFF::C_WEAKEXT;
   case GlobalValue::AppendingLinkage:
     report_fatal_error(
         "There is no mapping that implements AppendingLinkage for XCOFF.");
   }
   llvm_unreachable("Unknown linkage type!");
 }
 
 MCSymbol *TargetLoweringObjectFileXCOFF::getFunctionEntryPointSymbol(
-    const Function *F, const TargetMachine &TM) const {
+    const GlobalValue *Func, const TargetMachine &TM) const {
+  assert(
+      isa<Function>(Func) ||
+      (isa<GlobalAlias>(Func) &&
+       isa_and_nonnull<Function>(cast<GlobalAlias>(Func)->getBaseObject())) &&
+          "Func must be a function or an alias which has a function as base "
+          "object.");
   SmallString<128> NameStr;
   NameStr.push_back('.');
-  getNameWithPrefix(NameStr, F, TM);
+  getNameWithPrefix(NameStr, Func, TM);
   return getContext().getOrCreateSymbol(NameStr);
 }
 
 MCSection *TargetLoweringObjectFileXCOFF::getSectionForFunctionDescriptor(
     const Function *F, const TargetMachine &TM) const {
   SmallString<128> NameStr;
   getNameWithPrefix(NameStr, F, TM);
   return getContext().getXCOFFSection(NameStr, XCOFF::XMC_DS, XCOFF::XTY_SD,

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

 
 class PPCAIXAsmPrinter : public PPCAsmPrinter {
 private:
   /// Symbols lowered from ExternalSymbolSDNodes, we will need to emit extern
   /// linkage for them in AIX.
   SmallPtrSet<MCSymbol *, 8> ExtSymSDNodeSymbols;
 
   static void ValidateGV(const GlobalVariable *GV);
+  // Record a list of GlobalAlias associated with a GlobalObject.
+  // This is used for AIX's extra-label-at-definition aliasing strategy.
+  DenseMap<const GlobalObject *, SmallVector<const GlobalAlias *, 1>>
+      GOAliasMap;
 
 public:
   PPCAIXAsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer)
       : PPCAsmPrinter(TM, std::move(Streamer)) {
     if (MAI->isLittleEndian())
       report_fatal_error(
           "cannot create AIX PPC Assembly Printer for a little-endian target");
   }
 
   StringRef getPassName() const override { return "AIX PPC Assembly Printer"; }
 
   bool doInitialization(Module &M) override;
 
   void SetupMachineFunction(MachineFunction &MF) override;
 
   void emitGlobalVariable(const GlobalVariable *GV) override;
 
   void emitFunctionDescriptor() override;
 
+  void emitFunctionEntryLabel() override;
+
   void emitEndOfAsmFile(Module &) override;
 
   void emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const override;
 
   void emitInstruction(const MachineInstr *MI) override;
 
   bool doFinalization(Module &M) override;
 };
else
       OutStreamer->emitCommonSymbol(GVSym, Size, Alignment.value());
     return;
   }
 
   MCSymbol *EmittedInitSym = GVSym;
   emitLinkage(GV, EmittedInitSym);
   emitAlignment(getGVAlignment(GV, DL), GV);
   OutStreamer->emitLabel(EmittedInitSym);
+  // Emit aliasing label for global variable.
+  llvm::for_each(GOAliasMap[GV], [this](const GlobalAlias *Alias) {
+    OutStreamer->emitLabel(getSymbol(Alias));
+  });
   emitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer());
 }
 
 void PPCAIXAsmPrinter::emitFunctionDescriptor() {
   const DataLayout &DL = getDataLayout();
   const unsigned PointerSize = DL.getPointerSizeInBits() == 64 ? 8 : 4;
 
   MCSectionSubPair Current = OutStreamer->getCurrentSection();
   // Emit function descriptor.
   OutStreamer->SwitchSection(
       cast<MCSymbolXCOFF>(CurrentFnDescSym)->getRepresentedCsect());
+
+  // Emit aliasing label for function descriptor csect.
+  llvm::for_each(GOAliasMap[&MF->getFunction()],
+                 [this](const GlobalAlias *Alias) {
+                   OutStreamer->emitLabel(getSymbol(Alias));
+                 });
+
   // Emit function entry point address.
   OutStreamer->emitValue(MCSymbolRefExpr::create(CurrentFnSym, OutContext),
                          PointerSize);
   // Emit TOC base address.
   const MCSymbol *TOCBaseSym =
       cast<MCSectionXCOFF>(getObjFileLowering().getTOCBaseSection())
           ->getQualNameSymbol();
   OutStreamer->emitValue(MCSymbolRefExpr::create(TOCBaseSym, OutContext),
                          PointerSize);
   // Emit a null environment pointer.
   OutStreamer->emitIntValue(0, PointerSize);
 
   OutStreamer->SwitchSection(Current.first, Current.second);
 }
 
+void PPCAIXAsmPrinter::emitFunctionEntryLabel() {
+  PPCAsmPrinter::emitFunctionEntryLabel();
+  // Emit aliasing label for function entry point label.
+  llvm::for_each(
+      GOAliasMap[&MF->getFunction()], [this](const GlobalAlias *Alias) {
+        OutStreamer->emitLabel(
+            getObjFileLowering().getFunctionEntryPointSymbol(Alias, TM));
+      });
+}
+
 void PPCAIXAsmPrinter::emitEndOfAsmFile(Module &M) {
   // If there are no functions in this module, we will never need to reference
   // the TOC base.
   if (M.empty())
     return;
 
   // Switch to section to emit TOC base.
   OutStreamer->SwitchSection(getObjFileLowering().getTOCBaseSection());
for (auto &I : TOC) {
 
     OutStreamer->emitLabel(I.second);
     if (TS != nullptr)
       TS->emitTCEntry(*I.first);
   }
 }
 
 bool PPCAIXAsmPrinter::doInitialization(Module &M) {
-  if (M.alias_size() > 0u)
-    report_fatal_error(
-        "module has aliases, which LLVM does not yet support for AIX");
-
   const bool Result = PPCAsmPrinter::doInitialization(M);
 
   auto setCsectAlignment = [this](const GlobalObject *GO) {
     // Declarations have 0 alignment which is set by default.
     if (GO->isDeclarationForLinker())
       return;
 
     SectionKind GOKind = getObjFileLowering().getKindForGlobal(GO, TM);
bool PPCAIXAsmPrinter::doInitialization(Module &M) {
   // because once a .csect directive gets emitted, we could not change the
   // alignment value on it.
   for (const auto &G : M.globals())
     setCsectAlignment(&G);
 
   for (const auto &F : M)
     setCsectAlignment(&F);
 
+  // Construct an aliasing list for each GlobalObject.
+  for (const auto &Alias : M.aliases()) {
+    const GlobalObject *Base = Alias.getBaseObject();
+    if (!Base)
+      report_fatal_error(
+          "alias without a base object is not yet supported on AIX");
+    GOAliasMap[Base].push_back(&Alias);
+  }
+
   return Result;
 }
 
 void PPCAIXAsmPrinter::emitInstruction(const MachineInstr *MI) {
   switch (MI->getOpcode()) {
   default:
     break;
   case PPC::BL8:

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

if (isFunctionGlobalAddress(Callee)) {
     const GlobalAddressSDNode *G = cast<GlobalAddressSDNode>(Callee);
     const GlobalValue *GV = G->getGlobal();
 
     if (!Subtarget.isAIXABI())
       return DAG.getTargetGlobalAddress(GV, dl, Callee.getValueType(), 0,
                                         UsePlt ? PPCII::MO_PLT : 0);
 
     assert(!isa<GlobalIFunc>(GV) && "IFunc is not supported on AIX.");
-    const GlobalObject *GO = cast<GlobalObject>(GV);
     const XCOFF::StorageClass SC =
-        TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GO);
-    return getAIXFuncEntryPointSymbolSDNode(GO->getName(), GO->isDeclaration(),
+        TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GV);
+    return getAIXFuncEntryPointSymbolSDNode(GV->getName(), GV->isDeclaration(),
                                             SC);
   }
 
   if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
     const char *SymName = S->getSymbol();
     if (Subtarget.isAIXABI()) {
       // If there exists a user-declared function whose name is the same as the
       // ExternalSymbol's, then we pick up the user-declared version.

llvm/test/CodeGen/PowerPC/aix-alias-unsupported.ll

+; RUN: not --crash llc < %s -mtriple powerpc-ibm-aix-xcoff 2>&1 | FileCheck %s
+; RUN: not --crash llc < %s -mtriple powerpc64-ibm-aix-xcoff 2>&1 | FileCheck %s
+; CHECK: ERROR: alias without a base object is not yet supported on AIX
+
+@bar = global i32 42
+@test = alias i32, inttoptr(i32 42 to i32*)

llvm/test/CodeGen/PowerPC/aix-alias.ll

-; RUN: not --crash llc < %s -mtriple powerpc-ibm-aix-xcoff 2>&1 | FileCheck %s
-; RUN: not --crash llc < %s -mtriple powerpc64-ibm-aix-xcoff 2>&1 | FileCheck %s
+; TODO: Add object generation test when visibility for object generation
+;       is implemnted.
 
-; Check that, while generation of aliases on AIX remains unimplemented, llc dies
-; with an appropriate message instead of generating incorrect output when an
-; alias is encountered.
-
-define i32 @a() { ret i32 0 }
-; CHECK: ERROR: module has aliases
-@b = internal alias i32 (), i32 ()* @a
+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec < %s | \
+; RUN:   FileCheck --check-prefix=ASM %s
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec < %s | \
+; RUN:   FileCheck --check-prefix=ASM %s
+
+@var = global i32 42
+@var1 = alias i32, i32* @var
+@var2 = alias i32, i32* @var1
+@var_l = linkonce_odr alias i32, i32* @var
+@var_i = internal alias i32, i32* @var
+@var_h = hidden alias i32, i32* @var
+@var_p = protected alias i32, i32* @var
+
+@array = global [2 x i32] [i32 1, i32 2], align 4
+@x = global i32* bitcast (i8* getelementptr (i8, i8* bitcast ([2 x i32]* @array to i8*), i64 4) to i32*), align 4
+@bitcast_alias = alias i32*, i32** @x
+
+define i32 @fun() {
+  ret i32 0
+}
+
+%FunTy = type i32()
+@fun_weak = weak alias %FunTy, %FunTy* @fun
+@fun_hidden = hidden alias %FunTy, %FunTy* @fun
+@fun_ptr = global i32()* @fun_weak
+
+define i32 @test() {
+entry:
+   %tmp = load i32, i32* @var1
+   %tmp1 = load i32, i32* @var2
+   %tmp0 = load i32, i32* @var_i
+   %tmp2 = call i32 @fun()
+   %tmp3 = add i32 %tmp, %tmp2
+   %tmp4 = call i32 @fun_weak()
+   %tmp5 = add i32 %tmp3, %tmp4
+   %tmp6 = add i32 %tmp1, %tmp5
+   %tmp7 = add i32 %tmp6, %tmp0
+   %fun_ptr1 = alloca i32 ()*
+   store i32 ()* @fun_weak, i32 ()** %fun_ptr1
+   %callee.knr.cast = bitcast i32 ()** %fun_ptr1 to i32 ()*
+   %tmp8 = call i32 %callee.knr.cast()
+   %tmp9 = call i32 @fun_hidden()
+   %tmp10 = add i32 %tmp7, %tmp8
+   %tmp11 = add i32 %tmp10, %tmp9
+   ret i32 %tmp11
+}
+
+; ASM:         .globl  fun[DS]
+; ASM-NEXT:    .globl  .fun
+; ASM-NEXT:    .align  4
+; ASM-NEXT:    .csect fun[DS]
+; ASM-NEXT:  fun_weak:                               # @fun
+; ASM-NEXT:  fun_hidden:
+; ASM:         .csect .text[PR],2
+; ASM-NEXT:  .fun:
+; ASM-NEXT:  .fun_weak:
+; ASM-NEXT:  .fun_hidden:
+; ASM-NEXT:  # %bb.0:
+; ASM-NEXT:    li 3, 0
+; ASM-NEXT:    blr
+; ASM-NEXT:                                          # -- End function
+; ASM:       .csect .text[PR],2
+; ASM-NEXT:  .test:
+; ASM-NEXT:  # %bb.0:                                # %entry
+; ASM:         bl .fun
+; ASM-NEXT:    nop
+; ASM:         bl .fun_weak
+; ASM-NEXT:    nop
+; ASM:         bl .fun_hidden
+; ASM:                                               # -- End function
+; ASM-NEXT:    .csect .data[RW]
+; ASM-NEXT:    .globl  var
+; ASM:       var:
+; ASM-NEXT:  var1:
+; ASM-NEXT:  var2:
+; ASM-NEXT:  var_l:
+; ASM-NEXT:  var_i:
+; ASM-NEXT:  var_h:
+; ASM-NEXT:  var_p:
+; ASM-NEXT:    .vbyte  4, 42
+; ASM-NEXT:   .globl array
+; ASM:       array:
+; ASM-NEXT:    .vbyte 4, 1 # 0x1
+; ASM-NEXT:    .vbyte 4, 2 # 0x2
+; ASM-NEXT:    .globl x
+; ASM:       x:
+; ASM-NEXT:  bitcast_alias:
+; ASM-NEXT:    .vbyte  {{[0-9]+}}, array+4
+; ASM-NEXT:    .globl  fun_ptr
+; ASM:       fun_ptr:
+; ASM-NEXT:    .vbyte  {{[0-9]+}}, fun_weak
+; ASM-NEXT:    .globl  var1
+; ASM-NEXT:    .globl  var2
+; ASM-NEXT:    .weak var_l
+; ASM-NEXT:    .lglobl var_i
+; ASM-NEXT:    .globl  var_h,hidden
+; ASM-NEXT:    .globl  var_p,protected
+; ASM-NEXT:    .globl bitcast_alias
+; ASM-NEXT:    .weak fun_weak
+; ASM-NEXT:    .weak .fun_weak
+; ASM-NEXT:    .globl  fun_hidden,hidden
+; ASM-NEXT:    .globl  .fun_hidden,hidden
+; ASM-NEXT:    .toc
+; ASM-NEXT:  L..C0:
+; ASM-NEXT:    .tc var1[TC],var1
+; ASM-NEXT:  L..C1:
+; ASM-NEXT:    .tc var2[TC],var2
+; ASM-NEXT:  L..C2:
+; ASM-NEXT:    .tc var_i[TC],var_i
+; ASM-NEXT:  L..C3:
+; ASM-NEXT:    .tc fun_weak[TC],fun_weak