MCExpr.h revision 5d917a8952c09a345180ec36f0df4ee5dd5eddea
1//===- MCExpr.h - Assembly Level Expressions --------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#ifndef LLVM_MC_MCEXPR_H 11#define LLVM_MC_MCEXPR_H 12 13#include "llvm/Support/Casting.h" 14#include "llvm/System/DataTypes.h" 15 16namespace llvm { 17class MCAsmInfo; 18class MCContext; 19class MCSymbol; 20class MCValue; 21class raw_ostream; 22class StringRef; 23 24/// MCExpr - Base class for the full range of assembler expressions which are 25/// needed for parsing. 26class MCExpr { 27public: 28 enum ExprKind { 29 Binary, ///< Binary expressions. 30 Constant, ///< Constant expressions. 31 SymbolRef, ///< References to labels and assigned expressions. 32 Unary, ///< Unary expressions. 33 Target ///< Target specific expression. 34 }; 35 36private: 37 ExprKind Kind; 38 39 MCExpr(const MCExpr&); // DO NOT IMPLEMENT 40 void operator=(const MCExpr&); // DO NOT IMPLEMENT 41 42protected: 43 MCExpr(ExprKind _Kind) : Kind(_Kind) {} 44 45public: 46 /// @name Accessors 47 /// @{ 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 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 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, ///< Division. 206 EQ, ///< Equality comparison. 207 GT, ///< Greater than comparison. 208 GTE, ///< Greater than or equal comparison. 209 LAnd, ///< Logical and. 210 LOr, ///< Logical or. 211 LT, ///< Less than comparison. 212 LTE, ///< Less than or equal comparison. 213 Mod, ///< Modulus. 214 Mul, ///< Multiplication. 215 NE, ///< Inequality comparison. 216 Or, ///< Bitwise or. 217 Shl, ///< Bitwise shift left. 218 Shr, ///< Bitwise shift right. 219 Sub, ///< Subtraction. 220 Xor ///< Bitwise exclusive or. 221 }; 222 223private: 224 Opcode Op; 225 const MCExpr *LHS, *RHS; 226 227 MCBinaryExpr(Opcode _Op, const MCExpr *_LHS, const MCExpr *_RHS) 228 : MCExpr(MCExpr::Binary), Op(_Op), LHS(_LHS), RHS(_RHS) {} 229 230public: 231 /// @name Construction 232 /// @{ 233 234 static const MCBinaryExpr *Create(Opcode Op, const MCExpr *LHS, 235 const MCExpr *RHS, MCContext &Ctx); 236 static const MCBinaryExpr *CreateAdd(const MCExpr *LHS, const MCExpr *RHS, 237 MCContext &Ctx) { 238 return Create(Add, LHS, RHS, Ctx); 239 } 240 static const MCBinaryExpr *CreateAnd(const MCExpr *LHS, const MCExpr *RHS, 241 MCContext &Ctx) { 242 return Create(And, LHS, RHS, Ctx); 243 } 244 static const MCBinaryExpr *CreateDiv(const MCExpr *LHS, const MCExpr *RHS, 245 MCContext &Ctx) { 246 return Create(Div, LHS, RHS, Ctx); 247 } 248 static const MCBinaryExpr *CreateEQ(const MCExpr *LHS, const MCExpr *RHS, 249 MCContext &Ctx) { 250 return Create(EQ, LHS, RHS, Ctx); 251 } 252 static const MCBinaryExpr *CreateGT(const MCExpr *LHS, const MCExpr *RHS, 253 MCContext &Ctx) { 254 return Create(GT, LHS, RHS, Ctx); 255 } 256 static const MCBinaryExpr *CreateGTE(const MCExpr *LHS, const MCExpr *RHS, 257 MCContext &Ctx) { 258 return Create(GTE, LHS, RHS, Ctx); 259 } 260 static const MCBinaryExpr *CreateLAnd(const MCExpr *LHS, const MCExpr *RHS, 261 MCContext &Ctx) { 262 return Create(LAnd, LHS, RHS, Ctx); 263 } 264 static const MCBinaryExpr *CreateLOr(const MCExpr *LHS, const MCExpr *RHS, 265 MCContext &Ctx) { 266 return Create(LOr, LHS, RHS, Ctx); 267 } 268 static const MCBinaryExpr *CreateLT(const MCExpr *LHS, const MCExpr *RHS, 269 MCContext &Ctx) { 270 return Create(LT, LHS, RHS, Ctx); 271 } 272 static const MCBinaryExpr *CreateLTE(const MCExpr *LHS, const MCExpr *RHS, 273 MCContext &Ctx) { 274 return Create(LTE, LHS, RHS, Ctx); 275 } 276 static const MCBinaryExpr *CreateMod(const MCExpr *LHS, const MCExpr *RHS, 277 MCContext &Ctx) { 278 return Create(Mod, LHS, RHS, Ctx); 279 } 280 static const MCBinaryExpr *CreateMul(const MCExpr *LHS, const MCExpr *RHS, 281 MCContext &Ctx) { 282 return Create(Mul, LHS, RHS, Ctx); 283 } 284 static const MCBinaryExpr *CreateNE(const MCExpr *LHS, const MCExpr *RHS, 285 MCContext &Ctx) { 286 return Create(NE, LHS, RHS, Ctx); 287 } 288 static const MCBinaryExpr *CreateOr(const MCExpr *LHS, const MCExpr *RHS, 289 MCContext &Ctx) { 290 return Create(Or, LHS, RHS, Ctx); 291 } 292 static const MCBinaryExpr *CreateShl(const MCExpr *LHS, const MCExpr *RHS, 293 MCContext &Ctx) { 294 return Create(Shl, LHS, RHS, Ctx); 295 } 296 static const MCBinaryExpr *CreateShr(const MCExpr *LHS, const MCExpr *RHS, 297 MCContext &Ctx) { 298 return Create(Shr, LHS, RHS, Ctx); 299 } 300 static const MCBinaryExpr *CreateSub(const MCExpr *LHS, const MCExpr *RHS, 301 MCContext &Ctx) { 302 return Create(Sub, LHS, RHS, Ctx); 303 } 304 static const MCBinaryExpr *CreateXor(const MCExpr *LHS, const MCExpr *RHS, 305 MCContext &Ctx) { 306 return Create(Xor, LHS, RHS, Ctx); 307 } 308 309 /// @} 310 /// @name Accessors 311 /// @{ 312 313 /// getOpcode - Get the kind of this binary expression. 314 Opcode getOpcode() const { return Op; } 315 316 /// getLHS - Get the left-hand side expression of the binary operator. 317 const MCExpr *getLHS() const { return LHS; } 318 319 /// getRHS - Get the right-hand side expression of the binary operator. 320 const MCExpr *getRHS() const { return RHS; } 321 322 /// @} 323 324 static bool classof(const MCExpr *E) { 325 return E->getKind() == MCExpr::Binary; 326 } 327 static bool classof(const MCBinaryExpr *) { return true; } 328}; 329 330/// MCTargetExpr - This is an extension point for target-specific MCExpr 331/// subclasses to implement. 332/// 333/// NOTE: All subclasses are required to have trivial destructors because 334/// MCExprs are bump pointer allocated and not destructed. 335class MCTargetExpr : public MCExpr { 336 virtual ~MCTargetExpr(); // Not accessible. 337protected: 338 MCTargetExpr() : MCExpr(Target) {} 339 340public: 341 342 virtual void PrintImpl(raw_ostream &OS) const = 0; 343 virtual bool EvaluateAsRelocatableImpl(MCValue &Res) const = 0; 344 345 346 static bool classof(const MCExpr *E) { 347 return E->getKind() == MCExpr::Target; 348 } 349 static bool classof(const MCTargetExpr *) { return true; } 350}; 351 352} // end namespace llvm 353 354#endif 355