MCExpr.h revision f7c1ee79fe90353fcd3f545f9d45a01a837bbf4b
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/ADT/DenseMap.h" 14#include "llvm/Support/Casting.h" 15#include "llvm/Support/DataTypes.h" 16 17namespace llvm { 18class MCAsmLayout; 19class MCAssembler; 20class MCContext; 21class MCSection; 22class MCSectionData; 23class MCSymbol; 24class MCValue; 25class raw_ostream; 26class StringRef; 27typedef DenseMap<const MCSectionData*, uint64_t> SectionAddrMap; 28 29/// MCExpr - Base class for the full range of assembler expressions which are 30/// needed for parsing. 31class MCExpr { 32public: 33 enum ExprKind { 34 Binary, ///< Binary expressions. 35 Constant, ///< Constant expressions. 36 SymbolRef, ///< References to labels and assigned expressions. 37 Unary, ///< Unary expressions. 38 Target ///< Target specific expression. 39 }; 40 41private: 42 ExprKind Kind; 43 44 MCExpr(const MCExpr&) LLVM_DELETED_FUNCTION; 45 void operator=(const MCExpr&) LLVM_DELETED_FUNCTION; 46 47 bool EvaluateAsAbsolute(int64_t &Res, const MCAssembler *Asm, 48 const MCAsmLayout *Layout, 49 const SectionAddrMap *Addrs) const; 50protected: 51 explicit MCExpr(ExprKind _Kind) : Kind(_Kind) {} 52 53 bool EvaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm, 54 const MCAsmLayout *Layout, 55 const SectionAddrMap *Addrs, 56 bool InSet) const; 57public: 58 /// @name Accessors 59 /// @{ 60 61 ExprKind getKind() const { return Kind; } 62 63 /// @} 64 /// @name Utility Methods 65 /// @{ 66 67 void print(raw_ostream &OS) const; 68 void dump() const; 69 70 /// @} 71 /// @name Expression Evaluation 72 /// @{ 73 74 /// EvaluateAsAbsolute - Try to evaluate the expression to an absolute value. 75 /// 76 /// @param Res - The absolute value, if evaluation succeeds. 77 /// @param Layout - The assembler layout object to use for evaluating symbol 78 /// values. If not given, then only non-symbolic expressions will be 79 /// evaluated. 80 /// @result - True on success. 81 bool EvaluateAsAbsolute(int64_t &Res, const MCAsmLayout &Layout, 82 const SectionAddrMap &Addrs) const; 83 bool EvaluateAsAbsolute(int64_t &Res) const; 84 bool EvaluateAsAbsolute(int64_t &Res, const MCAssembler &Asm) const; 85 bool EvaluateAsAbsolute(int64_t &Res, const MCAsmLayout &Layout) const; 86 87 /// EvaluateAsRelocatable - Try to evaluate the expression to a relocatable 88 /// value, i.e. an expression of the fixed form (a - b + constant). 89 /// 90 /// @param Res - The relocatable value, if evaluation succeeds. 91 /// @param Layout - The assembler layout object to use for evaluating values. 92 /// @result - True on success. 93 bool EvaluateAsRelocatable(MCValue &Res, const MCAsmLayout &Layout) const; 94 95 /// FindAssociatedSection - Find the "associated section" for this expression, 96 /// which is currently defined as the absolute section for constants, or 97 /// otherwise the section associated with the first defined symbol in the 98 /// expression. 99 const MCSection *FindAssociatedSection() const; 100 101 /// @} 102}; 103 104inline raw_ostream &operator<<(raw_ostream &OS, const MCExpr &E) { 105 E.print(OS); 106 return OS; 107} 108 109//// MCConstantExpr - Represent a constant integer expression. 110class MCConstantExpr : public MCExpr { 111 int64_t Value; 112 113 explicit MCConstantExpr(int64_t _Value) 114 : MCExpr(MCExpr::Constant), Value(_Value) {} 115 116public: 117 /// @name Construction 118 /// @{ 119 120 static const MCConstantExpr *Create(int64_t Value, MCContext &Ctx); 121 122 /// @} 123 /// @name Accessors 124 /// @{ 125 126 int64_t getValue() const { return Value; } 127 128 /// @} 129 130 static bool classof(const MCExpr *E) { 131 return E->getKind() == MCExpr::Constant; 132 } 133}; 134 135/// MCSymbolRefExpr - Represent a reference to a symbol from inside an 136/// expression. 137/// 138/// A symbol reference in an expression may be a use of a label, a use of an 139/// assembler variable (defined constant), or constitute an implicit definition 140/// of the symbol as external. 141class MCSymbolRefExpr : public MCExpr { 142public: 143 enum VariantKind { 144 VK_None, 145 VK_Invalid, 146 147 VK_GOT, 148 VK_GOTOFF, 149 VK_GOTPCREL, 150 VK_GOTTPOFF, 151 VK_INDNTPOFF, 152 VK_NTPOFF, 153 VK_GOTNTPOFF, 154 VK_PLT, 155 VK_TLSGD, 156 VK_TLSLD, 157 VK_TLSLDM, 158 VK_TPOFF, 159 VK_DTPOFF, 160 VK_TLVP, // Mach-O thread local variable relocation 161 VK_SECREL, 162 // FIXME: We'd really like to use the generic Kinds listed above for these. 163 VK_ARM_NONE, 164 VK_ARM_PLT, // ARM-style PLT references. i.e., (PLT) instead of @PLT 165 VK_ARM_TLSGD, // ditto for TLSGD, GOT, GOTOFF, TPOFF and GOTTPOFF 166 VK_ARM_GOT, 167 VK_ARM_GOTOFF, 168 VK_ARM_TPOFF, 169 VK_ARM_GOTTPOFF, 170 VK_ARM_TARGET1, 171 VK_ARM_TARGET2, 172 VK_ARM_PREL31, 173 174 VK_PPC_LO, // symbol@l 175 VK_PPC_HI, // symbol@h 176 VK_PPC_HA, // symbol@ha 177 VK_PPC_HIGHER, // symbol@higher 178 VK_PPC_HIGHERA, // symbol@highera 179 VK_PPC_HIGHEST, // symbol@highest 180 VK_PPC_HIGHESTA, // symbol@highesta 181 VK_PPC_TOCBASE, // symbol@tocbase 182 VK_PPC_TOC, // symbol@toc 183 VK_PPC_TOC_LO, // symbol@toc@l 184 VK_PPC_TOC_HI, // symbol@toc@h 185 VK_PPC_TOC_HA, // symbol@toc@ha 186 VK_PPC_TPREL_LO, // symbol@tprel@l 187 VK_PPC_TPREL_HA, // symbol@tprel@ha 188 VK_PPC_DTPREL_LO, // symbol@dtprel@l 189 VK_PPC_DTPREL_HA, // symbol@dtprel@ha 190 VK_PPC_GOT_TPREL_LO, // symbol@got@tprel@l 191 VK_PPC_GOT_TPREL_HA, // symbol@got@tprel@ha 192 VK_PPC_TLS, // symbol@tls 193 VK_PPC_GOT_TLSGD_LO, // symbol@got@tlsgd@l 194 VK_PPC_GOT_TLSGD_HA, // symbol@got@tlsgd@ha 195 VK_PPC_TLSGD, // symbol@tlsgd 196 VK_PPC_GOT_TLSLD_LO, // symbol@got@tlsld@l 197 VK_PPC_GOT_TLSLD_HA, // symbol@got@tlsld@ha 198 VK_PPC_TLSLD, // symbol@tlsld 199 200 VK_Mips_GPREL, 201 VK_Mips_GOT_CALL, 202 VK_Mips_GOT16, 203 VK_Mips_GOT, 204 VK_Mips_ABS_HI, 205 VK_Mips_ABS_LO, 206 VK_Mips_TLSGD, 207 VK_Mips_TLSLDM, 208 VK_Mips_DTPREL_HI, 209 VK_Mips_DTPREL_LO, 210 VK_Mips_GOTTPREL, 211 VK_Mips_TPREL_HI, 212 VK_Mips_TPREL_LO, 213 VK_Mips_GPOFF_HI, 214 VK_Mips_GPOFF_LO, 215 VK_Mips_GOT_DISP, 216 VK_Mips_GOT_PAGE, 217 VK_Mips_GOT_OFST, 218 VK_Mips_HIGHER, 219 VK_Mips_HIGHEST, 220 VK_Mips_GOT_HI16, 221 VK_Mips_GOT_LO16, 222 VK_Mips_CALL_HI16, 223 VK_Mips_CALL_LO16, 224 225 VK_COFF_IMGREL32 // symbol@imgrel (image-relative) 226 }; 227 228private: 229 /// The symbol being referenced. 230 const MCSymbol *Symbol; 231 232 /// The symbol reference modifier. 233 const VariantKind Kind; 234 235 explicit MCSymbolRefExpr(const MCSymbol *_Symbol, VariantKind _Kind) 236 : MCExpr(MCExpr::SymbolRef), Symbol(_Symbol), Kind(_Kind) { 237 assert(Symbol); 238 } 239 240public: 241 /// @name Construction 242 /// @{ 243 244 static const MCSymbolRefExpr *Create(const MCSymbol *Symbol, MCContext &Ctx) { 245 return MCSymbolRefExpr::Create(Symbol, VK_None, Ctx); 246 } 247 248 static const MCSymbolRefExpr *Create(const MCSymbol *Symbol, VariantKind Kind, 249 MCContext &Ctx); 250 static const MCSymbolRefExpr *Create(StringRef Name, VariantKind Kind, 251 MCContext &Ctx); 252 253 /// @} 254 /// @name Accessors 255 /// @{ 256 257 const MCSymbol &getSymbol() const { return *Symbol; } 258 259 VariantKind getKind() const { return Kind; } 260 261 /// @} 262 /// @name Static Utility Functions 263 /// @{ 264 265 static StringRef getVariantKindName(VariantKind Kind); 266 267 static VariantKind getVariantKindForName(StringRef Name); 268 269 /// @} 270 271 static bool classof(const MCExpr *E) { 272 return E->getKind() == MCExpr::SymbolRef; 273 } 274}; 275 276/// MCUnaryExpr - Unary assembler expressions. 277class MCUnaryExpr : public MCExpr { 278public: 279 enum Opcode { 280 LNot, ///< Logical negation. 281 Minus, ///< Unary minus. 282 Not, ///< Bitwise negation. 283 Plus ///< Unary plus. 284 }; 285 286private: 287 Opcode Op; 288 const MCExpr *Expr; 289 290 MCUnaryExpr(Opcode _Op, const MCExpr *_Expr) 291 : MCExpr(MCExpr::Unary), Op(_Op), Expr(_Expr) {} 292 293public: 294 /// @name Construction 295 /// @{ 296 297 static const MCUnaryExpr *Create(Opcode Op, const MCExpr *Expr, 298 MCContext &Ctx); 299 static const MCUnaryExpr *CreateLNot(const MCExpr *Expr, MCContext &Ctx) { 300 return Create(LNot, Expr, Ctx); 301 } 302 static const MCUnaryExpr *CreateMinus(const MCExpr *Expr, MCContext &Ctx) { 303 return Create(Minus, Expr, Ctx); 304 } 305 static const MCUnaryExpr *CreateNot(const MCExpr *Expr, MCContext &Ctx) { 306 return Create(Not, Expr, Ctx); 307 } 308 static const MCUnaryExpr *CreatePlus(const MCExpr *Expr, MCContext &Ctx) { 309 return Create(Plus, Expr, Ctx); 310 } 311 312 /// @} 313 /// @name Accessors 314 /// @{ 315 316 /// getOpcode - Get the kind of this unary expression. 317 Opcode getOpcode() const { return Op; } 318 319 /// getSubExpr - Get the child of this unary expression. 320 const MCExpr *getSubExpr() const { return Expr; } 321 322 /// @} 323 324 static bool classof(const MCExpr *E) { 325 return E->getKind() == MCExpr::Unary; 326 } 327}; 328 329/// MCBinaryExpr - Binary assembler expressions. 330class MCBinaryExpr : public MCExpr { 331public: 332 enum Opcode { 333 Add, ///< Addition. 334 And, ///< Bitwise and. 335 Div, ///< Signed division. 336 EQ, ///< Equality comparison. 337 GT, ///< Signed greater than comparison (result is either 0 or some 338 ///< target-specific non-zero value) 339 GTE, ///< Signed greater than or equal comparison (result is either 0 or 340 ///< some target-specific non-zero value). 341 LAnd, ///< Logical and. 342 LOr, ///< Logical or. 343 LT, ///< Signed less than comparison (result is either 0 or 344 ///< some target-specific non-zero value). 345 LTE, ///< Signed less than or equal comparison (result is either 0 or 346 ///< some target-specific non-zero value). 347 Mod, ///< Signed remainder. 348 Mul, ///< Multiplication. 349 NE, ///< Inequality comparison. 350 Or, ///< Bitwise or. 351 Shl, ///< Shift left. 352 Shr, ///< Shift right (arithmetic or logical, depending on target) 353 Sub, ///< Subtraction. 354 Xor ///< Bitwise exclusive or. 355 }; 356 357private: 358 Opcode Op; 359 const MCExpr *LHS, *RHS; 360 361 MCBinaryExpr(Opcode _Op, const MCExpr *_LHS, const MCExpr *_RHS) 362 : MCExpr(MCExpr::Binary), Op(_Op), LHS(_LHS), RHS(_RHS) {} 363 364public: 365 /// @name Construction 366 /// @{ 367 368 static const MCBinaryExpr *Create(Opcode Op, const MCExpr *LHS, 369 const MCExpr *RHS, MCContext &Ctx); 370 static const MCBinaryExpr *CreateAdd(const MCExpr *LHS, const MCExpr *RHS, 371 MCContext &Ctx) { 372 return Create(Add, LHS, RHS, Ctx); 373 } 374 static const MCBinaryExpr *CreateAnd(const MCExpr *LHS, const MCExpr *RHS, 375 MCContext &Ctx) { 376 return Create(And, LHS, RHS, Ctx); 377 } 378 static const MCBinaryExpr *CreateDiv(const MCExpr *LHS, const MCExpr *RHS, 379 MCContext &Ctx) { 380 return Create(Div, LHS, RHS, Ctx); 381 } 382 static const MCBinaryExpr *CreateEQ(const MCExpr *LHS, const MCExpr *RHS, 383 MCContext &Ctx) { 384 return Create(EQ, LHS, RHS, Ctx); 385 } 386 static const MCBinaryExpr *CreateGT(const MCExpr *LHS, const MCExpr *RHS, 387 MCContext &Ctx) { 388 return Create(GT, LHS, RHS, Ctx); 389 } 390 static const MCBinaryExpr *CreateGTE(const MCExpr *LHS, const MCExpr *RHS, 391 MCContext &Ctx) { 392 return Create(GTE, LHS, RHS, Ctx); 393 } 394 static const MCBinaryExpr *CreateLAnd(const MCExpr *LHS, const MCExpr *RHS, 395 MCContext &Ctx) { 396 return Create(LAnd, LHS, RHS, Ctx); 397 } 398 static const MCBinaryExpr *CreateLOr(const MCExpr *LHS, const MCExpr *RHS, 399 MCContext &Ctx) { 400 return Create(LOr, LHS, RHS, Ctx); 401 } 402 static const MCBinaryExpr *CreateLT(const MCExpr *LHS, const MCExpr *RHS, 403 MCContext &Ctx) { 404 return Create(LT, LHS, RHS, Ctx); 405 } 406 static const MCBinaryExpr *CreateLTE(const MCExpr *LHS, const MCExpr *RHS, 407 MCContext &Ctx) { 408 return Create(LTE, LHS, RHS, Ctx); 409 } 410 static const MCBinaryExpr *CreateMod(const MCExpr *LHS, const MCExpr *RHS, 411 MCContext &Ctx) { 412 return Create(Mod, LHS, RHS, Ctx); 413 } 414 static const MCBinaryExpr *CreateMul(const MCExpr *LHS, const MCExpr *RHS, 415 MCContext &Ctx) { 416 return Create(Mul, LHS, RHS, Ctx); 417 } 418 static const MCBinaryExpr *CreateNE(const MCExpr *LHS, const MCExpr *RHS, 419 MCContext &Ctx) { 420 return Create(NE, LHS, RHS, Ctx); 421 } 422 static const MCBinaryExpr *CreateOr(const MCExpr *LHS, const MCExpr *RHS, 423 MCContext &Ctx) { 424 return Create(Or, LHS, RHS, Ctx); 425 } 426 static const MCBinaryExpr *CreateShl(const MCExpr *LHS, const MCExpr *RHS, 427 MCContext &Ctx) { 428 return Create(Shl, LHS, RHS, Ctx); 429 } 430 static const MCBinaryExpr *CreateShr(const MCExpr *LHS, const MCExpr *RHS, 431 MCContext &Ctx) { 432 return Create(Shr, LHS, RHS, Ctx); 433 } 434 static const MCBinaryExpr *CreateSub(const MCExpr *LHS, const MCExpr *RHS, 435 MCContext &Ctx) { 436 return Create(Sub, LHS, RHS, Ctx); 437 } 438 static const MCBinaryExpr *CreateXor(const MCExpr *LHS, const MCExpr *RHS, 439 MCContext &Ctx) { 440 return Create(Xor, LHS, RHS, Ctx); 441 } 442 443 /// @} 444 /// @name Accessors 445 /// @{ 446 447 /// getOpcode - Get the kind of this binary expression. 448 Opcode getOpcode() const { return Op; } 449 450 /// getLHS - Get the left-hand side expression of the binary operator. 451 const MCExpr *getLHS() const { return LHS; } 452 453 /// getRHS - Get the right-hand side expression of the binary operator. 454 const MCExpr *getRHS() const { return RHS; } 455 456 /// @} 457 458 static bool classof(const MCExpr *E) { 459 return E->getKind() == MCExpr::Binary; 460 } 461}; 462 463/// MCTargetExpr - This is an extension point for target-specific MCExpr 464/// subclasses to implement. 465/// 466/// NOTE: All subclasses are required to have trivial destructors because 467/// MCExprs are bump pointer allocated and not destructed. 468class MCTargetExpr : public MCExpr { 469 virtual void anchor(); 470protected: 471 MCTargetExpr() : MCExpr(Target) {} 472 virtual ~MCTargetExpr() {} 473public: 474 475 virtual void PrintImpl(raw_ostream &OS) const = 0; 476 virtual bool EvaluateAsRelocatableImpl(MCValue &Res, 477 const MCAsmLayout *Layout) const = 0; 478 virtual void AddValueSymbols(MCAssembler *) const = 0; 479 virtual const MCSection *FindAssociatedSection() const = 0; 480 481 virtual void fixELFSymbolsInTLSFixups(MCAssembler &) const = 0; 482 483 static bool classof(const MCExpr *E) { 484 return E->getKind() == MCExpr::Target; 485 } 486}; 487 488} // end namespace llvm 489 490#endif 491