Address comments round five.

- Added support for looking through aliases to the aliasees objects code
  model, along with lit testing.
- Split the shared code of 'getCodeModel' into PPCSubtarget and have
  PPCISelDAGToDAG and PPCAsmPrinter use that.
- Undo unintended change to 'getMCSymbolForTOCPsudoMO' that was left when
  addressing earlier comments.

Author: mandlebug

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

@@ -478,9 +478,6 @@ static CodeModel::Model getCodeModel(const PPCSubtarget &S,
                                      const TargetMachine &TM,
                                      const MachineOperand &MO) {
   CodeModel::Model ModuleModel = TM.getCodeModel();
-  // Per global code model is only supported on AIX.
-  if (!S.isAIXABI())
-    return ModuleModel;
 
   // If the operand is not a global address then there is no
   // global variable to carry an attribute.
@@ -490,24 +487,7 @@ static CodeModel::Model getCodeModel(const PPCSubtarget &S,
   const GlobalValue *GV = MO.getGlobal();
   assert(GV && "expected global for MO_GlobalAddress");
 
-  if (!isa<GlobalVariable>(GV))
-    return ModuleModel;
-
-  std::optional<CodeModel::Model> MaybeCodeModel =
-      cast<GlobalVariable>(GV)->getCodeModel();
-  if (MaybeCodeModel)
-    return *MaybeCodeModel;
-
-  return ModuleModel;
-}
-
-static std::optional<CodeModel::Model>
-getPerGlobalCodeModel(const GlobalValue *GV) {
-  // Symbols that aren't global variables cannot have the attribute.
-  if (!isa<GlobalVariable>(GV))
-    return std::nullopt;
-
-  return cast<GlobalVariable>(GV)->getCodeModel();
+  return S.getCodeModel(TM, GV);
 }
 
 static void setOptionalCodeModel(MCSymbolXCOFF *XSym, CodeModel::Model CM) {
@@ -772,11 +752,8 @@ void PPCAsmPrinter::EmitTlsCall(const MachineInstr *MI,
 static MCSymbol *getMCSymbolForTOCPseudoMO(const MachineOperand &MO,
                                            AsmPrinter &AP) {
   switch (MO.getType()) {
-  case MachineOperand::MO_GlobalAddress: {
-    const GlobalValue *GV = MO.getGlobal();
-    MCSymbol *Sym = AP.getSymbol(GV);
-    return Sym;
-  }
+  case MachineOperand::MO_GlobalAddress:
+    return AP.getSymbol(MO.getGlobal());
   case MachineOperand::MO_ConstantPoolIndex:
     return AP.GetCPISymbol(MO.getIndex());
   case MachineOperand::MO_JumpTableIndex:
@@ -3043,8 +3020,7 @@ bool PPCAIXAsmPrinter::doInitialization(Module &M) {
     }
 
     setCsectAlignment(&G);
-    std::optional<CodeModel::Model> OptionalCodeModel =
-        getPerGlobalCodeModel(&G);
+    std::optional<CodeModel::Model> OptionalCodeModel = G.getCodeModel();
     if (OptionalCodeModel)
       setOptionalCodeModel(cast<MCSymbolXCOFF>(getSymbol(&G)),
                            *OptionalCodeModel);
@@ -3069,6 +3045,15 @@ bool PPCAIXAsmPrinter::doInitialization(Module &M) {
                          false);
     }
 
+    const GlobalVariable *GVar =
+        dyn_cast_or_null<GlobalVariable>(Alias.getAliaseeObject());
+    if (GVar) {
+      std::optional<CodeModel::Model> OptionalCodeModel = GVar->getCodeModel();
+      if (OptionalCodeModel)
+        setOptionalCodeModel(cast<MCSymbolXCOFF>(getSymbol(&Alias)),
+                             *OptionalCodeModel);
+    }
+
     GOAliasMap[Aliasee].push_back(&Alias);
   }
 

llvm/lib/Target/PowerPC/PPCISelDAGToDAG.cpp

@@ -531,30 +531,15 @@ static CodeModel::Model getCodeModel(const PPCSubtarget &Subtarget,
   // this will be the effective code model.
   CodeModel::Model ModuleModel = TM.getCodeModel();
 
-  // Initially support per global code model for AIX only.
-  if (!Subtarget.isAIXABI())
-    return ModuleModel;
-
-  // If the operand is not a global address there is no
-  // GlobalVariable to query for an attribute.
-  SDValue Operand = Node->getOperand(0);
-  if (!isa<GlobalAddressSDNode>(Operand))
+  GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Node->getOperand(0));
+  if (!GA)
     return ModuleModel;
 
-  const GlobalValue *GV = cast<GlobalAddressSDNode>(Operand)->getGlobal();
-  if (!GV || !isa<GlobalVariable>(GV))
+  const GlobalValue *GV = GA->getGlobal();
+  if (!GV)
     return ModuleModel;
 
-  std::optional<CodeModel::Model> MaybeCodeModel =
-      dyn_cast<GlobalVariable>(GV)->getCodeModel();
-  if (MaybeCodeModel) {
-    CodeModel::Model CM = *MaybeCodeModel;
-    assert((CM == CodeModel::Small || CM == CodeModel::Large) &&
-           "invalid code model for AIX");
-    return CM;
-  }
-
-  return ModuleModel;
+  return Subtarget.getCodeModel(TM, GV);
 }
 
 /// isInt32Immediate - This method tests to see if the node is a 32-bit constant

llvm/lib/Target/PowerPC/PPCSubtarget.cpp

@@ -203,6 +203,46 @@ bool PPCSubtarget::isGVIndirectSymbol(const GlobalValue *GV) const {
   return true;
 }
 
+CodeModel::Model PPCSubtarget::getCodeModel(const TargetMachine &TM,
+                                            const GlobalValue *GV) const {
+  // If there isn't an attribute to override the module code model
+  // this will be the effective code model.
+  CodeModel::Model ModuleModel = TM.getCodeModel();
+
+  // Initially support per global code model for AIX only.
+  if (!isAIXABI())
+    return ModuleModel;
+
+  // Only GlobalVariables carry an attribute which can override the module code
+  // model.
+  assert(GV && "Unexpected NULL GlobalValue");
+  const GlobalVariable *GlobalVar =
+      [](const GlobalValue *GV) -> const GlobalVariable * {
+    const GlobalVariable *Var = dyn_cast<GlobalVariable>(GV);
+    if (Var)
+      return Var;
+
+    const GlobalAlias *Alias = dyn_cast<GlobalAlias>(GV);
+    if (Alias)
+      return dyn_cast<GlobalVariable>(Alias->getAliaseeObject());
+
+    return nullptr;
+  }(GV);
+
+  if (!GlobalVar)
+    return ModuleModel;
+
+  std::optional<CodeModel::Model> MaybeCodeModel = GlobalVar->getCodeModel();
+  if (MaybeCodeModel) {
+    CodeModel::Model CM = *MaybeCodeModel;
+    assert((CM == CodeModel::Small || CM == CodeModel::Large) &&
+           "invalid code model for AIX");
+    return CM;
+  }
+
+  return ModuleModel;
+}
+
 bool PPCSubtarget::isELFv2ABI() const { return TM.isELFv2ABI(); }
 bool PPCSubtarget::isPPC64() const { return TM.isPPC64(); }
 

llvm/lib/Target/PowerPC/PPCSubtarget.h

@@ -245,6 +245,10 @@ class PPCSubtarget : public PPCGenSubtargetInfo {
   /// True if the GV will be accessed via an indirect symbol.
   bool isGVIndirectSymbol(const GlobalValue *GV) const;
 
+  /// Calculates the effective code model for argument GV.
+  CodeModel::Model getCodeModel(const TargetMachine &TM,
+                                const GlobalValue *GV) const;
+
   /// True if the ABI is descriptor based.
   bool usesFunctionDescriptors() const {
     // Both 32-bit and 64-bit AIX are descriptor based. For ELF only the 64-bit

llvm/test/CodeGen/PowerPC/aix-codemodel-attr.ll

@@ -17,6 +17,14 @@
 @e = external dso_local global i32, align 4
 @f = dso_local global i32 2748, align 4
 
+@large_aliasee = global i32 10, code_model "large", align 4
+@small_aliasee = global i32 171, code_model "small", align 4
+@normal_aliasee = global i32 2748, align 4
+
+@al = alias i32, ptr @large_aliasee
+@as = alias i32, ptr @small_aliasee
+@an = alias i32, ptr @normal_aliasee
+
 define i32 @A() local_unnamed_addr {
 entry:
   %0 = load i32, ptr @a, align 4
@@ -120,6 +128,23 @@ entry:
 ; CHECK64: ld 3, L..C[[TL_D]]@l([[HI]])
 ; CHECK:   blr
 
+define i32 @G() {
+   %tmp = load i32, ptr @al
+   ret i32 %tmp
+}
+; CHECK:   addis [[HI:[0-9]+]], L..C[[TL_AL:[0-9]+]]@u(2)
+; CHECK32: lwz [[ADDR:[0-9]+]], L..C[[TL_AL]]@l([[HI]])
+; CHECK64: ld  [[ADDR:[0-9]+]], L..C[[TL_AL]]@l([[HI]])
+; CHECK:   lwz 3, 0([[ADDR]])
+
+define i32 @H() {
+   %tmp = load i32, ptr @as
+   ret i32 %tmp
+}
+; CHECK32: lwz [[ADDR:[0-9]+]], L..C[[TL_AS:[0-9]+]](2)
+; CHECK64: ld [[ADDR:[0-9]+]], L..C[[TL_AS:[0-9]+]](2)
+; CHECK:   lwz 3, 0([[ADDR]])
+
 ;; Check TOC entires have correct storage mapping class
 ; CHECK:         L..C[[TL_A]]:
 ; CHECK:           .tc a[TC],a[UA]
@@ -135,3 +160,7 @@ entry:
 ; CHECK:         L..C[[TL_F]]:
 ; CHECK-SMALL:     .tc f[TC],f[RW]
 ; CHECK-LARGE:     .tc f[TE],f[RW]
+; CHECK:         L..C[[TL_AL]]:
+; CHECK:           .tc al[TE],al
+; CHECK:         L..C[[TL_AS]]:
+; CHECK:           .tc as[TC],as