[AIX] Implement function descriptor on SDAG

[Xiangling_L]

Summary

(1)Function descriptor on AIX
On AIX, a called routine may have 2 distinct symbols associated with it:

• A function descriptor (Name)
• A function entry point (.Name)

The descriptor structure on AIX is the same as those in the ELF V1 ABI:

• The address of the entry point of the function.
• The TOC base address for the function.
• The environment pointer.

The descriptor symbol uses the same name as the source level function in C.
The function entry point is analogous to the symbol we would generate for a function in a
non-descriptor-based ABI, except that it is renamed by prepending a ".".

Which symbol gets referenced depends on the context:

• Taking the address of the function references the descriptor symbol.
• Calling the function references the entry point symbol.

(2)Speaking of implementation on AIX, for direct function call target, we create proper MCSymbol SDNode(e.g . ".foo") while constructing SDAG to replace original TargetGlobalAddress SDNode. Then down the path, we can take advantage of this MCSymbol.

(3)And since -stop-after llc option is used to test MIR results in the LIT testcase, to be able to get a MCSymbolXCOFF in SDAG layer, an option "-init-MC" is added to use together with -stop-after/-stop-before option to force llc doing the target object file lowering.

[Xiangling_L]

ping.

[hubert.reinterpretcast]

The commit message should explain something about function descriptor symbols on AIX and how they differ from the symbol that is created for the function entry point.

llvm/lib/CodeGen/LLVMTargetMachine.cpp

207 ↗

(On Diff #201684)

Use clang-format (pay attention to the spaces):

const_cast<TargetLoweringObjectFile &>(*this->getObjFileLowering())
    .Initialize(Ctx, *this);

llvm/lib/CodeGen/SelectionDAG/FastISel.cpp

1878 ↗

(On Diff #201684)

Is this statement of fundamental (permanent) fact? Please make the comment clear on that point. Clarify the relation between the first and the second sentences. For example, does the second sentence indicate something that is only done if we return false for AIX?

1879 ↗

(On Diff #201684)

s/functions/function's/;

1880 ↗

(On Diff #201684)

Split out the last part into a separate sentence:
The latter is the symbol whose XCOFF symbol name is the C-linkage name of the source level function.

llvm/lib/CodeGen/TargetPassConfig.cpp

203 ↗

(On Diff #201684)

Use clang-format:

static cl::opt<bool>
    InitMC("init-MC", cl::Hidden,
           cl::desc("Init target object file lowering when in use together "
                    "with -stop-after, -stop-before"));

In any case, notice that the current patch has a missing space before -stop-after in the string.

493 ↗

(On Diff #201684)

Remove the extra blank line.

llvm/lib/Target/PowerPC/PPC.h

91 ↗

(On Diff #201684)

This looks like a drive-by fix. If it is not, then clarify the relation of this comment to AIX.

llvm/lib/Target/PowerPC/PPCFastISel.cpp

1967 ↗

(On Diff #201684)

See the comments I made on FastISel.cpp.

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

4416 ↗

(On Diff #201684)

Using dyn_cast and then dereferencing the result without checking for null is not right. If the cast is expected to succeed, use cast. In that case, please also add a comment to explain why the cast is expected to succeed.

4419 ↗

(On Diff #201684)

Add a comma before "then".

4918 ↗

(On Diff #201684)

s/functions/function's/;

4919 ↗

(On Diff #201684)

s/pre-pending a "." to/inserting a "." before/;
s/functions/function's/;

4923 ↗

(On Diff #201684)

dyn_cast may return a null pointer. Please use cast if you expect the cast to succeed.

[syzaara]

llvm/lib/CodeGen/TargetPassConfig.cpp

204 ↗

(On Diff #201684)

nit: Init -> Initialize
End sentence with period.

[hubert.reinterpretcast]

llvm/lib/CodeGen/TargetPassConfig.cpp

204 ↗

(On Diff #201684)

To be contextually consistent with the surrounding use of cl::desc, the string should not end in a period.

[sfertile]

llvm/lib/CodeGen/LLVMTargetMachine.cpp

204 ↗

(On Diff #201684)

We either need to:

1. initialize the MCObjectFileInfo to be able to use mir tests with call instructions on AIX
2. Be able to add the requisite info the the MCSymbol base class, and not need to cast callee operands to an MCSymbolXCOFF during lowering.

If its safe to initialize MCObjectFileInfo even when we don't have an AsmPrinter, then maybe we should just always do so for MIR output on AIX.

llvm/lib/Target/PowerPC/PPC.h

91 ↗

(On Diff #201684)

This is my fault, I suggested we needed to fix comment but failed to explain it should be in a separate NFC patch. I'll land this separately for you.

[Xiangling_L]

Addressed 1st round reviews.

[jasonliu]

llvm/lib/CodeGen/SelectionDAG/FastISel.cpp

1878 ↗

(On Diff #201684)

I vaguely remember the discussion being... we will disable this fast-isel path for now on AIX and get the non-fast-isel path working first. We would deal with fast-isel path later down the road.
If my memory is correct, then I don't think it is a "permanent fact". So maybe we don't want to use words like "should always", and state that this would be "for now" and we will evaluate the situation later.

llvm/lib/Target/PowerPC/PPC.h

92 ↗

(On Diff #203018)

Extra blank line?

[Xiangling_L]

llvm/lib/CodeGen/LLVMTargetMachine.cpp

204 ↗

(On Diff #201684)

Some concerns as I discussed with Sean:

The base class implementation is not a pure virtual:

virtual TargetLoweringObjectFile *getObjFileLowering() const {
    return nullptr;
  }

not sure if something like that is expected to have a non-null TLOF.

Put some of my thoughts about doing target lowering object file code here:

[line 206]const_cast<TargetLoweringObjectFile&(*this->getObjFileLowering())
          .Initialize(Ctx, *this);

is extracted from generic AsmPrinter::doInitialization (lib/CodeGen/AsmPrinter/AsmPrinter.cpp:258), which means any backend that can init an AsmPrinter will have a non-null TLOF for sure, given that it seems all xxxAsmPrinter::doInitialization will finally call AsmPrinter::doInitialization. And back to our case here, it looks like the backends which will go through this path are only those who can add an AsmPrinter pass to, so I think it won't have a non-null TLOF.

[Xiangling_L]

llvm/lib/CodeGen/SelectionDAG/FastISel.cpp

1878 ↗

(On Diff #201684)

If we don't always ban fast-isel of call loweing on AIX, does that mean we need to duplicate logic of creating MCSymbolSDNode/MCSymbolXCOFF for function entry point on fast-isel path?

llvm/lib/Target/PowerPC/PPC.h

92 ↗

(On Diff #203018)

Thanks. will address this in the next update.

[hubert.reinterpretcast]

llvm/lib/CodeGen/SelectionDAG/FastISel.cpp

1878 ↗

(On Diff #201684)

I agree with Jason. There should be something about how the fast-isel path does not do the mapping at this time, and the "can be mapped" should say "will be mapped" to avoid the connotation that doing the mapping cannot be done other than by going through DAG-ISEL.

llvm/lib/Target/PowerPC/PPCFastISel.cpp

1967 ↗

(On Diff #201684)

Make the same tweaks to the comment here.

[Xiangling_L]

address 2nd reviews;

1. remove extra blank lines
2. tweak comments for disabling aix call lowering fast-isel path
3. set "always do target lowering object file" for AIX

[hubert.reinterpretcast]

llvm/lib/CodeGen/TargetPassConfig.cpp

490 ↗

(On Diff #203168)

Should we explain the rationale here?

491 ↗

(On Diff #203168)

Remove the extra space after getTargetTriple.

llvm/test/CodeGen/PowerPC/test_call_aix.ll

1 ↗

(On Diff #203168)

The -init-MC is no longer needed now; right?

[Xiangling_L]

llvm/test/CodeGen/PowerPC/test_call_aix.ll

1 ↗

(On Diff #203168)

You are right. And I am wondering do we still wanna create this option for other platforms? or do we wanna make some changes to do target object file lowering for AIX only?

[hubert.reinterpretcast]

llvm/test/CodeGen/PowerPC/test_call_aix.ll

1 ↗

(On Diff #203168)

I spoke with @sfertile today, and my understanding is that we don't want to add the option if we will just always perform the initialization on AIX (in which case, we don't need the willInitMCObjectFile function either).

[Xiangling_L]

3rd: delete init-MC option, and enable lowering object file on AIX always for MIR output.

[hubert.reinterpretcast]

Thanks Xiangling. Just a further minor comment.

llvm/lib/CodeGen/LLVMTargetMachine.cpp

206 ↗

(On Diff #203278)

Typo: "calle".
s/And to/To/;

[Xiangling_L]

address minor changes

[hubert.reinterpretcast]

I think everyone's comments have been addressed. Thanks again, Xiangling.

llvm/lib/CodeGen/LLVMTargetMachine.cpp

205 ↗

(On Diff #203361)

Sorry for missing this earlier. Please remove the space before the comma.

[Xiangling_L]

rebase onto the latest master branch and address minor changes

[sfertile]

LGTM.

llvm/lib/CodeGen/LLVMTargetMachine.cpp

205 ↗

(On Diff #203361)

I would suggest slightly rewording thjis comment along the lines of:

On AIX we might manifest MCSymbols during SDAG lowering. For mir testing to be meaningful we need to ensure that the symbols created are MCSymboLXCOFF variants, which requires that TargetLoweringObjectFile has been initialized.

[Xiangling_L]

Fix LIT testcase from delivered call lowering patch.

[Xiangling_L]

address minor changes

[hubert.reinterpretcast]

llvm/lib/CodeGen/LLVMTargetMachine.cpp

205 ↗

(On Diff #203406)

Add a comma after "AIX".

206 ↗

(On Diff #203406)

Add a comma after "meaningful".

207 ↗

(On Diff #203406)

s/MCSymboLXCOFF/MCSymbolXCOFF/;

208 ↗

(On Diff #203406)

s/TargetLoweringObjectFile/the TargetLoweringObjectFile instance/;

[jasonliu]

Last few comments by Hubert addressed in the landed commit.

[gribozavr]

llvm/trunk/include/llvm/MC/MCSymbolXCOFF.h

13

llvm/IR/GlobalValue.h can't be included in MC, that creates a circular dependency between MC and IR libraries. This circular dependency is causing an issue for build system that enforce layering. Is there another way to implement this change?

[gribozavr]

llvm/trunk/include/llvm/MC/MCSymbolXCOFF.h

13

I committed a workaround in r362782, but it is only a workaround, and it would be nice to have a real fix.

[Xiangling_L]

llvm/trunk/include/llvm/MC/MCSymbolXCOFF.h

13

Thanks for the workaround. We will discuss and see if there is a better way to implement this.

[Xiangling_L]

llvm/trunk/include/llvm/MC/MCSymbolXCOFF.h

13

Hi, I am now working on a fix for this. And I am wondering if there is any documentation about things like IR&MC dependency you pointed out here?

llvm/trunk/include/llvm/MC/MCSymbol.h

protected:
   /// The kind of the symbol.  If it is any value other than unset then this
   /// class is actually one of the appropriate subclasses of MCSymbol.
   enum SymbolKind {
     SymbolKindUnset,
     SymbolKindCOFF,
     SymbolKindELF,
     SymbolKindMachO,
     SymbolKindWasm,
+    SymbolKindXCOFF,
   };
 
   /// A symbol can contain an Offset, or Value, or be Common, but never more
   /// than one of these.
   enum Contents : uint8_t {
     SymContentsUnset,
     SymContentsOffset,
     SymContentsVariable,
public:
   bool isELF() const { return Kind == SymbolKindELF; }
 
   bool isCOFF() const { return Kind == SymbolKindCOFF; }
 
   bool isMachO() const { return Kind == SymbolKindMachO; }
 
   bool isWasm() const { return Kind == SymbolKindWasm; }
 
+  bool isXCOFF() const { return Kind == SymbolKindXCOFF; }
+
   /// @}
   /// \name Variable Symbols
   /// @{
 
   /// isVariable - Check if this is a variable symbol.
   bool isVariable() const {
     return SymbolContents == SymContentsVariable;
   }

llvm/trunk/include/llvm/MC/MCSymbolXCOFF.h

+//===- MCSymbolXCOFF.h -  ----------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_MC_MCSYMBOLXCOFF_H
+#define LLVM_MC_MCSYMBOLXCOFF_H
+
+#include "llvm/BinaryFormat/XCOFF.h"
+#include "llvm/MC/MCSymbol.h"
+#include "llvm/IR/GlobalValue.h"
+
+namespace llvm {
+
+class MCSymbolXCOFF : public MCSymbol {
+  // The IR symbol this MCSymbolXCOFF is based on. It is set on function
+  // entry point symbols when they are the callee operand of a direct call
+  // SDNode.
+  const GlobalValue *GV = nullptr;
+
+public:
+  MCSymbolXCOFF(const StringMapEntry<bool> *Name, bool isTemporary)
+      : MCSymbol(SymbolKindXCOFF, Name, isTemporary) {}
+
+  void setGlobalValue(const GlobalValue *G) { GV = G; }
+  const GlobalValue *getGlobalValue() const { return GV; }
+
+  static bool classof(const MCSymbol *S) { return S->isXCOFF(); }
+};
+
+} // end namespace llvm
+
+#endif // LLVM_MC_MCSYMBOLXCOFF_H

llvm/trunk/lib/CodeGen/LLVMTargetMachine.cpp

bool LLVMTargetMachine::addPassesToEmitFile(PassManagerBase &PM,
   if (!MMI)
     MMI = new MachineModuleInfo(this);
   TargetPassConfig *PassConfig =
       addPassesToGenerateCode(*this, PM, DisableVerify, *MMI);
   if (!PassConfig)
     return true;
 
   if (!TargetPassConfig::willCompleteCodeGenPipeline()) {
+    if (this->getTargetTriple().isOSAIX()) {
+      // On AIX, we might manifest MCSymbols during SDAG lowering. For MIR
+      // testing to be meaningful, we need to ensure that the symbols created
+      // are MCSymbolXCOFF variants, which requires that
+      // the TargetLoweringObjectFile instance has been initialized.
+      MCContext &Ctx = MMI->getContext();
+      const_cast<TargetLoweringObjectFile &>(*this->getObjFileLowering())
+          .Initialize(Ctx, *this);
+    }
     PM.add(createPrintMIRPass(Out));
   } else if (addAsmPrinter(PM, Out, DwoOut, FileType, MMI->getContext()))
     return true;
 
   PM.add(createFreeMachineFunctionPass());
   return false;
 }
 

llvm/trunk/lib/CodeGen/SelectionDAG/FastISel.cpp

case Instruction::Alloca:
     // FunctionLowering has the static-sized case covered.
     if (FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(I)))
       return true;
 
     // Dynamic-sized alloca is not handled yet.
     return false;
 
   case Instruction::Call:
+    // On AIX, call lowering uses the DAG-ISEL path currently so that the
+    // callee of the direct function call instruction will be mapped to the
+    // symbol for the function's entry point, which is distinct from the
+    // function descriptor symbol. The latter is the symbol whose XCOFF symbol
+    // name is the C-linkage name of the source level function.
+    if (TM.getTargetTriple().isOSAIX())
+      return false;
     return selectCall(I);
 
   case Instruction::BitCast:
     return selectBitCast(I);
 
   case Instruction::FPToSI:
     return selectCast(I, ISD::FP_TO_SINT);
   case Instruction::ZExt:

llvm/trunk/lib/MC/MCContext.cpp

 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolCOFF.h"
 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/MC/MCSymbolMachO.h"
 #include "llvm/MC/MCSymbolWasm.h"
+#include "llvm/MC/MCSymbolXCOFF.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.h"
case MCObjectFileInfo::IsCOFF:
       return new (Name, *this) MCSymbolCOFF(Name, IsTemporary);
     case MCObjectFileInfo::IsELF:
       return new (Name, *this) MCSymbolELF(Name, IsTemporary);
     case MCObjectFileInfo::IsMachO:
       return new (Name, *this) MCSymbolMachO(Name, IsTemporary);
     case MCObjectFileInfo::IsWasm:
       return new (Name, *this) MCSymbolWasm(Name, IsTemporary);
     case MCObjectFileInfo::IsXCOFF:
-      // TODO: Need to implement class MCSymbolXCOFF.
-      break;
+      return new (Name, *this) MCSymbolXCOFF(Name, IsTemporary);
     }
   }
   return new (Name, *this) MCSymbol(MCSymbol::SymbolKindUnset, Name,
                                     IsTemporary);
 }
 
 MCSymbol *MCContext::createSymbol(StringRef Name, bool AlwaysAddSuffix,
                                   bool CanBeUnnamed) {

llvm/trunk/lib/Target/PowerPC/PPCFastISel.cpp

case Instruction::FPToUI:
       return SelectFPToI(I, /*IsSigned*/ false);
     case Instruction::Add:
       return SelectBinaryIntOp(I, ISD::ADD);
     case Instruction::Or:
       return SelectBinaryIntOp(I, ISD::OR);
     case Instruction::Sub:
       return SelectBinaryIntOp(I, ISD::SUB);
     case Instruction::Call:
+      // On AIX, call lowering uses the DAG-ISEL path currently so that the
+      // callee of the direct function call instruction will be mapped to the
+      // symbol for the function's entry point, which is distinct from the
+      // function descriptor symbol. The latter is the symbol whose XCOFF symbol
+      // name is the C-linkage name of the source level function.
+      if (TM.getTargetTriple().isOSAIX())
+        break;
       return selectCall(I);
     case Instruction::Ret:
       return SelectRet(I);
     case Instruction::Trunc:
       return SelectTrunc(I);
     case Instruction::ZExt:
     case Instruction::SExt:
       return SelectIntExt(I);

llvm/trunk/lib/Target/PowerPC/PPCISelLowering.cpp

 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineJumpTableInfo.h"
 #include "llvm/CodeGen/MachineLoopInfo.h"
 #include "llvm/CodeGen/MachineMemOperand.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineOperand.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/RuntimeLibcalls.h"
 #include "llvm/CodeGen/SelectionDAG.h"
 #include "llvm/CodeGen/SelectionDAGNodes.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
 #include "llvm/CodeGen/TargetLowering.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"

 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Use.h"
 #include "llvm/IR/Value.h"
+#include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCSymbolXCOFF.h"
 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/BranchProbability.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
static int CalculateTailCallSPDiff(SelectionDAG& DAG, bool isTailCall,
   return SPDiff;
 }
 
 static bool isFunctionGlobalAddress(SDValue Callee);
 
 static bool
 callsShareTOCBase(const Function *Caller, SDValue Callee,
                     const TargetMachine &TM) {
-  // If !G, Callee can be an external symbol.
-  GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee);
-  if (!G)
+  // Need a GlobalValue to determine if a Caller and Callee share the same
+  // TOCBase.
+  const GlobalValue *GV = nullptr;
+
+  if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
+    GV = G->getGlobal();
+  } else if (MCSymbolSDNode *M = dyn_cast<MCSymbolSDNode>(Callee)) {
+    // On AIX only, we replace GlobalAddressSDNode with MCSymbolSDNode for
+    // the callee of a direct function call. The MCSymbolSDNode contains the
+    // MCSymbol for the funtion entry point.
+    const auto *S = cast<MCSymbolXCOFF>(M->getMCSymbol());
+    GV = S->getGlobalValue();
+  }
+
+  // If we failed to get a GlobalValue, then pessimistically assume they do not
+  // share a TOCBase.
+  if (!GV)
     return false;
 
   // The medium and large code models are expected to provide a sufficiently
   // large TOC to provide all data addressing needs of a module with a
   // single TOC. Since each module will be addressed with a single TOC then we
   // only need to check that caller and callee don't cross dso boundaries.
   if (CodeModel::Medium == TM.getCodeModel() ||
       CodeModel::Large == TM.getCodeModel())
-    return TM.shouldAssumeDSOLocal(*Caller->getParent(), G->getGlobal());
+    return TM.shouldAssumeDSOLocal(*Caller->getParent(), GV);
 
   // Otherwise we need to ensure callee and caller are in the same section,
   // since the linker may allocate multiple TOCs, and we don't know which
   // sections will belong to the same TOC base.
 
-  const GlobalValue *GV = G->getGlobal();
   if (!GV->isStrongDefinitionForLinker())
     return false;
 
   // Any explicitly-specified sections and section prefixes must also match.
   // Also, if we're using -ffunction-sections, then each function is always in
   // a different section (the same is true for COMDAT functions).
   if (TM.getFunctionSections() || GV->hasComdat() || Caller->hasComdat() ||
       GV->getSection() != Caller->getSection())
if (SDNode *Dest = isBLACompatibleAddress(Callee, DAG)) {
       Callee = SDValue(Dest, 0);
       needIndirectCall = false;
     }
 
   // PC-relative references to external symbols should go through $stub, unless
   // we're building with the leopard linker or later, which automatically
   // synthesizes these stubs.
   const TargetMachine &TM = DAG.getTarget();
-  const Module *Mod = DAG.getMachineFunction().getFunction().getParent();
+  MachineFunction &MF = DAG.getMachineFunction();
+  const Module *Mod = MF.getFunction().getParent();
   const GlobalValue *GV = nullptr;
   if (auto *G = dyn_cast<GlobalAddressSDNode>(Callee))
     GV = G->getGlobal();
   bool Local = TM.shouldAssumeDSOLocal(*Mod, GV);
   bool UsePlt = !Local && Subtarget.isTargetELF() && !isPPC64;
 
   if (isFunctionGlobalAddress(Callee)) {
     GlobalAddressSDNode *G = cast<GlobalAddressSDNode>(Callee);
+
+    if (TM.getTargetTriple().isOSAIX()) {
+      // Direct function calls reference the symbol for the function's entry
+      // point, which is named by inserting a "." before the function's
+      // C-linkage name.
+      auto &Context = MF.getMMI().getContext();
+      MCSymbol *S = Context.getOrCreateSymbol(Twine(".") +
+                                              Twine(G->getGlobal()->getName()));
+      cast<MCSymbolXCOFF>(S)->setGlobalValue(GV);
+      Callee = DAG.getMCSymbol(S, PtrVT);
+    } else {
       // A call to a TLS address is actually an indirect call to a
       // thread-specific pointer.
       unsigned OpFlags = 0;
       if (UsePlt)
         OpFlags = PPCII::MO_PLT;
 
       // If the callee is a GlobalAddress/ExternalSymbol node (quite common,
       // every direct call is) turn it into a TargetGlobalAddress /
       // TargetExternalSymbol node so that legalize doesn't hack it.
       Callee = DAG.getTargetGlobalAddress(G->getGlobal(), dl,
                                           Callee.getValueType(), 0, OpFlags);
+    }
     needIndirectCall = false;
   }
 
   if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
     unsigned char OpFlags = 0;
 
     if (UsePlt)
       OpFlags = PPCII::MO_PLT;

llvm/trunk/lib/Target/PowerPC/PPCInstr64Bit.td

 def : Pat<(PPCcall_nop (i64 tglobaladdr:$dst)),
           (BL8_NOP tglobaladdr:$dst)>;
 
 def : Pat<(PPCcall (i64 texternalsym:$dst)),
           (BL8 texternalsym:$dst)>;
 def : Pat<(PPCcall_nop (i64 texternalsym:$dst)),
           (BL8_NOP texternalsym:$dst)>;
 
+// Calls for AIX
+def : Pat<(PPCcall (i64 mcsym:$dst)),
+          (BL8 mcsym:$dst)>;
+def : Pat<(PPCcall_nop (i64 mcsym:$dst)),
+          (BL8_NOP mcsym:$dst)>;
+
 // Atomic operations
 // FIXME: some of these might be used with constant operands. This will result
 // in constant materialization instructions that may be redundant. We currently
 // clean this up in PPCMIPeephole with calls to
 // PPCInstrInfo::convertToImmediateForm() but we should probably not emit them
 // in the first place.
 let Defs = [CR0] in {
   def ATOMIC_LOAD_ADD_I64 : PPCCustomInserterPseudo<

llvm/trunk/lib/Target/PowerPC/PPCInstrInfo.td

 
 // RLWNM
 def : Pat<(and (rotl i32:$in, i32:$sh), maskimm32:$imm),
           (RLWNM $in, $sh, (MB maskimm32:$imm), (ME maskimm32:$imm))>;
 
 // Calls
 def : Pat<(PPCcall (i32 tglobaladdr:$dst)),
           (BL tglobaladdr:$dst)>;
-def : Pat<(PPCcall_nop (i32 tglobaladdr:$dst)),
-          (BL_NOP tglobaladdr:$dst)>;
 
 def : Pat<(PPCcall (i32 texternalsym:$dst)),
           (BL texternalsym:$dst)>;
 
+// Calls for AIX only
+def : Pat<(PPCcall (i32 mcsym:$dst)),
+          (BL mcsym:$dst)>;
+def : Pat<(PPCcall_nop (i32 mcsym:$dst)),
+          (BL_NOP mcsym:$dst)>;
+
 def : Pat<(PPCtc_return (i32 tglobaladdr:$dst),  imm:$imm),
           (TCRETURNdi tglobaladdr:$dst, imm:$imm)>;
 
 def : Pat<(PPCtc_return (i32 texternalsym:$dst), imm:$imm),
           (TCRETURNdi texternalsym:$dst, imm:$imm)>;
 
 def : Pat<(PPCtc_return CTRRC:$dst, imm:$imm),
           (TCRETURNri CTRRC:$dst, imm:$imm)>;

llvm/trunk/test/CodeGen/PowerPC/aix_gpr_param.ll

 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff -stop-after=machine-cp < %s | \
 ; RUN: FileCheck --check-prefix=32BIT %s
 
 ; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -stop-after=machine-cp < %s | \
 ; RUN: FileCheck --check-prefix=64BIT %s
 
 define void @call_test_char() {
 entry:
 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 ; 32BIT: $r3 = LI 97
-; 32BIT: BL_NOP @test_char, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit $r2, implicit-def $r1
+; 32BIT: BL_NOP <mcsymbol .test_char>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit $r2, implicit-def $r1
 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 
 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 ; 64BIT: $x3 = LI8 97
-; 64BIT: BL8_NOP @test_char, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit $x2, implicit-def $r1
+; 64BIT: BL8_NOP <mcsymbol .test_char>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit $x2, implicit-def $r1
 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 
   call void @test_char(i8 signext 97)
   ret void
 }
 
 define void @call_test_chars() {
 entry:
 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 ; 32BIT: $r3 = LI 97
 ; 32BIT: $r4 = LI 97
 ; 32BIT: $r5 = LI 97
 ; 32BIT: $r6 = LI 97
-; 32BIT: BL_NOP @test_chars, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit killed $r4, implicit killed $r5, implicit killed $r6, implicit $r2, implicit-def $r1
+; 32BIT: BL_NOP <mcsymbol .test_chars>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit killed $r4, implicit killed $r5, implicit killed $r6, implicit $r2, implicit-def $r1
 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 
 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 ; 64BIT: $x3 = LI8 97
 ; 64BIT: $x4 = LI8 97
 ; 64BIT: $x5 = LI8 97
 ; 64BIT: $x6 = LI8 97
-; 64BIT: BL8_NOP @test_chars, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit killed $x4, implicit killed $x5, implicit killed $x6, implicit $x2, implicit-def $r1
+; 64BIT: BL8_NOP <mcsymbol .test_chars>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit killed $x4, implicit killed $x5, implicit killed $x6, implicit $x2, implicit-def $r1
 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 
   call void @test_chars(i8 signext 97, i8 signext 97, i8 signext 97, i8 signext 97)
   ret void
 }
 
 define void @call_test_chars_mix() {
 entry:
 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 ; 32BIT: $r3 = LI 97
 ; 32BIT: $r4 = LI 225
 ; 32BIT: $r5 = LI 97
 ; 32BIT: $r6 = LI -31
-; 32BIT: BL_NOP @test_chars_mix, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit killed $r4, implicit killed $r5, implicit killed $r6, implicit $r2, implicit-def $r1
+; 32BIT: BL_NOP <mcsymbol .test_chars_mix>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit killed $r4, implicit killed $r5, implicit killed $r6, implicit $r2, implicit-def $r1
 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 
 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 ; 64BIT: $x3 = LI8 97
 ; 64BIT: $x4 = LI8 225
 ; 64BIT: $x5 = LI8 97
 ; 64BIT: $x6 = LI8 -31
-; 64BIT: BL8_NOP @test_chars_mix, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit killed $x4, implicit killed $x5, implicit killed $x6, implicit $x2, implicit-def $r1
+; 64BIT: BL8_NOP <mcsymbol .test_chars_mix>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit killed $x4, implicit killed $x5, implicit killed $x6, implicit $x2, implicit-def $r1
 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 
   call void @test_chars_mix(i8 signext 97, i8 zeroext -31, i8 zeroext 97, i8 signext -31)
   ret void
 }
 
 define void @call_test_int() {
 entry:
 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 ; 32BIT: $r3 = LI 1
-; 32BIT: BL_NOP @test_int, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit $r2, implicit-def $r1
+; 32BIT: BL_NOP <mcsymbol .test_int>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit $r2, implicit-def $r1
 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 
 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 ; 64BIT: $x3 = LI8 1
-; 64BIT: BL8_NOP @test_int, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit $x2, implicit-def $r1
+; 64BIT: BL8_NOP <mcsymbol .test_int>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit $x2, implicit-def $r1
 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 
   call void @test_int(i32 1)
   ret void
 }
 
 define void @call_test_ints() {
 entry:
 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 ; 32BIT: $r3 = LI 1
 ; 32BIT: $r4 = LI 1
 ; 32BIT: $r5 = LI 1
 ; 32BIT: $r6 = LI 1
 ; 32BIT: $r7 = LI 1
 ; 32BIT: $r8 = LI 1
 ; 32BIT: $r9 = LI 1
 ; 32BIT: $r10 = LI 1
-; 32BIT: BL_NOP @test_ints, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit killed $r4, implicit killed $r5, implicit killed $r6, implicit killed $r7, implicit killed $r8, implicit killed $r9, implicit killed $r10, implicit $r2, implicit-def $r1
+; 32BIT: BL_NOP <mcsymbol .test_ints>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit killed $r4, implicit killed $r5, implicit killed $r6, implicit killed $r7, implicit killed $r8, implicit killed $r9, implicit killed $r10, implicit $r2, implicit-def $r1
 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 
 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 ; 64BIT: $x3 = LI8 1
 ; 64BIT: $x4 = LI8 1
 ; 64BIT: $x5 = LI8 1
 ; 64BIT: $x6 = LI8 1
 ; 64BIT: $x7 = LI8 1
 ; 64BIT: $x8 = LI8 1
 ; 64BIT: $x9 = LI8 1
 ; 64BIT: $x10 = LI8 1
-; 64BIT: BL8_NOP @test_ints, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit killed $x4, implicit killed $x5, implicit killed $x6, implicit killed $x7, implicit killed $x8, implicit killed $x9, implicit killed $x10, implicit $x2, implicit-def $r1
+; 64BIT: BL8_NOP <mcsymbol .test_ints>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit killed $x4, implicit killed $x5, implicit killed $x6, implicit killed $x7, implicit killed $x8, implicit killed $x9, implicit killed $x10, implicit $x2, implicit-def $r1
 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 
   call void @test_ints(i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1)
   ret void
 }
 
 define void @call_test_ints_64bit() {
 entry:
 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 ; 64BIT: renamable $x3 = LI8 1
 ; 64BIT: renamable $x5 = RLDICR killed renamable $x3, 31, 32
 ; 64BIT: $x3 = LI8 1
 ; 64BIT: $x4 = LI8 1
 ; 64BIT: $x6 = LIS8 32768
 ; 64BIT: $x7 = LI8 1
 ; 64BIT: $x8 = LI8 1
 ; 64BIT: $x9 = LI8 1
 ; 64BIT: $x10 = LI8 1
-; 64BIT: BL8_NOP @test_ints_64bit, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit killed $x4, implicit $x5, implicit killed $x6, implicit killed $x7, implicit killed $x8, implicit killed $x9, implicit killed $x10, implicit $x2, implicit-def $r1
+; 64BIT: BL8_NOP <mcsymbol .test_ints_64bit>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit killed $x4, implicit $x5, implicit killed $x6, implicit killed $x7, implicit killed $x8, implicit killed $x9, implicit killed $x10, implicit $x2, implicit-def $r1
 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 
   call void @test_ints_64bit(i32 signext 1, i32 zeroext 1, i32 zeroext 2147483648, i32 signext -2147483648, i32 signext 1, i32 signext 1, i32 signext 1, i32 signext 1)
   ret void
 }
 
 define void @call_test_i1() {
 entry:
 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 ; 32BIT: $r3 = LI 1
-; 32BIT: BL_NOP @test_i1, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit $r2, implicit-def $r1
+; 32BIT: BL_NOP <mcsymbol .test_i1>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit $r2, implicit-def $r1
 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 
 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 ; 64BIT: $x3 = LI8 1
-; 64BIT: BL8_NOP @test_i1, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit $x2, implicit-def $r1
+; 64BIT: BL8_NOP <mcsymbol .test_i1>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit $x2, implicit-def $r1
 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 
   call void @test_i1(i1 1)
   ret void
 }
 
 define void @call_test_i64() {
 entry:
 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 ; 32BIT: $r3 = LI 0
 ; 32BIT: $r4 = LI 1
-; 32BIT: BL_NOP @test_i64, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit killed $r4, implicit $r2, implicit-def $r1
+; 32BIT: BL_NOP <mcsymbol .test_i64>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit killed $r4, implicit $r2, implicit-def $r1
 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 
 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 ; 64BIT: $x3 = LI8 1
-; 64BIT: BL8_NOP @test_i64, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit $x2, implicit-def $r1
+; 64BIT: BL8_NOP <mcsymbol .test_i64>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit $x2, implicit-def $r1
 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 
   call void @test_i64(i64 1)
   ret void
 }
 
 define void @call_test_int_ptr() {
 entry:
   %b = alloca i32, align 4
 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 ; 32BIT: renamable $r3 = ADDI %stack.0.b, 0
-; 32BIT: BL_NOP @test_int_ptr, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r3, implicit $r2, implicit-def $r1
+; 32BIT: BL_NOP <mcsymbol .test_int_ptr>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r3, implicit $r2, implicit-def $r1
 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 
 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 ; 64BIT: renamable $x3 = ADDI8 %stack.0.b, 0
-; 64BIT: BL8_NOP @test_int_ptr, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit $x2, implicit-def $r1
+; 64BIT: BL8_NOP <mcsymbol .test_int_ptr>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit $x2, implicit-def $r1
 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 
   store i32 0, i32* %b, align 4
   call void @test_int_ptr(i32* %b)
   ret void
 }
 
 declare void @test_char(i8 signext)

llvm/trunk/test/CodeGen/PowerPC/test_call_aix.ll

 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff -stop-after=machine-cp < %s | \
 ; RUN: FileCheck --check-prefix=32BIT %s
 
 ; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -stop-after=machine-cp < %s | \
 ; RUN: FileCheck --check-prefix=64BIT %s
 
 declare void @foo(...)
 
 define void @test_call() {
 entry:
 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
-; 32BIT: BL_NOP @foo, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r2, implicit-def $r1
+; 32BIT: BL_NOP <mcsymbol .foo>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r2, implicit-def $r1
 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 
 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
-; 64BIT: BL8_NOP @foo, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit $x2, implicit-def $r1
+; 64BIT: BL8_NOP <mcsymbol .foo>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit $x2, implicit-def $r1
 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 
   call void bitcast (void (...)* @foo to void ()*)()
   ret void
 }
 
 define hidden void @foo_local() {
 entry:
   ret void
 }
 
 define void @test_local_call() {
 entry:
 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
-; 32BIT: BL @foo_local, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r2, implicit-def $r1
+; 32BIT: BL <mcsymbol .foo_local>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r2, implicit-def $r1
 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 
 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
-; 64BIT: BL8 @foo_local, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit $x2, implicit-def $r1
+; 64BIT: BL8 <mcsymbol .foo_local>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit $x2, implicit-def $r1
 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 
   call void @foo_local()
   ret void
 }