MCExpr.h revision f230df9af4012f9510de664b6d62b128e26a5861
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 MCAsmLayout; 19class MCContext; 20class MCSymbol; 21class MCValue; 22class raw_ostream; 23class StringRef; 24 25/// MCExpr - Base class for the full range of assembler expressions which are 26/// needed for parsing. 27class MCExpr { 28public: 29 enum ExprKind { 30 Binary, ///< Binary expressions. 31 Constant, ///< Constant expressions. 32 SymbolRef, ///< References to labels and assigned expressions. 33 Unary, ///< Unary expressions. 34 Target ///< Target specific expression. 35 }; 36 37private: 38 ExprKind Kind; 39 40 MCExpr(const MCExpr&); // DO NOT IMPLEMENT 41 void operator=(const MCExpr&); // DO NOT IMPLEMENT 42 43protected: 44 explicit MCExpr(ExprKind _Kind) : Kind(_Kind) {} 45 46 bool EvaluateAsRelocatableImpl(MCValue &Res, const MCAsmLayout *Layout, 47 bool InSet) const; 48public: 49 /// @name Accessors 50 /// @{ 51 52 ExprKind getKind() const { return Kind; } 53 54 /// @} 55 /// @name Utility Methods 56 /// @{ 57 58 void print(raw_ostream &OS) const; 59 void dump() const; 60 61 /// @} 62 /// @name Expression Evaluation 63 /// @{ 64 65 /// EvaluateAsAbsolute - Try to evaluate the expression to an absolute value. 66 /// 67 /// @param Res - The absolute value, if evaluation succeeds. 68 /// @param Layout - The assembler layout object to use for evaluating symbol 69 /// values. If not given, then only non-symbolic expressions will be 70 /// evaluated. 71 /// @result - True on success. 72 bool EvaluateAsAbsolute(int64_t &Res, const MCAsmLayout *Layout = 0) const; 73 74 /// EvaluateAsRelocatable - Try to evaluate the expression to a relocatable 75 /// value, i.e. an expression of the fixed form (a - b + constant). 76 /// 77 /// @param Res - The relocatable value, if evaluation succeeds. 78 /// @param Layout - The assembler layout object to use for evaluating values. 79 /// @result - True on success. 80 bool EvaluateAsRelocatable(MCValue &Res, const MCAsmLayout *Layout = 0) const; 81 82 /// @} 83 84 static bool classof(const MCExpr *) { return true; } 85}; 86 87inline raw_ostream &operator<<(raw_ostream &OS, const MCExpr &E) { 88 E.print(OS); 89 return OS; 90} 91 92//// MCConstantExpr - Represent a constant integer expression. 93class MCConstantExpr : public MCExpr { 94 int64_t Value; 95 96 explicit MCConstantExpr(int64_t _Value) 97 : MCExpr(MCExpr::Constant), Value(_Value) {} 98 99public: 100 /// @name Construction 101 /// @{ 102 103 static const MCConstantExpr *Create(int64_t Value, MCContext &Ctx); 104 105 /// @} 106 /// @name Accessors 107 /// @{ 108 109 int64_t getValue() const { return Value; } 110 111 /// @} 112 113 static bool classof(const MCExpr *E) { 114 return E->getKind() == MCExpr::Constant; 115 } 116 static bool classof(const MCConstantExpr *) { return true; } 117}; 118 119/// MCSymbolRefExpr - Represent a reference to a symbol from inside an 120/// expression. 121/// 122/// A symbol reference in an expression may be a use of a label, a use of an 123/// assembler variable (defined constant), or constitute an implicit definition 124/// of the symbol as external. 125class MCSymbolRefExpr : public MCExpr { 126public: 127 enum VariantKind { 128 VK_None, 129 VK_Invalid, 130 131 VK_GOT, 132 VK_GOTOFF, 133 VK_GOTPCREL, 134 VK_GOTTPOFF, 135 VK_INDNTPOFF, 136 VK_NTPOFF, 137 VK_PLT, 138 VK_TLSGD, 139 VK_TPOFF, 140 VK_ARM_HI16, // The R_ARM_MOVT_ABS relocation (:upper16: in the asm file) 141 VK_ARM_LO16, // The R_ARM_MOVW_ABS_NC relocation (:lower16: in the asm file) 142 VK_ARM_PLT, // ARM-style PLT symbol references. i.e., (PLT) instead of @PLT 143 VK_TLVP // Mach-O thread local variable relocation 144 }; 145 146private: 147 /// The symbol being referenced. 148 const MCSymbol *Symbol; 149 150 /// The symbol reference modifier. 151 const VariantKind Kind; 152 153 explicit MCSymbolRefExpr(const MCSymbol *_Symbol, VariantKind _Kind) 154 : MCExpr(MCExpr::SymbolRef), Symbol(_Symbol), Kind(_Kind) {} 155 156public: 157 /// @name Construction 158 /// @{ 159 160 static const MCSymbolRefExpr *Create(const MCSymbol *Symbol, MCContext &Ctx) { 161 return MCSymbolRefExpr::Create(Symbol, VK_None, Ctx); 162 } 163 164 static const MCSymbolRefExpr *Create(const MCSymbol *Symbol, VariantKind Kind, 165 MCContext &Ctx); 166 static const MCSymbolRefExpr *Create(StringRef Name, VariantKind Kind, 167 MCContext &Ctx); 168 169 /// @} 170 /// @name Accessors 171 /// @{ 172 173 const MCSymbol &getSymbol() const { return *Symbol; } 174 175 VariantKind getKind() const { return Kind; } 176 177 /// @} 178 /// @name Static Utility Functions 179 /// @{ 180 181 static StringRef getVariantKindName(VariantKind Kind); 182 183 static VariantKind getVariantKindForName(StringRef Name); 184 185 /// @} 186 187 static bool classof(const MCExpr *E) { 188 return E->getKind() == MCExpr::SymbolRef; 189 } 190 static bool classof(const MCSymbolRefExpr *) { return true; } 191}; 192 193/// MCUnaryExpr - Unary assembler expressions. 194class MCUnaryExpr : public MCExpr { 195public: 196 enum Opcode { 197 LNot, ///< Logical negation. 198 Minus, ///< Unary minus. 199 Not, ///< Bitwise negation. 200 Plus ///< Unary plus. 201 }; 202 203private: 204 Opcode Op; 205 const MCExpr *Expr; 206 207 MCUnaryExpr(Opcode _Op, const MCExpr *_Expr) 208 : MCExpr(MCExpr::Unary), Op(_Op), Expr(_Expr) {} 209 210public: 211 /// @name Construction 212 /// @{ 213 214 static const MCUnaryExpr *Create(Opcode Op, const MCExpr *Expr, 215 MCContext &Ctx); 216 static const MCUnaryExpr *CreateLNot(const MCExpr *Expr, MCContext &Ctx) { 217 return Create(LNot, Expr, Ctx); 218 } 219 static const MCUnaryExpr *CreateMinus(const MCExpr *Expr, MCContext &Ctx) { 220 return Create(Minus, Expr, Ctx); 221 } 222 static const MCUnaryExpr *CreateNot(const MCExpr *Expr, MCContext &Ctx) { 223 return Create(Not, Expr, Ctx); 224 } 225 static const MCUnaryExpr *CreatePlus(const MCExpr *Expr, MCContext &Ctx) { 226 return Create(Plus, Expr, Ctx); 227 } 228 229 /// @} 230 /// @name Accessors 231 /// @{ 232 233 /// getOpcode - Get the kind of this unary expression. 234 Opcode getOpcode() const { return Op; } 235 236 /// getSubExpr - Get the child of this unary expression. 237 const MCExpr *getSubExpr() const { return Expr; } 238 239 /// @} 240 241 static bool classof(const MCExpr *E) { 242 return E->getKind() == MCExpr::Unary; 243 } 244 static bool classof(const MCUnaryExpr *) { return true; } 245}; 246 247/// MCBinaryExpr - Binary assembler expressions. 248class MCBinaryExpr : public MCExpr { 249public: 250 enum Opcode { 251 Add, ///< Addition. 252 And, ///< Bitwise and. 253 Div, ///< Signed division. 254 EQ, ///< Equality comparison. 255 GT, ///< Signed greater than comparison (result is either 0 or some 256 ///< target-specific non-zero value) 257 GTE, ///< Signed greater than or equal comparison (result is either 0 or 258 ///< some target-specific non-zero value). 259 LAnd, ///< Logical and. 260 LOr, ///< Logical or. 261 LT, ///< Signed less than comparison (result is either 0 or 262 ///< some target-specific non-zero value). 263 LTE, ///< Signed less than or equal comparison (result is either 0 or 264 ///< some target-specific non-zero value). 265 Mod, ///< Signed remainder. 266 Mul, ///< Multiplication. 267 NE, ///< Inequality comparison. 268 Or, ///< Bitwise or. 269 Shl, ///< Shift left. 270 Shr, ///< Shift right (arithmetic or logical, depending on target) 271 Sub, ///< Subtraction. 272 Xor ///< Bitwise exclusive or. 273 }; 274 275private: 276 Opcode Op; 277 const MCExpr *LHS, *RHS; 278 279 MCBinaryExpr(Opcode _Op, const MCExpr *_LHS, const MCExpr *_RHS) 280 : MCExpr(MCExpr::Binary), Op(_Op), LHS(_LHS), RHS(_RHS) {} 281 282public: 283 /// @name Construction 284 /// @{ 285 286 static const MCBinaryExpr *Create(Opcode Op, const MCExpr *LHS, 287 const MCExpr *RHS, MCContext &Ctx); 288 static const MCBinaryExpr *CreateAdd(const MCExpr *LHS, const MCExpr *RHS, 289 MCContext &Ctx) { 290 return Create(Add, LHS, RHS, Ctx); 291 } 292 static const MCBinaryExpr *CreateAnd(const MCExpr *LHS, const MCExpr *RHS, 293 MCContext &Ctx) { 294 return Create(And, LHS, RHS, Ctx); 295 } 296 static const MCBinaryExpr *CreateDiv(const MCExpr *LHS, const MCExpr *RHS, 297 MCContext &Ctx) { 298 return Create(Div, LHS, RHS, Ctx); 299 } 300 static const MCBinaryExpr *CreateEQ(const MCExpr *LHS, const MCExpr *RHS, 301 MCContext &Ctx) { 302 return Create(EQ, LHS, RHS, Ctx); 303 } 304 static const MCBinaryExpr *CreateGT(const MCExpr *LHS, const MCExpr *RHS, 305 MCContext &Ctx) { 306 return Create(GT, LHS, RHS, Ctx); 307 } 308 static const MCBinaryExpr *CreateGTE(const MCExpr *LHS, const MCExpr *RHS, 309 MCContext &Ctx) { 310 return Create(GTE, LHS, RHS, Ctx); 311 } 312 static const MCBinaryExpr *CreateLAnd(const MCExpr *LHS, const MCExpr *RHS, 313 MCContext &Ctx) { 314 return Create(LAnd, LHS, RHS, Ctx); 315 } 316 static const MCBinaryExpr *CreateLOr(const MCExpr *LHS, const MCExpr *RHS, 317 MCContext &Ctx) { 318 return Create(LOr, LHS, RHS, Ctx); 319 } 320 static const MCBinaryExpr *CreateLT(const MCExpr *LHS, const MCExpr *RHS, 321 MCContext &Ctx) { 322 return Create(LT, LHS, RHS, Ctx); 323 } 324 static const MCBinaryExpr *CreateLTE(const MCExpr *LHS, const MCExpr *RHS, 325 MCContext &Ctx) { 326 return Create(LTE, LHS, RHS, Ctx); 327 } 328 static const MCBinaryExpr *CreateMod(const MCExpr *LHS, const MCExpr *RHS, 329 MCContext &Ctx) { 330 return Create(Mod, LHS, RHS, Ctx); 331 } 332 static const MCBinaryExpr *CreateMul(const MCExpr *LHS, const MCExpr *RHS, 333 MCContext &Ctx) { 334 return Create(Mul, LHS, RHS, Ctx); 335 } 336 static const MCBinaryExpr *CreateNE(const MCExpr *LHS, const MCExpr *RHS, 337 MCContext &Ctx) { 338 return Create(NE, LHS, RHS, Ctx); 339 } 340 static const MCBinaryExpr *CreateOr(const MCExpr *LHS, const MCExpr *RHS, 341 MCContext &Ctx) { 342 return Create(Or, LHS, RHS, Ctx); 343 } 344 static const MCBinaryExpr *CreateShl(const MCExpr *LHS, const MCExpr *RHS, 345 MCContext &Ctx) { 346 return Create(Shl, LHS, RHS, Ctx); 347 } 348 static const MCBinaryExpr *CreateShr(const MCExpr *LHS, const MCExpr *RHS, 349 MCContext &Ctx) { 350 return Create(Shr, LHS, RHS, Ctx); 351 } 352 static const MCBinaryExpr *CreateSub(const MCExpr *LHS, const MCExpr *RHS, 353 MCContext &Ctx) { 354 return Create(Sub, LHS, RHS, Ctx); 355 } 356 static const MCBinaryExpr *CreateXor(const MCExpr *LHS, const MCExpr *RHS, 357 MCContext &Ctx) { 358 return Create(Xor, LHS, RHS, Ctx); 359 } 360 361 /// @} 362 /// @name Accessors 363 /// @{ 364 365 /// getOpcode - Get the kind of this binary expression. 366 Opcode getOpcode() const { return Op; } 367 368 /// getLHS - Get the left-hand side expression of the binary operator. 369 const MCExpr *getLHS() const { return LHS; } 370 371 /// getRHS - Get the right-hand side expression of the binary operator. 372 const MCExpr *getRHS() const { return RHS; } 373 374 /// @} 375 376 static bool classof(const MCExpr *E) { 377 return E->getKind() == MCExpr::Binary; 378 } 379 static bool classof(const MCBinaryExpr *) { return true; } 380}; 381 382/// MCTargetExpr - This is an extension point for target-specific MCExpr 383/// subclasses to implement. 384/// 385/// NOTE: All subclasses are required to have trivial destructors because 386/// MCExprs are bump pointer allocated and not destructed. 387class MCTargetExpr : public MCExpr { 388 virtual void Anchor(); 389protected: 390 MCTargetExpr() : MCExpr(Target) {} 391 virtual ~MCTargetExpr() {} 392public: 393 394 virtual void PrintImpl(raw_ostream &OS) const = 0; 395 virtual bool EvaluateAsRelocatableImpl(MCValue &Res, 396 const MCAsmLayout *Layout) const = 0; 397 398 399 static bool classof(const MCExpr *E) { 400 return E->getKind() == MCExpr::Target; 401 } 402 static bool classof(const MCTargetExpr *) { return true; } 403}; 404 405} // end namespace llvm 406 407#endif 408