wip -- emitFunctionProlog

ghstack-source-id: 71a88c0
Pull-Request: #2013

Author: lanza

clang/include/clang/CIR/MissingFeatures.h

@@ -476,6 +476,17 @@ struct MissingFeatures {
   static bool mustProgress() { return false; }
 
   static bool skipTempCopy() { return false; }
+
+  static bool addressSpaceInGlobalVar() { return false; }
+
+  static bool useARMGuardVarABI() { return false; }
+
+  // PtrAuth added a RawAddress type subclassing from Address.
+  static bool rawAddress() { return false; }
+
+  // LLVM has values that can be named (e.g. %x) and MLIR doens't, add this when
+  // we have a solution
+  static bool namedValues() { return false; }
 };
 
 } // namespace cir

clang/lib/CIR/CodeGen/CIRGenCall.cpp

@@ -19,8 +19,13 @@
 #include "TargetInfo.h"
 
 #include "clang/AST/Attr.h"
+#include "clang/AST/Attrs.inc"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/GlobalDecl.h"
+#include "clang/Basic/Specifiers.h"
+#include "clang/CIR/ABIArgInfo.h"
 #include "clang/CIR/Dialect/IR/CIRDialect.h"
 #include "clang/CIR/Dialect/IR/CIRTypes.h"
 #include "clang/CIR/FnInfoOpts.h"
@@ -943,6 +948,12 @@ static CanQual<FunctionProtoType> GetFormalType(const CXXMethodDecl *MD) {
       .getAs<FunctionProtoType>();
 }
 
+void CIRGenFunction::emitFunctionProlog(const CIRGenFunctionInfo &functionInfo,
+                                        cir::FuncOp fn,
+                                        const FunctionArgList &args) {
+  return;
+}
+
 /// TODO(cir): this should be shared with LLVM codegen
 static void addExtParameterInfosForCall(
     llvm::SmallVectorImpl<FunctionProtoType::ExtParameterInfo> &paramInfos,
@@ -1319,6 +1330,7 @@ CIRGenTypes::arrangeUnprototypedMustTailThunk(const CXXMethodDecl *md) {
   return arrangeCIRFunctionInfo(astContext.VoidTy, cir::FnInfoOpts::None,
                                 ArgTys, FTP->getExtInfo(), {}, RequiredArgs(1));
 }
+
 /// Figure out the rules for calling a function with the given formal type using
 /// the given arguments. The arguments are necessary because the function might
 /// be unprototyped, in which case it's target-dependent in crazy ways.
@@ -1483,3 +1495,35 @@ void CIRGenModule::getDefaultFunctionAttributes(
     // TODO(cir): addMergableDefaultFunctionAttributes(codeGenOpts, funcAttrs);
   }
 }
+
+void CIRGenFunction::createCoercedStore(mlir::Value src, Address dst,
+                                        llvm::TypeSize dstSize,
+                                        bool dstIsVolatile) {
+  if (!dstSize)
+    return;
+
+  mlir::Type srcTy = src.getType();
+  llvm::TypeSize srcSize = CGM.getDataLayout().getTypeAllocSize(srcTy);
+
+  // GEP into structs to try to make typesm match.
+  // FIXME: This isn't really that useful with opaque types, but it impacts a
+  // lot of regressiont ests.
+  if (srcTy != dst.getElementType()) {
+    llvm_unreachable("NYI");
+  }
+
+  if (srcSize.isScalable() || srcSize <= dstSize) {
+    if (isa<cir::IntType>(srcTy) &&
+        isa<cir::PointerType>(dst.getElementType()) &&
+        srcSize == CGM.getDataLayout().getTypeAllocSize(dst.getElementType())) {
+      llvm_unreachable("NYI");
+    } else {
+      getBuilder().createStore(src.getLoc(), src, dst.withElementType(getBuilder(), srcTy),
+                               dstIsVolatile);
+    }
+  } else if (isa<cir::IntType>(srcTy)) {
+    llvm_unreachable("NYI");
+  } else {
+    llvm_unreachable("NYI");
+  }
+}

clang/lib/CIR/CodeGen/CIRGenDecl.cpp

@@ -1289,3 +1289,84 @@ void CIRGenFunction::pushDestroyAndDeferDeactivation(
   pushDestroy(cleanupKind, addr, type, destroyer, useEHCleanupForArray);
   DeferredDeactivationCleanupStack.push_back({EHStack.stable_begin(), flag});
 }
+
+/// Emit an alloca (or GlobalValue depending on target)
+/// for the specified parameter and set up LocalDeclMap.
+void CIRGenFunction::emitParmDecl(const VarDecl &varDecl, ParamValue arg,
+                                   unsigned argNo) {
+  bool noDebugInfo = false;
+  // FIXME: Why isn't ImplicitParamDecl a ParmVarDecl?
+  assert((isa<ParmVarDecl>(varDecl) || isa<ImplicitParamDecl>(varDecl)) &&
+         "Invalid argument to buildParmDecl");
+
+  // Set the name of the parameter's initial value to make IR easier to read.
+  // Don't modify the names of globals.
+  if (cir::MissingFeatures::namedValues())
+    llvm_unreachable("NYI");
+
+  QualType ty = varDecl.getType();
+
+  // Use better CIR generation for certain implicit parameters.
+  if ([[maybe_unused]] auto const *ipd =
+          dyn_cast<ImplicitParamDecl>(&varDecl)) {
+    llvm_unreachable("NYI");
+  }
+
+  Address declPtr = Address::invalid();
+  assert(!cir::MissingFeatures::rawAddress());
+  Address allocaPtr = Address::invalid();
+  bool doStore = false;
+  bool isScalar = hasScalarEvaluationKind(ty);
+  bool useIndirectDebugAddress = false;
+
+  // If we already have a pointer to the argument, reuse the input pointer.
+  if (arg.isIndirect()) {
+    llvm_unreachable("NYI");
+  } else {
+    // Check if the parameter address is controlled by OpenMP runtime.
+    Address openMPLocalAddr =
+        getLangOpts().OpenMP
+            ? CGM.getOpenMPRuntime().getAddressOfLocalVariable(*this, &varDecl)
+            : Address::invalid();
+    if (getLangOpts().OpenMP && openMPLocalAddr.isValid()) {
+      llvm_unreachable("NYI");
+    } else {
+      // Otherwise, create a temporary to hold the value.
+      declPtr = CreateMemTemp(ty, getContext().getDeclAlign(&varDecl),
+                              getLoc(varDecl.getLocation()),
+                              varDecl.getName() + ".addr", &allocaPtr);
+    }
+    doStore = true;
+  }
+
+  mlir::Value argVal = (doStore ? arg.getDirectValue() : nullptr);
+
+  LValue lv = makeAddrLValue(declPtr, ty);
+  if (isScalar) {
+    Qualifiers qs = ty.getQualifiers();
+    if ([[maybe_unused]] Qualifiers::ObjCLifetime lt = qs.getObjCLifetime()) {
+      llvm_unreachable("NYI");
+    }
+  }
+
+  // Store the initial value into the alloca.
+  if (doStore)
+    emitStoreOfScalar(argVal, lv, /*isInit=*/true);
+
+  setAddrOfLocalVar(&varDecl, declPtr);
+
+  // Emit debug info for param declarations in non-thunk functions.
+  if (CIRGenDebugInfo *di = getDebugInfo()) {
+    llvm_unreachable("NYI");
+  }
+
+  if (varDecl.hasAttr<AnnotateAttr>())
+    llvm_unreachable("NYI");
+
+  // We can only check return value nullability if all arguments to the function
+  // staisfy their nullability preconditions. This makes it necessary to emit
+  // null checks for args in the function body itself.
+  if (requiresReturnValueNullabilityCheck()) {
+    llvm_unreachable("NYI");
+  }
+}

clang/lib/CIR/CodeGen/CIRGenFunction.cpp

@@ -1331,7 +1331,7 @@ void CIRGenFunction::StartFunction(GlobalDecl gd, QualType retTy,
     llvm_unreachable("NYI");
   }
 
-  // TODO: emitFunctionProlog
+  emitFunctionProlog(*CurFnInfo, cast<cir::FuncOp>(CurFn), args);
 
   {
     // Set the insertion point in the builder to the beginning of the