[clang][CodeGen] Break up TargetInfo.cpp [4/8]

[barannikov88]

Summary

Remove getABIInfo overrides returning references to target-specific
implementations of ABIInfo.
The methods may be convenient, but they are only used in one place and
prevent from ABIInfo implementations from being put into anonymous
namespaces in different cpp files.

[efriedma]

Is this supposed to be different from D148093?

[barannikov88]

In D148092#4302861, @efriedma wrote:

Is this supposed to be different from D148093?

Yes indeed. I've updated D148093.

[barannikov88]

Rebase

[efriedma]

Is there some alternative way we can write this? Even if each of the overrides is only technically used in one place, it's a repeating pattern, and writing the casts inline makes it really hard to read. (Maybe the helpers can be somewhere else?)

[barannikov88]

Add a templated overload to help derived classes avoid explicit casts

[barannikov88]

In D148092#4317438, @efriedma wrote:

Is there some alternative way we can write this? Even if each of the overrides is only technically used in one place, it's a repeating pattern, and writing the casts inline makes it really hard to read. (Maybe the helpers can be somewhere else?)

Thanks for the suggestion. Does it look better now?

[efriedma]

LGTM

[barannikov88]

Rebase

[barannikov88]

Rebase

clang/lib/CodeGen/TargetInfo.h

class TargetCodeGenInfo {
   std::unique_ptr<ABIInfo> Info;
 
 protected:
   // Target hooks supporting Swift calling conventions. The target must
   // initialize this field if it claims to support these calling conventions
   // by returning true from TargetInfo::checkCallingConvention for them.
   std::unique_ptr<SwiftABIInfo> SwiftInfo;
 
+  // Returns ABI info helper for the target. This is for use by derived classes.
+  template <typename T> const T &getABIInfo() const {
+    return static_cast<const T &>(*Info);
+  }
+
 public:
   TargetCodeGenInfo(std::unique_ptr<ABIInfo> Info);
   virtual ~TargetCodeGenInfo();
 
   /// getABIInfo() - Returns ABI info helper for the target.
   const ABIInfo &getABIInfo() const { return *Info; }
 
   /// Returns Swift ABI info helper for the target.

clang/lib/CodeGen/TargetInfo.cpp

 class X86_64TargetCodeGenInfo : public TargetCodeGenInfo {
 public:
   X86_64TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, X86AVXABILevel AVXLevel)
       : TargetCodeGenInfo(std::make_unique<X86_64ABIInfo>(CGT, AVXLevel)) {
     SwiftInfo =
         std::make_unique<SwiftABIInfo>(CGT, /*SwiftErrorInRegister=*/true);
   }
 
-  const X86_64ABIInfo &getABIInfo() const {
-    return static_cast<const X86_64ABIInfo&>(TargetCodeGenInfo::getABIInfo());
-  }
-
   /// Disable tail call on x86-64. The epilogue code before the tail jump blocks
   /// autoreleaseRV/retainRV and autoreleaseRV/unsafeClaimRV optimizations.
   bool markARCOptimizedReturnCallsAsNoTail() const override { return true; }
 
   int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const override {
     return 7;
   }
 
bool isNoProtoCallVariadic(const CallArgList &args,
     // function, so we override the default behavior.  However, don't do
     // that when AVX types are involved: the ABI explicitly states it is
     // undefined, and it doesn't work in practice because of how the ABI
     // defines varargs anyway.
     if (fnType->getCallConv() == CC_C) {
       bool HasAVXType = false;
       for (CallArgList::const_iterator
              it = args.begin(), ie = args.end(); it != ie; ++it) {
-        if (getABIInfo().isPassedUsingAVXType(it->Ty)) {
+        if (getABIInfo<X86_64ABIInfo>().isPassedUsingAVXType(it->Ty)) {
           HasAVXType = true;
           break;
         }
       }
 
       if (!HasAVXType)
         return true;
     }

 
 class ARMTargetCodeGenInfo : public TargetCodeGenInfo {
 public:
   ARMTargetCodeGenInfo(CodeGenTypes &CGT, ARMABIKind K)
       : TargetCodeGenInfo(std::make_unique<ARMABIInfo>(CGT, K)) {
     SwiftInfo = std::make_unique<ARMSwiftABIInfo>(CGT);
   }
 
-  const ARMABIInfo &getABIInfo() const {
-    return static_cast<const ARMABIInfo&>(TargetCodeGenInfo::getABIInfo());
-  }
-
   int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const override {
     return 13;
   }
 
   StringRef getARCRetainAutoreleasedReturnValueMarker() const override {
     return "mov\tr7, r7\t\t// marker for objc_retainAutoreleaseReturnValue";
   }
 
   bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
                                llvm::Value *Address) const override {
     llvm::Value *Four8 = llvm::ConstantInt::get(CGF.Int8Ty, 4);
 
     // 0-15 are the 16 integer registers.
     AssignToArrayRange(CGF.Builder, Address, Four8, 0, 15);
     return false;
   }
 
   unsigned getSizeOfUnwindException() const override {
-    if (getABIInfo().isEABI()) return 88;
+    if (getABIInfo<ARMABIInfo>().isEABI())
+      return 88;
     return TargetCodeGenInfo::getSizeOfUnwindException();
   }
 
   void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
                            CodeGen::CodeGenModule &CGM) const override {
     if (GV->isDeclaration())
       return;
     const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
     case ARMInterruptAttr::FIQ:     Kind = "FIQ"; break;
     case ARMInterruptAttr::SWI:     Kind = "SWI"; break;
     case ARMInterruptAttr::ABORT:   Kind = "ABORT"; break;
     case ARMInterruptAttr::UNDEF:   Kind = "UNDEF"; break;
     }
 
     Fn->addFnAttr("interrupt", Kind);
 
-    ARMABIKind ABI = cast<ARMABIInfo>(getABIInfo()).getABIKind();
+    ARMABIKind ABI = getABIInfo<ARMABIInfo>().getABIKind();
     if (ABI == ARMABIKind::APCS)
       return;
 
     // AAPCS guarantees that sp will be 8-byte aligned on any public interface,
     // however this is not necessarily true on taking any interrupt. Instruct
     // the backend to perform a realignment as part of the function prologue.
     llvm::AttrBuilder B(Fn->getContext());
     B.addStackAlignmentAttr(8);
public:
   void computeInfo(CGFunctionInfo &FI) const override;
   Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
                     QualType Ty) const override;
 };
 
 class SystemZTargetCodeGenInfo : public TargetCodeGenInfo {
   ASTContext &Ctx;
 
-  const SystemZABIInfo &getABIInfo() const {
-    return static_cast<const SystemZABIInfo&>(TargetCodeGenInfo::getABIInfo());
-  }
-
   // These are used for speeding up the search for a visible vector ABI.
   mutable bool HasVisibleVecABIFlag = false;
   mutable std::set<const Type *> SeenTypes;
 
   // Returns true (the first time) if Ty is, or is found to include, a vector
   // type that exposes the vector ABI. This is any vector >=16 bytes which
   // with vector support are aligned to only 8 bytes. When IsParam is true,
   // the type belongs to a value as passed between functions. If it is a
bool SystemZTargetCodeGenInfo::isVectorTypeBased(const Type *Ty,
   if (!SeenTypes.insert(Ty).second)
     return false;
 
   if (IsParam) {
     // A narrow (<16 bytes) vector will as a parameter also expose the ABI as
     // it will be passed in a vector register. A wide (>16 bytes) vector will
     // be passed via "hidden" pointer where any extra alignment is not
     // required (per GCC).
-    const Type *SingleEltTy =
-      getABIInfo().GetSingleElementType(QualType(Ty, 0)).getTypePtr();
+    const Type *SingleEltTy = getABIInfo<SystemZABIInfo>()
+                                  .GetSingleElementType(QualType(Ty, 0))
+                                  .getTypePtr();
     bool SingleVecEltStruct = SingleEltTy != Ty && SingleEltTy->isVectorType() &&
       Ctx.getTypeSize(SingleEltTy) == Ctx.getTypeSize(Ty);
     if (Ty->isVectorType() || SingleVecEltStruct)
       return Ctx.getTypeSize(Ty) / 8 <= 16;
   }
 
   // Assume pointers are dereferenced.
   while (Ty->isPointerType() || Ty->isArrayType())
public:
   }
 
 };
 
 class BPFTargetCodeGenInfo : public TargetCodeGenInfo {
 public:
   BPFTargetCodeGenInfo(CodeGenTypes &CGT)
       : TargetCodeGenInfo(std::make_unique<BPFABIInfo>(CGT)) {}
-
-  const BPFABIInfo &getABIInfo() const {
-    return static_cast<const BPFABIInfo&>(TargetCodeGenInfo::getABIInfo());
-  }
 };
 
 }
 
 // LoongArch ABI Implementation. Documented at
 // https://loongson.github.io/LoongArch-Documentation/LoongArch-ELF-ABI-EN.html
 //
 //===----------------------------------------------------------------------===//