MCExpr.h revision e3e7a369f20af66a96830d8bfe52668c9e2e1fa1
1116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch//===- MCExpr.h - Assembly Level Expressions --------------------*- C++ -*-===// 2116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch// 3116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch// The LLVM Compiler Infrastructure 4116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch// 5116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch// This file is distributed under the University of Illinois Open Source 6116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch// License. See LICENSE.TXT for details. 7116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch// 8116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch//===----------------------------------------------------------------------===// 9116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch 10116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch#ifndef LLVM_MC_MCEXPR_H 11116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch#define LLVM_MC_MCEXPR_H 12116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch 13116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch#include "llvm/Support/Casting.h" 14116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch#include "llvm/System/DataTypes.h" 15116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch 16116680a4aac90f2aa7413d9095a592090648e557Ben Murdochnamespace llvm { 17116680a4aac90f2aa7413d9095a592090648e557Ben Murdochclass MCAsmInfo; 18116680a4aac90f2aa7413d9095a592090648e557Ben Murdochclass MCContext; 19116680a4aac90f2aa7413d9095a592090648e557Ben Murdochclass MCSymbol; 20116680a4aac90f2aa7413d9095a592090648e557Ben Murdochclass MCValue; 21116680a4aac90f2aa7413d9095a592090648e557Ben Murdochclass raw_ostream; 22116680a4aac90f2aa7413d9095a592090648e557Ben Murdochclass StringRef; 23116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch 24116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch/// MCExpr - Base class for the full range of assembler expressions which are 25116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch/// needed for parsing. 26116680a4aac90f2aa7413d9095a592090648e557Ben Murdochclass MCExpr { 27116680a4aac90f2aa7413d9095a592090648e557Ben Murdochpublic: 28116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch enum ExprKind { 29116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch Binary, ///< Binary expressions. 30116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch Constant, ///< Constant expressions. 31116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch SymbolRef, ///< References to labels and assigned expressions. 32116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch Unary, ///< Unary expressions. 33116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch Target ///< Target specific expression. 34116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch }; 35116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch 36116680a4aac90f2aa7413d9095a592090648e557Ben Murdochprivate: 37116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch ExprKind Kind; 38116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch 39116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch MCExpr(const MCExpr&); // DO NOT IMPLEMENT 40116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch void operator=(const MCExpr&); // DO NOT IMPLEMENT 41116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch 42116680a4aac90f2aa7413d9095a592090648e557Ben Murdochprotected: 43116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch explicit MCExpr(ExprKind _Kind) : Kind(_Kind) {} 44116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch 45116680a4aac90f2aa7413d9095a592090648e557Ben Murdochpublic: 46116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch /// @name Accessors 47116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch /// @{ 48 49 ExprKind getKind() const { return Kind; } 50 51 /// @} 52 /// @name Utility Methods 53 /// @{ 54 55 void print(raw_ostream &OS) const; 56 void dump() const; 57 58 /// @} 59 /// @name Expression Evaluation 60 /// @{ 61 62 /// EvaluateAsAbsolute - Try to evaluate the expression to an absolute value. 63 /// 64 /// @param Res - The absolute value, if evaluation succeeds. 65 /// @result - True on success. 66 bool EvaluateAsAbsolute(int64_t &Res) const; 67 68 /// EvaluateAsRelocatable - Try to evaluate the expression to a relocatable 69 /// value, i.e. an expression of the fixed form (a - b + constant). 70 /// 71 /// @param Res - The relocatable value, if evaluation succeeds. 72 /// @result - True on success. 73 bool EvaluateAsRelocatable(MCValue &Res) const; 74 75 /// @} 76 77 static bool classof(const MCExpr *) { return true; } 78}; 79 80inline raw_ostream &operator<<(raw_ostream &OS, const MCExpr &E) { 81 E.print(OS); 82 return OS; 83} 84 85//// MCConstantExpr - Represent a constant integer expression. 86class MCConstantExpr : public MCExpr { 87 int64_t Value; 88 89 explicit MCConstantExpr(int64_t _Value) 90 : MCExpr(MCExpr::Constant), Value(_Value) {} 91 92public: 93 /// @name Construction 94 /// @{ 95 96 static const MCConstantExpr *Create(int64_t Value, MCContext &Ctx); 97 98 /// @} 99 /// @name Accessors 100 /// @{ 101 102 int64_t getValue() const { return Value; } 103 104 /// @} 105 106 static bool classof(const MCExpr *E) { 107 return E->getKind() == MCExpr::Constant; 108 } 109 static bool classof(const MCConstantExpr *) { return true; } 110}; 111 112/// MCSymbolRefExpr - Represent a reference to a symbol from inside an 113/// expression. 114/// 115/// A symbol reference in an expression may be a use of a label, a use of an 116/// assembler variable (defined constant), or constitute an implicit definition 117/// of the symbol as external. 118class MCSymbolRefExpr : public MCExpr { 119 const MCSymbol *Symbol; 120 121 explicit MCSymbolRefExpr(const MCSymbol *_Symbol) 122 : MCExpr(MCExpr::SymbolRef), Symbol(_Symbol) {} 123 124public: 125 /// @name Construction 126 /// @{ 127 128 static const MCSymbolRefExpr *Create(const MCSymbol *Symbol, MCContext &Ctx); 129 static const MCSymbolRefExpr *Create(StringRef Name, MCContext &Ctx); 130 131 /// @} 132 /// @name Accessors 133 /// @{ 134 135 const MCSymbol &getSymbol() const { return *Symbol; } 136 137 /// @} 138 139 static bool classof(const MCExpr *E) { 140 return E->getKind() == MCExpr::SymbolRef; 141 } 142 static bool classof(const MCSymbolRefExpr *) { return true; } 143}; 144 145/// MCUnaryExpr - Unary assembler expressions. 146class MCUnaryExpr : public MCExpr { 147public: 148 enum Opcode { 149 LNot, ///< Logical negation. 150 Minus, ///< Unary minus. 151 Not, ///< Bitwise negation. 152 Plus ///< Unary plus. 153 }; 154 155private: 156 Opcode Op; 157 const MCExpr *Expr; 158 159 MCUnaryExpr(Opcode _Op, const MCExpr *_Expr) 160 : MCExpr(MCExpr::Unary), Op(_Op), Expr(_Expr) {} 161 162public: 163 /// @name Construction 164 /// @{ 165 166 static const MCUnaryExpr *Create(Opcode Op, const MCExpr *Expr, 167 MCContext &Ctx); 168 static const MCUnaryExpr *CreateLNot(const MCExpr *Expr, MCContext &Ctx) { 169 return Create(LNot, Expr, Ctx); 170 } 171 static const MCUnaryExpr *CreateMinus(const MCExpr *Expr, MCContext &Ctx) { 172 return Create(Minus, Expr, Ctx); 173 } 174 static const MCUnaryExpr *CreateNot(const MCExpr *Expr, MCContext &Ctx) { 175 return Create(Not, Expr, Ctx); 176 } 177 static const MCUnaryExpr *CreatePlus(const MCExpr *Expr, MCContext &Ctx) { 178 return Create(Plus, Expr, Ctx); 179 } 180 181 /// @} 182 /// @name Accessors 183 /// @{ 184 185 /// getOpcode - Get the kind of this unary expression. 186 Opcode getOpcode() const { return Op; } 187 188 /// getSubExpr - Get the child of this unary expression. 189 const MCExpr *getSubExpr() const { return Expr; } 190 191 /// @} 192 193 static bool classof(const MCExpr *E) { 194 return E->getKind() == MCExpr::Unary; 195 } 196 static bool classof(const MCUnaryExpr *) { return true; } 197}; 198 199/// MCBinaryExpr - Binary assembler expressions. 200class MCBinaryExpr : public MCExpr { 201public: 202 enum Opcode { 203 Add, ///< Addition. 204 And, ///< Bitwise and. 205 Div, ///< Signed division. 206 EQ, ///< Equality comparison. 207 GT, ///< Signed greater than comparison (result is either 0 or some 208 ///< target-specific non-zero value) 209 GTE, ///< Signed greater than or equal comparison (result is either 0 or 210 ///< some target-specific non-zero value). 211 LAnd, ///< Logical and. 212 LOr, ///< Logical or. 213 LT, ///< Signed less than comparison (result is either 0 or 214 ///< some target-specific non-zero value). 215 LTE, ///< Signed less than or equal comparison (result is either 0 or 216 ///< some target-specific non-zero value). 217 Mod, ///< Signed remainder. 218 Mul, ///< Multiplication. 219 NE, ///< Inequality comparison. 220 Or, ///< Bitwise or. 221 Shl, ///< Shift left. 222 Shr, ///< Shift right (arithmetic or logical, depending on target) 223 Sub, ///< Subtraction. 224 Xor ///< Bitwise exclusive or. 225 }; 226 227private: 228 Opcode Op; 229 const MCExpr *LHS, *RHS; 230 231 MCBinaryExpr(Opcode _Op, const MCExpr *_LHS, const MCExpr *_RHS) 232 : MCExpr(MCExpr::Binary), Op(_Op), LHS(_LHS), RHS(_RHS) {} 233 234public: 235 /// @name Construction 236 /// @{ 237 238 static const MCBinaryExpr *Create(Opcode Op, const MCExpr *LHS, 239 const MCExpr *RHS, MCContext &Ctx); 240 static const MCBinaryExpr *CreateAdd(const MCExpr *LHS, const MCExpr *RHS, 241 MCContext &Ctx) { 242 return Create(Add, LHS, RHS, Ctx); 243 } 244 static const MCBinaryExpr *CreateAnd(const MCExpr *LHS, const MCExpr *RHS, 245 MCContext &Ctx) { 246 return Create(And, LHS, RHS, Ctx); 247 } 248 static const MCBinaryExpr *CreateDiv(const MCExpr *LHS, const MCExpr *RHS, 249 MCContext &Ctx) { 250 return Create(Div, LHS, RHS, Ctx); 251 } 252 static const MCBinaryExpr *CreateEQ(const MCExpr *LHS, const MCExpr *RHS, 253 MCContext &Ctx) { 254 return Create(EQ, LHS, RHS, Ctx); 255 } 256 static const MCBinaryExpr *CreateGT(const MCExpr *LHS, const MCExpr *RHS, 257 MCContext &Ctx) { 258 return Create(GT, LHS, RHS, Ctx); 259 } 260 static const MCBinaryExpr *CreateGTE(const MCExpr *LHS, const MCExpr *RHS, 261 MCContext &Ctx) { 262 return Create(GTE, LHS, RHS, Ctx); 263 } 264 static const MCBinaryExpr *CreateLAnd(const MCExpr *LHS, const MCExpr *RHS, 265 MCContext &Ctx) { 266 return Create(LAnd, LHS, RHS, Ctx); 267 } 268 static const MCBinaryExpr *CreateLOr(const MCExpr *LHS, const MCExpr *RHS, 269 MCContext &Ctx) { 270 return Create(LOr, LHS, RHS, Ctx); 271 } 272 static const MCBinaryExpr *CreateLT(const MCExpr *LHS, const MCExpr *RHS, 273 MCContext &Ctx) { 274 return Create(LT, LHS, RHS, Ctx); 275 } 276 static const MCBinaryExpr *CreateLTE(const MCExpr *LHS, const MCExpr *RHS, 277 MCContext &Ctx) { 278 return Create(LTE, LHS, RHS, Ctx); 279 } 280 static const MCBinaryExpr *CreateMod(const MCExpr *LHS, const MCExpr *RHS, 281 MCContext &Ctx) { 282 return Create(Mod, LHS, RHS, Ctx); 283 } 284 static const MCBinaryExpr *CreateMul(const MCExpr *LHS, const MCExpr *RHS, 285 MCContext &Ctx) { 286 return Create(Mul, LHS, RHS, Ctx); 287 } 288 static const MCBinaryExpr *CreateNE(const MCExpr *LHS, const MCExpr *RHS, 289 MCContext &Ctx) { 290 return Create(NE, LHS, RHS, Ctx); 291 } 292 static const MCBinaryExpr *CreateOr(const MCExpr *LHS, const MCExpr *RHS, 293 MCContext &Ctx) { 294 return Create(Or, LHS, RHS, Ctx); 295 } 296 static const MCBinaryExpr *CreateShl(const MCExpr *LHS, const MCExpr *RHS, 297 MCContext &Ctx) { 298 return Create(Shl, LHS, RHS, Ctx); 299 } 300 static const MCBinaryExpr *CreateShr(const MCExpr *LHS, const MCExpr *RHS, 301 MCContext &Ctx) { 302 return Create(Shr, LHS, RHS, Ctx); 303 } 304 static const MCBinaryExpr *CreateSub(const MCExpr *LHS, const MCExpr *RHS, 305 MCContext &Ctx) { 306 return Create(Sub, LHS, RHS, Ctx); 307 } 308 static const MCBinaryExpr *CreateXor(const MCExpr *LHS, const MCExpr *RHS, 309 MCContext &Ctx) { 310 return Create(Xor, LHS, RHS, Ctx); 311 } 312 313 /// @} 314 /// @name Accessors 315 /// @{ 316 317 /// getOpcode - Get the kind of this binary expression. 318 Opcode getOpcode() const { return Op; } 319 320 /// getLHS - Get the left-hand side expression of the binary operator. 321 const MCExpr *getLHS() const { return LHS; } 322 323 /// getRHS - Get the right-hand side expression of the binary operator. 324 const MCExpr *getRHS() const { return RHS; } 325 326 /// @} 327 328 static bool classof(const MCExpr *E) { 329 return E->getKind() == MCExpr::Binary; 330 } 331 static bool classof(const MCBinaryExpr *) { return true; } 332}; 333 334/// MCTargetExpr - This is an extension point for target-specific MCExpr 335/// subclasses to implement. 336/// 337/// NOTE: All subclasses are required to have trivial destructors because 338/// MCExprs are bump pointer allocated and not destructed. 339class MCTargetExpr : public MCExpr { 340 virtual void Anchor(); 341protected: 342 MCTargetExpr() : MCExpr(Target) {} 343 virtual ~MCTargetExpr() {} 344public: 345 346 virtual void PrintImpl(raw_ostream &OS) const = 0; 347 virtual bool EvaluateAsRelocatableImpl(MCValue &Res) const = 0; 348 349 350 static bool classof(const MCExpr *E) { 351 return E->getKind() == MCExpr::Target; 352 } 353 static bool classof(const MCTargetExpr *) { return true; } 354}; 355 356} // end namespace llvm 357 358#endif 359