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