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