[CIR][ABI] Replay TargetLowering library reverted commits (#697)

Essentially re-applies #668 and #678, but also includes #687 which
patched build introduced by the other two PRs.

Closes #691

Author: sitio-couto

clang/include/clang/CIR/Dialect/IR/CIRDataLayout.h

@@ -15,6 +15,7 @@
 #include "mlir/Dialect/DLTI/DLTI.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "clang/CIR/Dialect/IR/CIRTypes.h"
+#include "llvm/ADT/StringRef.h"
 
 namespace cir {
 
@@ -24,7 +25,20 @@ class CIRDataLayout {
 public:
   mlir::DataLayout layout;
 
+  /// Constructs a DataLayout from a specification string. See reset().
+  explicit CIRDataLayout(llvm::StringRef dataLayout, mlir::ModuleOp module)
+      : layout(module) {
+    reset(dataLayout);
+  }
+
+  /// Parse a data layout string (with fallback to default values).
+  void reset(llvm::StringRef dataLayout);
+
+  // Free all internal data structures.
+  void clear();
+
   CIRDataLayout(mlir::ModuleOp modOp);
+
   bool isBigEndian() const { return bigEndian; }
 
   // `useABI` is `true` if not using prefered alignment.

clang/include/clang/CIR/FnInfoOpts.h

@@ -0,0 +1,37 @@
+#ifndef CIR_FNINFOOPTS_H
+#define CIR_FNINFOOPTS_H
+
+#include "llvm/ADT/STLForwardCompat.h"
+
+namespace cir {
+
+enum class FnInfoOpts {
+  None = 0,
+  IsInstanceMethod = 1 << 0,
+  IsChainCall = 1 << 1,
+  IsDelegateCall = 1 << 2,
+};
+
+inline FnInfoOpts operator|(FnInfoOpts A, FnInfoOpts B) {
+  return static_cast<FnInfoOpts>(llvm::to_underlying(A) |
+                                 llvm::to_underlying(B));
+}
+
+inline FnInfoOpts operator&(FnInfoOpts A, FnInfoOpts B) {
+  return static_cast<FnInfoOpts>(llvm::to_underlying(A) &
+                                 llvm::to_underlying(B));
+}
+
+inline FnInfoOpts operator|=(FnInfoOpts A, FnInfoOpts B) {
+  A = A | B;
+  return A;
+}
+
+inline FnInfoOpts operator&=(FnInfoOpts A, FnInfoOpts B) {
+  A = A & B;
+  return A;
+}
+
+} // namespace cir
+
+#endif // CIR_FNINFOOPTS_H

clang/include/clang/CIR/MissingFeatures.h

@@ -156,7 +156,6 @@ struct MissingFeatures {
   static bool zeroInitializer() { return false; }
   static bool targetCodeGenInfoIsProtoCallVariadic() { return false; }
   static bool targetCodeGenInfoGetNullPointer() { return false; }
-  static bool chainCalls() { return false; }
   static bool operandBundles() { return false; }
   static bool exceptions() { return false; }
   static bool metaDataNode() { return false; }
@@ -190,24 +189,61 @@ struct MissingFeatures {
 
   //===--- ABI lowering --===//
 
+  //-- Missing AST queries
+
+  static bool recordDeclCanPassInRegisters() { return false; }
+  static bool funcDeclIsCXXConstructorDecl() { return false; }
+  static bool funcDeclIsCXXDestructorDecl() { return false; }
+  static bool funcDeclIsCXXMethodDecl() { return false; }
+  static bool funcDeclIsInlineBuiltinDeclaration() { return false; }
+  static bool funcDeclIsReplaceableGlobalAllocationFunction() { return false; }
+  static bool qualTypeIsReferenceType() { return false; }
+
+  //-- Missing types
+
+  static bool vectorType() { return false; }
+
+  //-- Missing LLVM attributes
+
+  static bool noReturn() { return false; }
+  static bool csmeCall() { return false; }
+
+  //-- Other missing features
+
+  // Calls with a static chain pointer argument may be optimized (p.e. freeing
+  // up argument registers), but we do not yet track such cases.
+  static bool chainCall() { return false; }
+
+  // ABI-lowering has special handling for regcall calling convention (tries to
+  // pass every argument in regs). We don't support it just yet.
+  static bool regCall() { return false; }
+
+  // Some ABIs (e.g. x86) require special handling for returning large structs
+  // by value. The sret argument parameter aids in this, but it is current NYI.
+  static bool sretArgs() { return false; }
+
+  // Inalloca parameter attributes are mostly used for Windows x86_32 ABI. We
+  // do not yet support this yet.
+  static bool inallocaArgs() { return false; }
+
   // Parameters may have additional attributes (e.g. [[noescape]]) that affect
   // the compiler. This is not yet supported in CIR.
-  static bool extParamInfo() { return true; }
+  static bool extParamInfo() { return false; }
 
   // LangOpts may affect lowering, but we do not carry this information into CIR
   // just yet. Right now, it only instantiates the default lang options.
-  static bool langOpts() { return true; }
+  static bool langOpts() { return false; }
 
   // Several type qualifiers are not yet supported in CIR, but important when
   // evaluating ABI-specific lowering.
-  static bool qualifiedTypes() { return true; }
+  static bool qualifiedTypes() { return false; }
 
   // We're ignoring several details regarding ABI-halding for Swift.
-  static bool swift() { return true; }
+  static bool swift() { return false; }
 
   // Despite carrying some information about variadics, we are currently
   // ignoring this to focus only on the code necessary to lower non-variadics.
-  static bool variadicFunctions() { return true; }
+  static bool variadicFunctions() { return false; }
 };
 
 } // namespace cir

clang/include/clang/CIR/Target/x86.h

@@ -0,0 +1,32 @@
+//==-- x86.h - Definitions common to all x86 ABI variants ------------------==//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Definitions common to any X86 ABI implementation.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef CIR_X86_H
+#define CIR_X86_H
+
+namespace cir {
+
+// Possible argument classifications according to the x86 ABI documentation.
+enum X86ArgClass {
+  Integer = 0,
+  SSE,
+  SSEUp,
+  X87,
+  X87Up,
+  ComplexX87,
+  NoClass,
+  Memory
+};
+
+} // namespace cir
+
+#endif // CIR_X86_H

clang/lib/CIR/CodeGen/CIRGenCall.cpp

@@ -23,6 +23,7 @@
 #include "clang/AST/GlobalDecl.h"
 #include "clang/CIR/Dialect/IR/CIRDialect.h"
 #include "clang/CIR/Dialect/IR/CIRTypes.h"
+#include "clang/CIR/FnInfoOpts.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <cassert>
 

clang/lib/CIR/CodeGen/CIRGenCall.h

@@ -290,13 +290,6 @@ class ReturnValueSlot {
   Address getAddress() const { return Addr; }
 };
 
-enum class FnInfoOpts {
-  None = 0,
-  IsInstanceMethod = 1 << 0,
-  IsChainCall = 1 << 1,
-  IsDelegateCall = 1 << 2,
-};
-
 } // namespace cir
 
 #endif

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -1439,7 +1439,7 @@ RValue CIRGenFunction::buildCall(clang::QualType CalleeType,
   // Chain calls use the same code path to add the inviisble chain parameter to
   // the function type.
   if (isa<FunctionNoProtoType>(FnType) || Chain) {
-    assert(!MissingFeatures::chainCalls());
+    assert(!MissingFeatures::chainCall());
     assert(!MissingFeatures::addressSpace());
     auto CalleeTy = getTypes().GetFunctionType(FnInfo);
     // get non-variadic function type

clang/lib/CIR/CodeGen/CIRGenTypes.cpp

@@ -16,6 +16,7 @@
 #include "clang/AST/GlobalDecl.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/CIR/Dialect/IR/CIRTypes.h"
+#include "clang/CIR/FnInfoOpts.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"

clang/lib/CIR/CodeGen/CIRGenTypes.h

@@ -22,6 +22,7 @@
 #include "clang/AST/Type.h"
 #include "clang/Basic/ABI.h"
 #include "clang/CIR/Dialect/IR/CIRTypes.h"
+#include "clang/CIR/FnInfoOpts.h"
 
 #include "llvm/ADT/SmallPtrSet.h"
 

clang/lib/CIR/CodeGen/TargetInfo.cpp

@@ -6,6 +6,7 @@
 #include "CallingConv.h"
 
 #include "clang/Basic/TargetInfo.h"
+#include "clang/CIR/Target/x86.h"
 
 using namespace cir;
 using namespace clang;
@@ -79,16 +80,7 @@ namespace {
 enum class X86AVXABILevel { None, AVX, AVX512 };
 
 class X86_64ABIInfo : public ABIInfo {
-  enum Class {
-    Integer = 0,
-    SSE,
-    SSEUp,
-    X87,
-    X87Up,
-    ComplexX87,
-    NoClass,
-    Memory
-  };
+  using Class = X86ArgClass;
 
   // X86AVXABILevel AVXLevel;
   // Some ABIs (e.g. X32 ABI and Native Client OS) use 32 bit pointers on 64-bit

clang/lib/CIR/Dialect/IR/CIRDataLayout.cpp

@@ -1,19 +1,8 @@
-//===- CIRDialect.cpp - MLIR CIR ops implementation -----------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the CIR DataLayout class and its functions.
-//
-//===----------------------------------------------------------------------===//a
-//
-
 #include "clang/CIR/Dialect/IR/CIRDataLayout.h"
+#include "llvm/ADT/StringRef.h"
 
 namespace cir {
+
 CIRDataLayout::CIRDataLayout(mlir::ModuleOp modOp) : layout{modOp} {
   auto dlSpec = modOp->getAttr(mlir::DLTIDialect::kDataLayoutAttrName)
                     .dyn_cast<mlir::DataLayoutSpecAttr>();
@@ -40,4 +29,8 @@ CIRDataLayout::CIRDataLayout(mlir::ModuleOp modOp) : layout{modOp} {
   }
 }
 
+void CIRDataLayout::reset(llvm::StringRef Desc) { clear(); }
+
+void CIRDataLayout::clear() {}
+
 } // namespace cir

clang/lib/CIR/Dialect/IR/CMakeLists.txt

@@ -17,6 +17,7 @@ add_clang_library(MLIRCIR
   LINK_LIBS PUBLIC
   MLIRIR
   MLIRCIRInterfaces
+  MLIRDLTIDialect
   MLIRDataLayoutInterfaces
   MLIRFuncDialect
   MLIRLoopLikeInterface

clang/lib/CIR/Dialect/Transforms/CallConvLowering.cpp

@@ -45,7 +45,7 @@ LowerModule createLowerModule(FuncOp op, PatternRewriter &rewriter) {
   // FIXME(cir): This just uses the default language options. We need to account
   // for custom options.
   // Create context.
-  assert(::cir::MissingFeatures::langOpts());
+  assert(!::cir::MissingFeatures::langOpts());
   clang::LangOptions langOpts;
   auto context = CIRLowerContext(module.getContext(), langOpts);
   context.initBuiltinTypes(*targetInfo);
@@ -64,11 +64,29 @@ struct CallConvLoweringPattern : public OpRewritePattern<FuncOp> {
 
   LogicalResult matchAndRewrite(FuncOp op,
                                 PatternRewriter &rewriter) const final {
+    const auto module = op->getParentOfType<mlir::ModuleOp>();
+
     if (!op.getAst())
       return op.emitError("function has no AST information");
 
     LowerModule lowerModule = createLowerModule(op, rewriter);
 
+    // Rewrite function calls before definitions. This should be done before
+    // lowering the definition.
+    auto calls = op.getSymbolUses(module);
+    if (calls.has_value()) {
+      for (auto call : calls.value()) {
+        auto callOp = cast<CallOp>(call.getUser());
+        if (lowerModule.rewriteFunctionCall(callOp, op).failed())
+          return failure();
+      }
+    }
+
+    // TODO(cir): Instead of re-emmiting every load and store, bitcast arguments
+    // and return values to their ABI-specific counterparts when possible.
+    if (lowerModule.rewriteFunctionDefinition(op).failed())
+      return failure();
+
     return success();
   }
 };

clang/lib/CIR/Dialect/Transforms/TargetLowering/ABIInfo.cpp

@@ -12,12 +12,16 @@
 //===----------------------------------------------------------------------===//
 
 #include "ABIInfo.h"
+#include "CIRCXXABI.h"
+#include "LowerTypes.h"
 
 namespace mlir {
 namespace cir {
 
 // Pin the vtable to this file.
 ABIInfo::~ABIInfo() = default;
 
+CIRCXXABI &ABIInfo::getCXXABI() const { return LT.getCXXABI(); }
+
 } // namespace cir
 } // namespace mlir

clang/lib/CIR/Dialect/Transforms/TargetLowering/ABIInfo.h

@@ -14,6 +14,8 @@
 #ifndef LLVM_CLANG_LIB_CIR_DIALECT_TRANSFORMS_TARGETLOWERING_ABIINFO_H
 #define LLVM_CLANG_LIB_CIR_DIALECT_TRANSFORMS_TARGETLOWERING_ABIINFO_H
 
+#include "CIRCXXABI.h"
+#include "LowerFunctionInfo.h"
 #include "llvm/IR/CallingConv.h"
 
 namespace mlir {
@@ -32,6 +34,10 @@ class ABIInfo {
 public:
   ABIInfo(LowerTypes &LT) : LT(LT), RuntimeCC(llvm::CallingConv::C) {}
   virtual ~ABIInfo();
+
+  CIRCXXABI &getCXXABI() const;
+
+  virtual void computeInfo(LowerFunctionInfo &FI) const = 0;
 };
 
 } // namespace cir

clang/lib/CIR/Dialect/Transforms/TargetLowering/ABIInfoImpl.cpp

@@ -10,3 +10,25 @@
 // adapted to operate on the CIR dialect, however.
 //
 //===----------------------------------------------------------------------===//
+
+#include "ABIInfo.h"
+#include "CIRCXXABI.h"
+#include "LowerFunctionInfo.h"
+#include "llvm/Support/ErrorHandling.h"
+
+namespace mlir {
+namespace cir {
+
+bool classifyReturnType(const CIRCXXABI &CXXABI, LowerFunctionInfo &FI,
+                        const ABIInfo &Info) {
+  Type Ty = FI.getReturnType();
+
+  if (const auto RT = Ty.dyn_cast<StructType>()) {
+    llvm_unreachable("NYI");
+  }
+
+  return CXXABI.classifyReturnType(FI);
+}
+
+} // namespace cir
+} // namespace mlir