clang 22.0.0git
CIRGenConstantEmitter.h
Go to the documentation of this file.
1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// A helper class for emitting expressions and values as cir::ConstantOp
10// and as initializers for global variables.
11//
12// Note: this is based on clang's LLVM IR codegen in ConstantEmitter.h, reusing
13// this class interface makes it easier move forward with bringing CIR codegen
14// to completion.
15//
16//===----------------------------------------------------------------------===//
17
18#ifndef CLANG_LIB_CIR_CODEGEN_CIRGENCONSTANTEMITTER_H
19#define CLANG_LIB_CIR_CODEGEN_CIRGENCONSTANTEMITTER_H
20
21#include "CIRGenFunction.h"
22#include "CIRGenModule.h"
23
24namespace clang::CIRGen {
25
27public:
30
31private:
32 bool abstract = false;
33
34#ifndef NDEBUG
35 // Variables used for asserting state consistency.
36
37 /// Whether non-abstract components of the emitter have been initialized.
38 bool initializedNonAbstract = false;
39
40 /// Whether the emitter has been finalized.
41 bool finalized = false;
42
43 /// Whether the constant-emission failed.
44 bool failed = false;
45#endif // NDEBUG
46
47 /// Whether we're in a constant context.
48 bool inConstantContext = false;
49
50public:
51 /// Initialize this emission in the context of the given function.
52 /// Use this if the expression might contain contextual references like
53 /// block addresses or PredefinedExprs.
55
57 : cgm(cgm), cgf(cgf) {}
58
59 ConstantEmitter(const ConstantEmitter &other) = delete;
60 ConstantEmitter &operator=(const ConstantEmitter &other) = delete;
61
63
64 /// Try to emit the initializer of the given declaration as an abstract
65 /// constant. If this succeeds, the emission must be finalized.
66 mlir::Attribute tryEmitForInitializer(const VarDecl &d);
67
68 void finalize(cir::GlobalOp gv);
69
70 // All of the "abstract" emission methods below permit the emission to
71 // be immediately discarded without finalizing anything. Therefore, they
72 // must also promise not to do anything that will, in the future, require
73 // finalization:
74 //
75 // - using the CGF (if present) for anything other than establishing
76 // semantic context; for example, an expression with ignored
77 // side-effects must not be emitted as an abstract expression
78 //
79 // - doing anything that would not be safe to duplicate within an
80 // initializer or to propagate to another context; for example,
81 // side effects, or emitting an initialization that requires a
82 // reference to its current location.
83 mlir::Attribute emitForMemory(mlir::Attribute c, QualType destType);
84
85 /// Try to emit the initializer of the given declaration as an abstract
86 /// constant.
87 mlir::Attribute tryEmitAbstractForInitializer(const VarDecl &d);
88
89 /// Emit the result of the given expression as an abstract constant,
90 /// asserting that it succeeded. This is only safe to do when the
91 /// expression is known to be a constant expression with either a fairly
92 /// simple type or a known simple form.
93 mlir::Attribute emitAbstract(const Expr *e, QualType destType);
94 mlir::Attribute emitAbstract(SourceLocation loc, const APValue &value,
95 QualType destType);
96
97 mlir::Attribute tryEmitConstantExpr(const ConstantExpr *ce);
98
99 // These are private helper routines of the constant emitter that
100 // can't actually be private because things are split out into helper
101 // functions and classes.
102
103 mlir::Attribute tryEmitPrivateForVarInit(const VarDecl &d);
104
105 mlir::TypedAttr tryEmitPrivate(const Expr *e, QualType destType);
106 mlir::Attribute tryEmitPrivate(const APValue &value, QualType destType);
107 mlir::Attribute tryEmitPrivateForMemory(const APValue &value, QualType t);
108
109private:
110#ifndef NDEBUG
111 void initializeNonAbstract() {
112 assert(!initializedNonAbstract);
113 initializedNonAbstract = true;
115 }
116 mlir::Attribute markIfFailed(mlir::Attribute init) {
117 if (!init)
118 failed = true;
119 return init;
120 }
121#else
122 void initializeNonAbstract() {}
123 mlir::Attribute markIfFailed(mlir::Attribute init) { return init; }
124#endif // NDEBUG
125
126 class AbstractStateRAII {
127 ConstantEmitter &emitter;
128 bool oldValue;
129
130 public:
131 AbstractStateRAII(ConstantEmitter &emitter, bool value)
132 : emitter(emitter), oldValue(emitter.abstract) {
133 emitter.abstract = value;
134 }
135 ~AbstractStateRAII() { emitter.abstract = oldValue; }
136 };
137};
138
139} // namespace clang::CIRGen
140
141#endif // CLANG_LIB_CIR_CODEGEN_CIRGENCONSTANTEMITTER_H
__device__ __2f16 float c
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
This class organizes the cross-function state that is used while generating CIR code.
Definition: CIRGenModule.h:56
mlir::Attribute emitForMemory(mlir::Attribute c, QualType destType)
ConstantEmitter(const ConstantEmitter &other)=delete
ConstantEmitter & operator=(const ConstantEmitter &other)=delete
mlir::TypedAttr tryEmitPrivate(const Expr *e, QualType destType)
mlir::Attribute tryEmitPrivateForVarInit(const VarDecl &d)
mlir::Attribute emitAbstract(const Expr *e, QualType destType)
Emit the result of the given expression as an abstract constant, asserting that it succeeded.
mlir::Attribute tryEmitPrivateForMemory(const APValue &value, QualType t)
mlir::Attribute tryEmitForInitializer(const VarDecl &d)
Try to emit the initializer of the given declaration as an abstract constant.
ConstantEmitter(CIRGenFunction &cgf)
Initialize this emission in the context of the given function.
mlir::Attribute tryEmitAbstractForInitializer(const VarDecl &d)
Try to emit the initializer of the given declaration as an abstract constant.
ConstantEmitter(CIRGenModule &cgm, CIRGenFunction *cgf=nullptr)
mlir::Attribute tryEmitConstantExpr(const ConstantExpr *ce)
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
Definition: Expr.h:1084
This represents one expression.
Definition: Expr.h:112
A (possibly-)qualified type.
Definition: TypeBase.h:937
Encodes a location in the source.
Represents a variable declaration or definition.
Definition: Decl.h:925
static bool addressSpace()