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

[barannikov88]

Summary

Make occupiesMoreThan a protected member of SwiftABIInfo.
This method is only used by implementations of SwiftABIInfo.
Making it protected will allow to use it after the implementations
are moved to dedicated cpp files.

[barannikov88]

Drop unintended changes

[barannikov88]

Attempt to overcome arc

[barannikov88]

Overcome arc, 2nd attempt

[barannikov88]

clang/lib/CodeGen/TargetInfo.cpp

128

Remnant of D130394

[barannikov88]

Upload the correct diff

[efriedma]

LGTM

[barannikov88]

Rebase

[barannikov88]

Rebase

[barannikov88]

Rebase

[barannikov88]

Rebase

clang/lib/CodeGen/ABIInfo.h

namespace CodeGen {
 
   /// Target specific hooks for defining how a type should be passed or returned
   /// from functions with one of the Swift calling conventions.
   class SwiftABIInfo {
   protected:
     CodeGenTypes &CGT;
     bool SwiftErrorInRegister;
 
+    bool occupiesMoreThan(ArrayRef<llvm::Type *> scalarTypes,
+                          unsigned maxAllRegisters) const;
+
   public:
     SwiftABIInfo(CodeGen::CodeGenTypes &CGT, bool SwiftErrorInRegister)
         : CGT(CGT), SwiftErrorInRegister(SwiftErrorInRegister) {}
 
     virtual ~SwiftABIInfo();
 
     /// Returns true if an aggregate which expands to the given type sequence
     /// should be passed / returned indirectly.

clang/lib/CodeGen/TargetInfo.cpp

 ABIInfo::~ABIInfo() = default;
 
 SwiftABIInfo::~SwiftABIInfo() = default;
 
 /// Does the given lowering require more than the given number of
 /// registers when expanded?
 ///
 /// This is intended to be the basis of a reasonable basic implementation
-/// of should{Pass,Return}IndirectlyForSwift.
+/// of should{Pass,Return}Indirectly.
 ///
 /// For most targets, a limit of four total registers is reasonable; this
 /// limits the amount of code required in order to move around the value
 /// in case it wasn't produced immediately prior to the call by the caller
 /// (or wasn't produced in exactly the right registers) or isn't used
 /// immediately within the callee.  But some targets may need to further
 /// limit the register count due to an inability to support that many
 /// return registers.
-static bool occupiesMoreThan(CodeGenTypes &cgt,
-                             ArrayRef<llvm::Type*> scalarTypes,
-                             unsigned maxAllRegisters) {
+bool SwiftABIInfo::occupiesMoreThan(ArrayRef<llvm::Type *> scalarTypes,
+                                    unsigned maxAllRegisters) const {
   unsigned intCount = 0, fpCount = 0;
   for (llvm::Type *type : scalarTypes) {
     if (type->isPointerTy()) {
       intCount++;
     } else if (auto intTy = dyn_cast<llvm::IntegerType>(type)) {
-      auto ptrWidth = cgt.getTarget().getPointerWidth(LangAS::Default);
+      auto ptrWidth = CGT.getTarget().getPointerWidth(LangAS::Default);
       intCount += (intTy->getBitWidth() + ptrWidth - 1) / ptrWidth;
     } else {
       assert(type->isVectorTy() || type->isFloatingPointTy());
       fpCount++;
     }
   }
 
   return (intCount + fpCount > maxAllRegisters);
 }
 
 bool SwiftABIInfo::shouldPassIndirectly(ArrayRef<llvm::Type *> ComponentTys,
                                         bool AsReturnValue) const {
-  return occupiesMoreThan(CGT, ComponentTys, /*total=*/4);
+  return occupiesMoreThan(ComponentTys, /*total=*/4);
 }
 
 bool SwiftABIInfo::isLegalVectorType(CharUnits VectorSize, llvm::Type *EltTy,
                                      unsigned NumElts) const {
   // The default implementation of this assumes that the target guarantees
   // 128-bit SIMD support but nothing more.
   return (VectorSize.getQuantity() > 8 && VectorSize.getQuantity() <= 16);
 }
explicit X86_32SwiftABIInfo(CodeGenTypes &CGT)
       : SwiftABIInfo(CGT, /*SwiftErrorInRegister=*/false) {}
 
   bool shouldPassIndirectly(ArrayRef<llvm::Type *> ComponentTys,
                             bool AsReturnValue) const override {
     // LLVM's x86-32 lowering currently only assigns up to three
     // integer registers and three fp registers.  Oddly, it'll use up to
     // four vector registers for vectors, but those can overlap with the
     // scalar registers.
-    return occupiesMoreThan(CGT, ComponentTys, /*total=*/3);
+    return occupiesMoreThan(ComponentTys, /*total=*/3);
   }
 };
 
 class X86_32TargetCodeGenInfo : public TargetCodeGenInfo {
 public:
   X86_32TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, bool DarwinVectorABI,
                           bool RetSmallStructInRegABI, bool Win32StructABI,
                           unsigned NumRegisterParameters, bool SoftFloatABI)