Move SwiftABIInfo to new CodeGen/Target directory.

[• scross99]

Summary

This is the first of a series of changes that moves the ABI target-specific logic into the CodeGen/Target directory, in particular moving logic out of CodeGen/TargetInfo.cpp.

[lygstate]

I suggest add a ABI subfolder in Target
for example:
#include "Target/ABI/SwiftABIInfo.h"
and
Target/ABI/SwiftABIInfo.cpp

lib/CodeGen/ABIInfo.h

 
 namespace CodeGen {
   class ABIArgInfo;
   class Address;
   class CGCXXABI;
   class CGFunctionInfo;
   class CodeGenFunction;
   class CodeGenTypes;
-  class SwiftABIInfo;
-
-namespace swiftcall {
-  class SwiftAggLowering;
-}
 
   // FIXME: All of this stuff should be part of the target interface
   // somehow. It is currently here because it is not clear how to factor
   // the targets to support this, since the Targets currently live in a
   // layer below types n'stuff.
 
 
   /// ABIInfo - Target specific hooks for defining how a type should be
getNaturalAlignIndirect(QualType Ty, bool ByRef = true,
                             llvm::Type *Padding = nullptr) const;
 
     CodeGen::ABIArgInfo
     getNaturalAlignIndirectInReg(QualType Ty, bool Realign = false) const;
 
 
   };
 
-  /// A refining implementation of ABIInfo for targets that support swiftcall.
-  ///
-  /// If we find ourselves wanting multiple such refinements, they'll probably
-  /// be independent refinements, and we should probably find another way
-  /// to do it than simple inheritance.
-  class SwiftABIInfo : public ABIInfo {
-  public:
-    SwiftABIInfo(CodeGen::CodeGenTypes &cgt) : ABIInfo(cgt) {}
-
-    bool supportsSwift() const final override { return true; }
-
-    virtual bool shouldPassIndirectlyForSwift(CharUnits totalSize,
-                                              ArrayRef<llvm::Type*> types,
-                                              bool asReturnValue) const = 0;
-
-    virtual bool isLegalVectorTypeForSwift(CharUnits totalSize,
-                                           llvm::Type *eltTy,
-                                           unsigned elts) const;
-
-    virtual bool isSwiftErrorInRegister() const = 0;
-
-    static bool classof(const ABIInfo *info) {
-      return info->supportsSwift();
-    }
-  };
-
 }  // end namespace CodeGen
 }  // end namespace clang
 
 #endif

lib/CodeGen/CMakeLists.txt

add_clang_library(clangCodeGen
   ItaniumCXXABI.cpp
   MacroPPCallbacks.cpp
   MicrosoftCXXABI.cpp
   ModuleBuilder.cpp
   ObjectFilePCHContainerOperations.cpp
   SanitizerMetadata.cpp
   SwiftCallingConv.cpp
   TargetInfo.cpp
+  Target/SwiftABIInfo.cpp
   VarBypassDetector.cpp
 
   DEPENDS
   ${codegen_deps}
 
   LINK_LIBS
   clangAnalysis
   clangAST
   clangAnalysis
   clangBasic
   clangFrontend
   clangLex
   )

lib/CodeGen/SwiftCallingConv.cpp

 //===--- SwiftCallingConv.cpp - Lowering for the Swift calling convention -===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Implementation of the abstract lowering for the Swift calling convention.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/CodeGen/SwiftCallingConv.h"
 #include "clang/Basic/TargetInfo.h"
 #include "CodeGenModule.h"
+#include "Target/SwiftABIInfo.h"
 #include "TargetInfo.h"
 
 using namespace clang;
 using namespace CodeGen;
 using namespace swiftcall;
 
 static const SwiftABIInfo &getSwiftABIInfo(CodeGenModule &CGM) {
   return cast<SwiftABIInfo>(CGM.getTargetCodeGenInfo().getABIInfo());

lib/CodeGen/Target/SwiftABIInfo.h

+//===----- SwiftABIInfo.h - Implements ABIInfo for Swift. -------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_CODEGEN_TARGET_SWIFTABIINFO_H
+#define LLVM_CLANG_LIB_CODEGEN_TARGET_SWIFTABIINFO_H
+
+#include "../ABIInfo.h"
+#include "clang/AST/CharUnits.h"
+
+namespace llvm {
+  class Type;
+}
+
+namespace clang {
+
+namespace CodeGen {
+  class CodeGenTypes;
+  class SwiftABIInfo;
+
+namespace swiftcall {
+  class SwiftAggLowering;
+}
+
+  /// A refining implementation of ABIInfo for targets that support swiftcall.
+  ///
+  /// If we find ourselves wanting multiple such refinements, they'll probably
+  /// be independent refinements, and we should probably find another way
+  /// to do it than simple inheritance.
+  class SwiftABIInfo : public ABIInfo {
+  public:
+    SwiftABIInfo(CodeGen::CodeGenTypes &cgt) : ABIInfo(cgt) {}
+
+    bool supportsSwift() const final override { return true; }
+
+    virtual bool shouldPassIndirectlyForSwift(CharUnits totalSize,
+                                              ArrayRef<llvm::Type*> types,
+                                              bool asReturnValue) const = 0;
+
+    virtual bool isLegalVectorTypeForSwift(CharUnits totalSize,
+                                           llvm::Type *eltTy,
+                                           unsigned elts) const;
+
+    virtual bool isSwiftErrorInRegister() const = 0;
+
+    static bool classof(const ABIInfo *info) {
+      return info->supportsSwift();
+    }
+  };
+
+}  // end namespace CodeGen
+}  // end namespace clang
+
+#endif

lib/CodeGen/Target/SwiftABIInfo.cpp

+//===----- SwiftABIInfo.cpp - Implement ABIInfo for Swift. ------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "SwiftABIInfo.h"
+
+using namespace clang;
+using namespace CodeGen;
+
+bool SwiftABIInfo::isLegalVectorTypeForSwift(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);
+}

lib/CodeGen/TargetInfo.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "TargetInfo.h"
 #include "ABIInfo.h"
 #include "CGCXXABI.h"
 #include "CGValue.h"
 #include "CodeGenFunction.h"
+#include "Target/SwiftABIInfo.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/CodeGen/CGFunctionInfo.h"
 #include "clang/CodeGen/SwiftCallingConv.h"
 #include "clang/Frontend/CodeGenOptions.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Type.h"
if (type->isPointerTy()) {
       assert(type->isVectorTy() || type->isFloatingPointTy());
       fpCount++;
     }
   }
 
   return (intCount + fpCount > maxAllRegisters);
 }
 
-bool SwiftABIInfo::isLegalVectorTypeForSwift(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);
-}
-
 static CGCXXABI::RecordArgABI getRecordArgABI(const RecordType *RT,
                                               CGCXXABI &CXXABI) {
   const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());
   if (!RD)
     return CGCXXABI::RAA_Default;
   return CXXABI.getRecordArgABI(RD);
 }