[CIR][ABI] Add unsigned int CC lowering for x86_64

clang/include/clang/CIR/ABIArgInfo.h

@@ -18,6 +18,7 @@
 
 #include "mlir/IR/Types.h"
 #include "clang/AST/Type.h"
+#include "clang/CIR/Dialect/IR/CIRTypes.h"
 #include <cstdint>
 
 namespace cir {
@@ -99,6 +100,7 @@ class ABIArgInfo {
     unsigned AllocaFieldIndex;     // isInAlloca()
   };
   Kind TheKind;
+  bool InReg : 1;          // isDirect() || isExtend() || isIndirect()
   bool CanBeFlattened : 1; // isDirect()
   bool SignExt : 1;        // isExtend()
 
@@ -115,7 +117,7 @@ class ABIArgInfo {
 public:
   ABIArgInfo(Kind K = Direct)
       : TypeData(nullptr), PaddingType(nullptr), DirectAttr{0, 0}, TheKind(K),
-        CanBeFlattened(false) {}
+        InReg(false), CanBeFlattened(false), SignExt(false) {}
 
   static ABIArgInfo getDirect(mlir::Type T = nullptr, unsigned Offset = 0,
                               mlir::Type Padding = nullptr,
@@ -139,6 +141,16 @@ class ABIArgInfo {
     AI.setSignExt(true);
     return AI;
   }
+  static ABIArgInfo getSignExtend(mlir::Type Ty, mlir::Type T = nullptr) {
+    // NOTE(cir): Enumerations are IntTypes in CIR.
+    auto AI = ABIArgInfo(Extend);
+    AI.setCoerceToType(T);
+    AI.setPaddingType(nullptr);
+    AI.setDirectOffset(0);
+    AI.setDirectAlign(0);
+    AI.setSignExt(true);
+    return AI;
+  }
 
   static ABIArgInfo getZeroExtend(clang::QualType Ty, mlir::Type T = nullptr) {
     assert(Ty->isIntegralOrEnumerationType() && "Unexpected QualType");
@@ -150,6 +162,18 @@ class ABIArgInfo {
     AI.setSignExt(false);
     return AI;
   }
+  static ABIArgInfo getZeroExtend(mlir::Type Ty, mlir::Type T = nullptr) {
+    // NOTE(cir): Enumerations are IntTypes in CIR.
+    assert(mlir::isa<mlir::cir::IntType>(Ty) ||
+           mlir::isa<mlir::cir::BoolType>(Ty));
+    auto AI = ABIArgInfo(Extend);
+    AI.setCoerceToType(T);
+    AI.setPaddingType(nullptr);
+    AI.setDirectOffset(0);
+    AI.setDirectAlign(0);
+    AI.setSignExt(false);
+    return AI;
+  }
 
   // ABIArgInfo will record the argument as being extended based on the sign of
   // it's type.
@@ -159,6 +183,14 @@ class ABIArgInfo {
       return getSignExtend(Ty, T);
     return getZeroExtend(Ty, T);
   }
+  static ABIArgInfo getExtend(mlir::Type Ty, mlir::Type T = nullptr) {
+    // NOTE(cir): The original can apply this method on both integers and
+    // enumerations, but in CIR, these two types are one and the same.
+    if (mlir::isa<mlir::cir::IntType>(Ty) &&
+        mlir::cast<mlir::cir::IntType>(Ty).isSigned())
+      return getSignExtend(mlir::cast<mlir::cir::IntType>(Ty), T);
+    return getZeroExtend(Ty, T);
+  }
 
   static ABIArgInfo getIgnore() { return ABIArgInfo(Ignore); }
 
@@ -171,6 +203,24 @@ class ABIArgInfo {
   bool isExpand() const { return TheKind == Expand; }
   bool isCoerceAndExpand() const { return TheKind == CoerceAndExpand; }
 
+  bool isSignExt() const {
+    assert(isExtend() && "Invalid kind!");
+    return SignExt;
+  }
+  void setSignExt(bool SExt) {
+    assert(isExtend() && "Invalid kind!");
+    SignExt = SExt;
+  }
+
+  bool getInReg() const {
+    assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!");
+    return InReg;
+  }
+  void setInReg(bool IR) {
+    assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!");
+    InReg = IR;
+  }
+
   bool canHaveCoerceToType() const {
     return isDirect() || isExtend() || isCoerceAndExpand();
   }
@@ -191,11 +241,6 @@ class ABIArgInfo {
     DirectAttr.Align = Align;
   }
 
-  void setSignExt(bool SExt) {
-    assert(isExtend() && "Invalid kind!");
-    SignExt = SExt;
-  }
-
   void setCanBeFlattened(bool Flatten) {
     assert(isDirect() && "Invalid kind!");
     CanBeFlattened = Flatten;

clang/include/clang/CIR/Dialect/IR/CIRDialect.td

@@ -28,6 +28,11 @@ def CIR_Dialect : Dialect {
   let useDefaultTypePrinterParser = 0;
 
   let extraClassDeclaration = [{
+
+    // Names of CIR parameter attributes.
+    static StringRef getSExtAttrName() { return "cir.signext"; }
+    static StringRef getZExtAttrName() { return "cir.zeroext"; }
+
     void registerAttributes();
     void registerTypes();
 

clang/include/clang/CIR/MissingFeatures.h

@@ -201,18 +201,32 @@ struct MissingFeatures {
   static bool funcDeclIsInlineBuiltinDeclaration() { return false; }
   static bool funcDeclIsReplaceableGlobalAllocationFunction() { return false; }
   static bool qualTypeIsReferenceType() { return false; }
+  static bool typeGetAsEnumType() { return false; }
+  static bool typeGetAsBuiltinType() { return false; }
+  static bool varDeclIsKNRPromoted() { return false; }
 
   //-- Missing types
 
+  static bool fixedWidthIntegers() { return false; }
   static bool vectorType() { return false; }
 
   //-- Missing LLVM attributes
 
   static bool noReturn() { return false; }
   static bool csmeCall() { return false; }
+  static bool undef() { return false; }
+  static bool noFPClass() { return false; }
 
   //-- Other missing features
 
+  // Empty values might be passed as arguments to serve as padding, ensuring
+  // alignment and compliance (e.g. MIPS). We do not yet support this.
+  static bool argumentPadding() { return false; }
+
+  // Clang has evaluation kinds which determines how code is emitted for certain
+  // group of type classes. We don't have a way to identify type classes.
+  static bool evaluationKind() { return false; }
+
   // 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; }
@@ -247,6 +261,10 @@ struct MissingFeatures {
   // 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 false; }
+
+  // If a store op is guaranteed to execute before the retun value load op, we
+  // can optimize away the store and load ops. Seems like an early optimization.
+  static bool returnValueDominatingStoreOptmiization() { return false; }
 };
 
 } // namespace cir

clang/include/clang/CIR/TypeEvaluationKind.h

@@ -0,0 +1,12 @@
+#ifndef CLANG_CIR_TYPEEVALUATIONKIND_H
+#define CLANG_CIR_TYPEEVALUATIONKIND_H
+
+namespace cir {
+
+// FIXME: for now we are reusing this from lib/Clang/CIRGenFunction.h, which
+// isn't available in the include dir. Same for getEvaluationKind below.
+enum TypeEvaluationKind { TEK_Scalar, TEK_Complex, TEK_Aggregate };
+
+} // namespace cir
+
+#endif // CLANG_CIR_TYPEEVALUATIONKIND_H

clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp

@@ -267,7 +267,6 @@ static mlir::Value MakeAtomicCmpXchgValue(CIRGenFunction &cgf,
 
   auto intType = builder.getSIntNTy(cgf.getContext().getTypeSize(typ));
   auto cmpVal = cgf.buildScalarExpr(expr->getArg(1));
-  auto valueType = cmpVal.getType();
   cmpVal = buildToInt(cgf, cmpVal, typ, intType);
   auto newVal =
       buildToInt(cgf, cgf.buildScalarExpr(expr->getArg(2)), typ, intType);

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -27,6 +27,7 @@
 #include "clang/AST/Type.h"
 #include "clang/Basic/ABI.h"
 #include "clang/Basic/TargetInfo.h"
+#include "clang/CIR/TypeEvaluationKind.h"
 
 #include "mlir/IR/TypeRange.h"
 #include "mlir/IR/Value.h"
@@ -49,9 +50,6 @@ class AggExprEmitter;
 
 namespace cir {
 
-// FIXME: for now we are reusing this from lib/Clang/CIRGenFunction.h, which
-// isn't available in the include dir. Same for getEvaluationKind below.
-enum TypeEvaluationKind { TEK_Scalar, TEK_Complex, TEK_Aggregate };
 struct CGCoroData;
 
 class CIRGenFunction : public CIRGenTypeCache {

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

@@ -46,7 +46,7 @@ LowerModule createLowerModule(FuncOp op, PatternRewriter &rewriter) {
   // Create context.
   assert(!::cir::MissingFeatures::langOpts());
   clang::LangOptions langOpts;
-  auto context = CIRLowerContext(module.getContext(), langOpts);
+  auto context = CIRLowerContext(module, langOpts);
   context.initBuiltinTypes(*targetInfo);
 
   return LowerModule(context, module, dataLayoutStr, *targetInfo, rewriter);

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

@@ -13,6 +13,7 @@
 
 #include "ABIInfo.h"
 #include "CIRCXXABI.h"
+#include "CIRLowerContext.h"
 #include "LowerTypes.h"
 
 namespace mlir {
@@ -23,5 +24,16 @@ ABIInfo::~ABIInfo() = default;
 
 CIRCXXABI &ABIInfo::getCXXABI() const { return LT.getCXXABI(); }
 
+CIRLowerContext &ABIInfo::getContext() const { return LT.getContext(); }
+
+bool ABIInfo::isPromotableIntegerTypeForABI(Type Ty) const {
+  if (getContext().isPromotableIntegerType(Ty))
+    return true;
+
+  assert(!::cir::MissingFeatures::fixedWidthIntegers());
+
+  return false;
+}
+
 } // namespace cir
 } // namespace mlir

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

@@ -15,6 +15,7 @@
 #define LLVM_CLANG_LIB_CIR_DIALECT_TRANSFORMS_TARGETLOWERING_ABIINFO_H
 
 #include "CIRCXXABI.h"
+#include "CIRLowerContext.h"
 #include "LowerFunctionInfo.h"
 #include "llvm/IR/CallingConv.h"
 
@@ -37,7 +38,13 @@ class ABIInfo {
 
   CIRCXXABI &getCXXABI() const;
 
+  CIRLowerContext &getContext() const;
+
   virtual void computeInfo(LowerFunctionInfo &FI) const = 0;
+
+  // Implement the Type::IsPromotableIntegerType for ABI specific needs. The
+  // only difference is that this considers bit-precise integer types as well.
+  bool isPromotableIntegerTypeForABI(Type Ty) const;
 };
 
 } // namespace cir

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

@@ -30,5 +30,13 @@ bool classifyReturnType(const CIRCXXABI &CXXABI, LowerFunctionInfo &FI,
   return CXXABI.classifyReturnType(FI);
 }
 
+Type useFirstFieldIfTransparentUnion(Type Ty) {
+  if (auto RT = dyn_cast<StructType>(Ty)) {
+    if (RT.isUnion())
+      llvm_unreachable("NYI");
+  }
+  return Ty;
+}
+
 } // namespace cir
 } // namespace mlir

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

@@ -24,6 +24,10 @@ namespace cir {
 bool classifyReturnType(const CIRCXXABI &CXXABI, LowerFunctionInfo &FI,
                         const ABIInfo &Info);
 
+/// Pass transparent unions as if they were the type of the first element. Sema
+/// should ensure that all elements of the union have the same "machine type".
+Type useFirstFieldIfTransparentUnion(Type Ty);
+
 } // namespace cir
 } // namespace mlir