================
@@ -488,6 +364,143 @@ class CIRGenFunction : public CIRGenTypeCache {
LexicalScope *curLexScope = nullptr;
+ /// ----------------------
+ /// CIR emit functions
+ /// ----------------------
+private:
+ void emitAndUpdateRetAlloca(clang::QualType type, mlir::Location loc,
+ clang::CharUnits alignment);
+
+public:
+ mlir::Value emitAlloca(llvm::StringRef name, mlir::Type ty,
+ mlir::Location loc, clang::CharUnits alignment,
+ bool insertIntoFnEntryBlock,
+ mlir::Value arraySize = nullptr);
+ mlir::Value emitAlloca(llvm::StringRef name, mlir::Type ty,
+ mlir::Location loc, clang::CharUnits alignment,
+ mlir::OpBuilder::InsertPoint ip,
+ mlir::Value arraySize = nullptr);
+
+ /// Emit code to compute the specified expression which can have any type.
The
+ /// result is returned as an RValue struct. If this is an aggregate
+ /// expression, the aggloc/agglocvolatile arguments indicate where the result
+ /// should be returned.
+ RValue emitAnyExpr(const clang::Expr *e);
+
+ AutoVarEmission emitAutoVarAlloca(const clang::VarDecl &d);
+
+ /// Emit code and set up symbol table for a variable declaration with auto,
+ /// register, or no storage class specifier. These turn into simple stack
+ /// objects, globals depending on target.
+ void emitAutoVarDecl(const clang::VarDecl &d);
+
+ void emitAutoVarCleanups(const AutoVarEmission &emission);
+ void emitAutoVarInit(const AutoVarEmission &emission);
+
+ LValue emitBinaryOperatorLValue(const BinaryOperator *e);
+
+ /// Emit an expression as an initializer for an object (variable, field,
etc.)
+ /// at the given location. The expression is not necessarily the normal
+ /// initializer for the object, and the address is not necessarily
+ /// its normal location.
+ ///
+ /// \param init the initializing expression
+ /// \param d the object to act as if we're initializing
+ /// \param lvalue the lvalue to initialize
+ /// \param capturedByInit true if \p d is a __block variable whose address is
+ /// potentially changed by the initializer
+ void emitExprAsInit(const clang::Expr *init, const clang::ValueDecl *d,
+ LValue lvalue, bool capturedByInit = false);
+
+ mlir::LogicalResult emitFunctionBody(const clang::Stmt *body);
+
+ mlir::Value emitPromotedScalarExpr(const Expr *e, QualType promotionType);
+
+ /// Emit the computation of the specified expression of scalar type.
+ mlir::Value emitScalarExpr(const clang::Expr *e);
+
+ mlir::Value emitScalarPrePostIncDec(const UnaryOperator *e, LValue lv,
+ bool isInc, bool isPre);
+
+ /// Build a debug stoppoint if we are emitting debug info.
+ void emitStopPoint(const Stmt *s);
+
+ // Build CIR for a statement. useCurrentScope should be true if no
+ // new scopes need be created when finding a compound statement.
+ mlir::LogicalResult
+ emitStmt(const clang::Stmt *s, bool useCurrentScope,
+ llvm::ArrayRef<const Attr *> attrs = std::nullopt);
+
+ mlir::LogicalResult emitSimpleStmt(const clang::Stmt *s,
+ bool useCurrentScope);
+
+ mlir::LogicalResult emitForStmt(const clang::ForStmt &S);
+
+ void emitCompoundStmt(const clang::CompoundStmt &s);
+
+ void emitCompoundStmtWithoutScope(const clang::CompoundStmt &s);
+
+ void emitDecl(const clang::Decl &d);
+ mlir::LogicalResult emitDeclStmt(const clang::DeclStmt &s);
+ LValue emitDeclRefLValue(const clang::DeclRefExpr *e);
+
+ /// Emit code to compute the specified expression,
+ /// ignoring the result.
+ void emitIgnoredExpr(const clang::Expr *e);
+
+ /// Given an expression that represents a value lvalue, this method emits
+ /// the address of the lvalue, then loads the result as an rvalue,
+ /// returning the rvalue.
+ RValue emitLoadOfLValue(LValue lv, SourceLocation loc);
+
+ /// EmitLoadOfScalar - Load a scalar value from an address, taking
+ /// care to appropriately convert from the memory representation to
+ /// the LLVM value representation. The l-value must be a simple
+ /// l-value.
+ mlir::Value emitLoadOfScalar(LValue lvalue, SourceLocation loc);
+
+ /// Emit code to compute a designator that specifies the location
+ /// of the expression.
+ /// FIXME: document this function better.
+ LValue emitLValue(const clang::Expr *e);
+
+ mlir::LogicalResult emitReturnStmt(const clang::ReturnStmt &s);
+
+ /// Emit a conversion from the specified type to the specified destination
+ /// type, both of which are CIR scalar types.
+ mlir::Value emitScalarConversion(mlir::Value src, clang::QualType srcType,
+ clang::QualType dstType,
+ clang::SourceLocation loc);
+
+ void emitScalarInit(const clang::Expr *init, mlir::Location loc,
+ LValue lvalue, bool capturedByInit = false);
+
+ void emitStoreOfScalar(mlir::Value value, Address addr, bool isVolatile,
+ clang::QualType ty, bool isInit = false,
+ bool isNontemporal = false);
+ void emitStoreOfScalar(mlir::Value value, LValue lvalue, bool isInit);
+
+ /// Store the specified rvalue into the specified
+ /// lvalue, where both are guaranteed to the have the same type, and that
type
+ /// is 'Ty'.
+ void emitStoreThroughLValue(RValue Src, LValue Dst, bool isInit = false);
+
+ /// Given a value and its clang type, returns the value casted to its memory
+ /// representation.
+ /// Note: CIR defers most of the special casting to the final lowering passes
+ /// to conserve the high level information.
+ mlir::Value emitToMemory(mlir::Value Value, clang::QualType Ty);
----------------
xlauko wrote:
```suggestion
mlir::Value emitToMemory(mlir::Value value, clang::QualType ty);
```
https://github.com/llvm/llvm-project/pull/133017
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
