LLVM 20.0.0git
MCExpr.h
Go to the documentation of this file.
1//===- MCExpr.h - Assembly Level Expressions --------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef LLVM_MC_MCEXPR_H
10#define LLVM_MC_MCEXPR_H
11
12#include "llvm/ADT/DenseMap.h"
13#include "llvm/Support/SMLoc.h"
14#include <cstdint>
15
16namespace llvm {
17
18class MCAsmInfo;
19class MCAssembler;
20class MCContext;
21class MCFixup;
22class MCFragment;
23class MCSection;
24class MCStreamer;
25class MCSymbol;
26class MCValue;
27class raw_ostream;
28class StringRef;
29
31
32/// Base class for the full range of assembler expressions which are
33/// needed for parsing.
34class MCExpr {
35public:
36 enum ExprKind : uint8_t {
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
44private:
45 static const unsigned NumSubclassDataBits = 24;
46 static_assert(
47 NumSubclassDataBits == CHAR_BIT * (sizeof(unsigned) - sizeof(ExprKind)),
48 "ExprKind and SubclassData together should take up one word");
49
50 ExprKind Kind;
51 /// Field reserved for use by MCExpr subclasses.
52 unsigned SubclassData : NumSubclassDataBits;
53 SMLoc Loc;
54
55 bool evaluateAsAbsolute(int64_t &Res, const MCAssembler *Asm,
56 const SectionAddrMap *Addrs, bool InSet) const;
57
58protected:
59 explicit MCExpr(ExprKind Kind, SMLoc Loc, unsigned SubclassData = 0)
60 : Kind(Kind), SubclassData(SubclassData), Loc(Loc) {
61 assert(SubclassData < (1 << NumSubclassDataBits) &&
62 "Subclass data too large");
63 }
64
65 bool evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
66 const MCFixup *Fixup,
67 const SectionAddrMap *Addrs, bool InSet) const;
68
69 unsigned getSubclassData() const { return SubclassData; }
70
71public:
72 MCExpr(const MCExpr &) = delete;
73 MCExpr &operator=(const MCExpr &) = delete;
74
75 /// \name Accessors
76 /// @{
77
78 ExprKind getKind() const { return Kind; }
79 SMLoc getLoc() const { return Loc; }
80
81 /// @}
82 /// \name Utility Methods
83 /// @{
84
85 void print(raw_ostream &OS, const MCAsmInfo *MAI,
86 bool InParens = false) const;
87 void dump() const;
88
89 /// @}
90 /// \name Expression Evaluation
91 /// @{
92
93 /// Try to evaluate the expression to an absolute value.
94 ///
95 /// \param Res - The absolute value, if evaluation succeeds.
96 /// \return - True on success.
97 bool evaluateAsAbsolute(int64_t &Res, const MCAssembler &Asm,
98 const SectionAddrMap &Addrs) const;
99 bool evaluateAsAbsolute(int64_t &Res) const;
100 bool evaluateAsAbsolute(int64_t &Res, const MCAssembler &Asm) const;
101 bool evaluateAsAbsolute(int64_t &Res, const MCAssembler *Asm) const;
102
103 /// Aggressive variant of evaluateAsRelocatable when relocations are
104 /// unavailable (e.g. .fill). Expects callers to handle errors when true is
105 /// returned.
106 bool evaluateKnownAbsolute(int64_t &Res, const MCAssembler &Asm) const;
107
108 /// Try to evaluate the expression to a relocatable value, i.e. an
109 /// expression of the fixed form (a - b + constant).
110 ///
111 /// \param Res - The relocatable value, if evaluation succeeds.
112 /// \param Asm - The assembler object to use for evaluating values.
113 /// \param Fixup - The Fixup object if available.
114 /// \return - True on success.
115 bool evaluateAsRelocatable(MCValue &Res, const MCAssembler *Asm,
116 const MCFixup *Fixup) const;
117
118 /// Try to evaluate the expression to the form (a - b + constant) where
119 /// neither a nor b are variables.
120 ///
121 /// This is a more aggressive variant of evaluateAsRelocatable. The intended
122 /// use is for when relocations are not available, like the .size directive.
123 bool evaluateAsValue(MCValue &Res, const MCAssembler &Asm) const;
124
125 /// Find the "associated section" for this expression, which is
126 /// currently defined as the absolute section for constants, or
127 /// otherwise the section associated with the first defined symbol in the
128 /// expression.
130
131 /// @}
132};
133
135 E.print(OS, nullptr);
136 return OS;
137}
138
139//// Represent a constant integer expression.
140class MCConstantExpr : public MCExpr {
141 int64_t Value;
142
143 // Subclass data stores SizeInBytes in bits 0..7 and PrintInHex in bit 8.
144 static const unsigned SizeInBytesBits = 8;
145 static const unsigned SizeInBytesMask = (1 << SizeInBytesBits) - 1;
146 static const unsigned PrintInHexBit = 1 << SizeInBytesBits;
147
148 static unsigned encodeSubclassData(bool PrintInHex, unsigned SizeInBytes) {
149 assert(SizeInBytes <= sizeof(int64_t) && "Excessive size");
150 return SizeInBytes | (PrintInHex ? PrintInHexBit : 0);
151 }
152
153 MCConstantExpr(int64_t Value, bool PrintInHex, unsigned SizeInBytes)
155 encodeSubclassData(PrintInHex, SizeInBytes)), Value(Value) {}
156
157public:
158 /// \name Construction
159 /// @{
160
161 static const MCConstantExpr *create(int64_t Value, MCContext &Ctx,
162 bool PrintInHex = false,
163 unsigned SizeInBytes = 0);
164
165 /// @}
166 /// \name Accessors
167 /// @{
168
169 int64_t getValue() const { return Value; }
170 unsigned getSizeInBytes() const {
171 return getSubclassData() & SizeInBytesMask;
172 }
173
174 bool useHexFormat() const { return (getSubclassData() & PrintInHexBit) != 0; }
175
176 /// @}
177
178 static bool classof(const MCExpr *E) {
179 return E->getKind() == MCExpr::Constant;
180 }
181};
182
183/// Represent a reference to a symbol from inside an expression.
184///
185/// A symbol reference in an expression may be a use of a label, a use of an
186/// assembler variable (defined constant), or constitute an implicit definition
187/// of the symbol as external.
188class MCSymbolRefExpr : public MCExpr {
189public:
193
210 VK_TLSCALL, // symbol(tlscall)
211 VK_TLSDESC, // symbol(tlsdesc)
212 VK_TLVP, // Mach-O thread local variable relocations
220 VK_SIZE, // symbol@SIZE
221 VK_WEAKREF, // The link between the symbols in .weakref foo, bar
228
231
237 VK_ARM_SBREL, // symbol(sbrel)
238 VK_ARM_TLSLDO, // symbol(tlsldo)
240
249
250 VK_PPC_LO, // symbol@l
251 VK_PPC_HI, // symbol@h
252 VK_PPC_HA, // symbol@ha
253 VK_PPC_HIGH, // symbol@high
254 VK_PPC_HIGHA, // symbol@higha
255 VK_PPC_HIGHER, // symbol@higher
256 VK_PPC_HIGHERA, // symbol@highera
257 VK_PPC_HIGHEST, // symbol@highest
258 VK_PPC_HIGHESTA, // symbol@highesta
259 VK_PPC_GOT_LO, // symbol@got@l
260 VK_PPC_GOT_HI, // symbol@got@h
261 VK_PPC_GOT_HA, // symbol@got@ha
262 VK_PPC_TOCBASE, // symbol@tocbase
263 VK_PPC_TOC, // symbol@toc
264 VK_PPC_TOC_LO, // symbol@toc@l
265 VK_PPC_TOC_HI, // symbol@toc@h
266 VK_PPC_TOC_HA, // symbol@toc@ha
267 VK_PPC_U, // symbol@u
268 VK_PPC_L, // symbol@l
269 VK_PPC_DTPMOD, // symbol@dtpmod
270 VK_PPC_TPREL_LO, // symbol@tprel@l
271 VK_PPC_TPREL_HI, // symbol@tprel@h
272 VK_PPC_TPREL_HA, // symbol@tprel@ha
273 VK_PPC_TPREL_HIGH, // symbol@tprel@high
274 VK_PPC_TPREL_HIGHA, // symbol@tprel@higha
275 VK_PPC_TPREL_HIGHER, // symbol@tprel@higher
276 VK_PPC_TPREL_HIGHERA, // symbol@tprel@highera
277 VK_PPC_TPREL_HIGHEST, // symbol@tprel@highest
278 VK_PPC_TPREL_HIGHESTA, // symbol@tprel@highesta
279 VK_PPC_DTPREL_LO, // symbol@dtprel@l
280 VK_PPC_DTPREL_HI, // symbol@dtprel@h
281 VK_PPC_DTPREL_HA, // symbol@dtprel@ha
282 VK_PPC_DTPREL_HIGH, // symbol@dtprel@high
283 VK_PPC_DTPREL_HIGHA, // symbol@dtprel@higha
284 VK_PPC_DTPREL_HIGHER, // symbol@dtprel@higher
285 VK_PPC_DTPREL_HIGHERA, // symbol@dtprel@highera
286 VK_PPC_DTPREL_HIGHEST, // symbol@dtprel@highest
287 VK_PPC_DTPREL_HIGHESTA, // symbol@dtprel@highesta
288 VK_PPC_GOT_TPREL, // symbol@got@tprel
289 VK_PPC_GOT_TPREL_LO, // symbol@got@tprel@l
290 VK_PPC_GOT_TPREL_HI, // symbol@got@tprel@h
291 VK_PPC_GOT_TPREL_HA, // symbol@got@tprel@ha
292 VK_PPC_GOT_DTPREL, // symbol@got@dtprel
293 VK_PPC_GOT_DTPREL_LO, // symbol@got@dtprel@l
294 VK_PPC_GOT_DTPREL_HI, // symbol@got@dtprel@h
295 VK_PPC_GOT_DTPREL_HA, // symbol@got@dtprel@ha
296 VK_PPC_TLS, // symbol@tls
297 VK_PPC_GOT_TLSGD, // symbol@got@tlsgd
298 VK_PPC_GOT_TLSGD_LO, // symbol@got@tlsgd@l
299 VK_PPC_GOT_TLSGD_HI, // symbol@got@tlsgd@h
300 VK_PPC_GOT_TLSGD_HA, // symbol@got@tlsgd@ha
301 VK_PPC_TLSGD, // symbol@tlsgd
302 VK_PPC_AIX_TLSGD, // symbol@gd
303 VK_PPC_AIX_TLSGDM, // symbol@m
304 VK_PPC_AIX_TLSIE, // symbol@ie
305 VK_PPC_AIX_TLSLE, // symbol@le
306 VK_PPC_AIX_TLSLD, // symbol@ld
307 VK_PPC_AIX_TLSML, // symbol@ml
308 VK_PPC_GOT_TLSLD, // symbol@got@tlsld
309 VK_PPC_GOT_TLSLD_LO, // symbol@got@tlsld@l
310 VK_PPC_GOT_TLSLD_HI, // symbol@got@tlsld@h
311 VK_PPC_GOT_TLSLD_HA, // symbol@got@tlsld@ha
312 VK_PPC_GOT_PCREL, // symbol@got@pcrel
313 VK_PPC_GOT_TLSGD_PCREL, // symbol@got@tlsgd@pcrel
314 VK_PPC_GOT_TLSLD_PCREL, // symbol@got@tlsld@pcrel
315 VK_PPC_GOT_TPREL_PCREL, // symbol@got@tprel@pcrel
316 VK_PPC_TLS_PCREL, // symbol@tls@pcrel
317 VK_PPC_TLSLD, // symbol@tlsld
318 VK_PPC_LOCAL, // symbol@local
319 VK_PPC_NOTOC, // symbol@notoc
320 VK_PPC_PCREL_OPT, // .reloc expr, R_PPC64_PCREL_OPT, expr
321
322 VK_COFF_IMGREL32, // symbol@imgrel (image-relative)
323
333
334 VK_WASM_TYPEINDEX, // Reference to a symbol's type (signature)
335 VK_WASM_TLSREL, // Memory address relative to __tls_base
336 VK_WASM_MBREL, // Memory address relative to __memory_base
337 VK_WASM_TBREL, // Table index relative to __table_base
338 VK_WASM_GOT_TLS, // Wasm global index of TLS symbol.
339 VK_WASM_FUNCINDEX, // Wasm function index.
340
341 VK_AMDGPU_GOTPCREL32_LO, // symbol@gotpcrel32@lo
342 VK_AMDGPU_GOTPCREL32_HI, // symbol@gotpcrel32@hi
343 VK_AMDGPU_REL32_LO, // symbol@rel32@lo
344 VK_AMDGPU_REL32_HI, // symbol@rel32@hi
345 VK_AMDGPU_REL64, // symbol@rel64
346 VK_AMDGPU_ABS32_LO, // symbol@abs32@lo
347 VK_AMDGPU_ABS32_HI, // symbol@abs32@hi
348
349 VK_VE_HI32, // symbol@hi
350 VK_VE_LO32, // symbol@lo
351 VK_VE_PC_HI32, // symbol@pc_hi
352 VK_VE_PC_LO32, // symbol@pc_lo
353 VK_VE_GOT_HI32, // symbol@got_hi
354 VK_VE_GOT_LO32, // symbol@got_lo
355 VK_VE_GOTOFF_HI32, // symbol@gotoff_hi
356 VK_VE_GOTOFF_LO32, // symbol@gotoff_lo
357 VK_VE_PLT_HI32, // symbol@plt_hi
358 VK_VE_PLT_LO32, // symbol@plt_lo
359 VK_VE_TLS_GD_HI32, // symbol@tls_gd_hi
360 VK_VE_TLS_GD_LO32, // symbol@tls_gd_lo
361 VK_VE_TPOFF_HI32, // symbol@tpoff_hi
362 VK_VE_TPOFF_LO32, // symbol@tpoff_lo
363
366 };
367
368private:
369 /// The symbol being referenced.
370 const MCSymbol *Symbol;
371
372 // Subclass data stores VariantKind in bits 0..15 and HasSubsectionsViaSymbols
373 // in bit 16.
374 static const unsigned VariantKindBits = 16;
375 static const unsigned VariantKindMask = (1 << VariantKindBits) - 1;
376
377 // FIXME: Remove this bit.
378 static const unsigned HasSubsectionsViaSymbolsBit = 1 << VariantKindBits;
379
380 static unsigned encodeSubclassData(VariantKind Kind,
381 bool HasSubsectionsViaSymbols) {
382 return (unsigned)Kind |
383 (HasSubsectionsViaSymbols ? HasSubsectionsViaSymbolsBit : 0);
384 }
385
386 explicit MCSymbolRefExpr(const MCSymbol *Symbol, VariantKind Kind,
387 const MCAsmInfo *MAI, SMLoc Loc = SMLoc());
388
389public:
390 /// \name Construction
391 /// @{
392
393 static const MCSymbolRefExpr *create(const MCSymbol *Symbol, MCContext &Ctx) {
394 return MCSymbolRefExpr::create(Symbol, VK_None, Ctx);
395 }
396
397 static const MCSymbolRefExpr *create(const MCSymbol *Symbol, VariantKind Kind,
398 MCContext &Ctx, SMLoc Loc = SMLoc());
399 static const MCSymbolRefExpr *create(StringRef Name, VariantKind Kind,
400 MCContext &Ctx);
401
402 /// @}
403 /// \name Accessors
404 /// @{
405
406 const MCSymbol &getSymbol() const { return *Symbol; }
407
409 return (VariantKind)(getSubclassData() & VariantKindMask);
410 }
411
413 return (getSubclassData() & HasSubsectionsViaSymbolsBit) != 0;
414 }
415
416 /// @}
417 /// \name Static Utility Functions
418 /// @{
419
421
423
424 /// @}
425
426 static bool classof(const MCExpr *E) {
427 return E->getKind() == MCExpr::SymbolRef;
428 }
429};
430
431/// Unary assembler expressions.
432class MCUnaryExpr : public MCExpr {
433public:
434 enum Opcode {
435 LNot, ///< Logical negation.
436 Minus, ///< Unary minus.
437 Not, ///< Bitwise negation.
438 Plus ///< Unary plus.
439 };
440
441private:
442 const MCExpr *Expr;
443
444 MCUnaryExpr(Opcode Op, const MCExpr *Expr, SMLoc Loc)
445 : MCExpr(MCExpr::Unary, Loc, Op), Expr(Expr) {}
446
447public:
448 /// \name Construction
449 /// @{
450
451 static const MCUnaryExpr *create(Opcode Op, const MCExpr *Expr,
452 MCContext &Ctx, SMLoc Loc = SMLoc());
453
454 static const MCUnaryExpr *createLNot(const MCExpr *Expr, MCContext &Ctx, SMLoc Loc = SMLoc()) {
455 return create(LNot, Expr, Ctx, Loc);
456 }
457
458 static const MCUnaryExpr *createMinus(const MCExpr *Expr, MCContext &Ctx, SMLoc Loc = SMLoc()) {
459 return create(Minus, Expr, Ctx, Loc);
460 }
461
462 static const MCUnaryExpr *createNot(const MCExpr *Expr, MCContext &Ctx, SMLoc Loc = SMLoc()) {
463 return create(Not, Expr, Ctx, Loc);
464 }
465
466 static const MCUnaryExpr *createPlus(const MCExpr *Expr, MCContext &Ctx, SMLoc Loc = SMLoc()) {
467 return create(Plus, Expr, Ctx, Loc);
468 }
469
470 /// @}
471 /// \name Accessors
472 /// @{
473
474 /// Get the kind of this unary expression.
475 Opcode getOpcode() const { return (Opcode)getSubclassData(); }
476
477 /// Get the child of this unary expression.
478 const MCExpr *getSubExpr() const { return Expr; }
479
480 /// @}
481
482 static bool classof(const MCExpr *E) {
483 return E->getKind() == MCExpr::Unary;
484 }
485};
486
487/// Binary assembler expressions.
488class MCBinaryExpr : public MCExpr {
489public:
490 enum Opcode {
491 Add, ///< Addition.
492 And, ///< Bitwise and.
493 Div, ///< Signed division.
494 EQ, ///< Equality comparison.
495 GT, ///< Signed greater than comparison (result is either 0 or some
496 ///< target-specific non-zero value)
497 GTE, ///< Signed greater than or equal comparison (result is either 0 or
498 ///< some target-specific non-zero value).
499 LAnd, ///< Logical and.
500 LOr, ///< Logical or.
501 LT, ///< Signed less than comparison (result is either 0 or
502 ///< some target-specific non-zero value).
503 LTE, ///< Signed less than or equal comparison (result is either 0 or
504 ///< some target-specific non-zero value).
505 Mod, ///< Signed remainder.
506 Mul, ///< Multiplication.
507 NE, ///< Inequality comparison.
508 Or, ///< Bitwise or.
509 OrNot, ///< Bitwise or not.
510 Shl, ///< Shift left.
511 AShr, ///< Arithmetic shift right.
512 LShr, ///< Logical shift right.
513 Sub, ///< Subtraction.
514 Xor ///< Bitwise exclusive or.
515 };
516
517private:
518 const MCExpr *LHS, *RHS;
519
520 MCBinaryExpr(Opcode Op, const MCExpr *LHS, const MCExpr *RHS,
521 SMLoc Loc = SMLoc())
522 : MCExpr(MCExpr::Binary, Loc, Op), LHS(LHS), RHS(RHS) {}
523
524public:
525 /// \name Construction
526 /// @{
527
528 static const MCBinaryExpr *create(Opcode Op, const MCExpr *LHS,
529 const MCExpr *RHS, MCContext &Ctx,
530 SMLoc Loc = SMLoc());
531
532 static const MCBinaryExpr *createAdd(const MCExpr *LHS, const MCExpr *RHS,
533 MCContext &Ctx) {
534 return create(Add, LHS, RHS, Ctx);
535 }
536
537 static const MCBinaryExpr *createAnd(const MCExpr *LHS, const MCExpr *RHS,
538 MCContext &Ctx) {
539 return create(And, LHS, RHS, Ctx);
540 }
541
542 static const MCBinaryExpr *createDiv(const MCExpr *LHS, const MCExpr *RHS,
543 MCContext &Ctx) {
544 return create(Div, LHS, RHS, Ctx);
545 }
546
547 static const MCBinaryExpr *createEQ(const MCExpr *LHS, const MCExpr *RHS,
548 MCContext &Ctx) {
549 return create(EQ, LHS, RHS, Ctx);
550 }
551
552 static const MCBinaryExpr *createGT(const MCExpr *LHS, const MCExpr *RHS,
553 MCContext &Ctx) {
554 return create(GT, LHS, RHS, Ctx);
555 }
556
557 static const MCBinaryExpr *createGTE(const MCExpr *LHS, const MCExpr *RHS,
558 MCContext &Ctx) {
559 return create(GTE, LHS, RHS, Ctx);
560 }
561
562 static const MCBinaryExpr *createLAnd(const MCExpr *LHS, const MCExpr *RHS,
563 MCContext &Ctx) {
564 return create(LAnd, LHS, RHS, Ctx);
565 }
566
567 static const MCBinaryExpr *createLOr(const MCExpr *LHS, const MCExpr *RHS,
568 MCContext &Ctx) {
569 return create(LOr, LHS, RHS, Ctx);
570 }
571
572 static const MCBinaryExpr *createLT(const MCExpr *LHS, const MCExpr *RHS,
573 MCContext &Ctx) {
574 return create(LT, LHS, RHS, Ctx);
575 }
576
577 static const MCBinaryExpr *createLTE(const MCExpr *LHS, const MCExpr *RHS,
578 MCContext &Ctx) {
579 return create(LTE, LHS, RHS, Ctx);
580 }
581
582 static const MCBinaryExpr *createMod(const MCExpr *LHS, const MCExpr *RHS,
583 MCContext &Ctx) {
584 return create(Mod, LHS, RHS, Ctx);
585 }
586
587 static const MCBinaryExpr *createMul(const MCExpr *LHS, const MCExpr *RHS,
588 MCContext &Ctx) {
589 return create(Mul, LHS, RHS, Ctx);
590 }
591
592 static const MCBinaryExpr *createNE(const MCExpr *LHS, const MCExpr *RHS,
593 MCContext &Ctx) {
594 return create(NE, LHS, RHS, Ctx);
595 }
596
597 static const MCBinaryExpr *createOr(const MCExpr *LHS, const MCExpr *RHS,
598 MCContext &Ctx) {
599 return create(Or, LHS, RHS, Ctx);
600 }
601
602 static const MCBinaryExpr *createShl(const MCExpr *LHS, const MCExpr *RHS,
603 MCContext &Ctx) {
604 return create(Shl, LHS, RHS, Ctx);
605 }
606
607 static const MCBinaryExpr *createAShr(const MCExpr *LHS, const MCExpr *RHS,
608 MCContext &Ctx) {
609 return create(AShr, LHS, RHS, Ctx);
610 }
611
612 static const MCBinaryExpr *createLShr(const MCExpr *LHS, const MCExpr *RHS,
613 MCContext &Ctx) {
614 return create(LShr, LHS, RHS, Ctx);
615 }
616
617 static const MCBinaryExpr *createSub(const MCExpr *LHS, const MCExpr *RHS,
618 MCContext &Ctx) {
619 return create(Sub, LHS, RHS, Ctx);
620 }
621
622 static const MCBinaryExpr *createXor(const MCExpr *LHS, const MCExpr *RHS,
623 MCContext &Ctx) {
624 return create(Xor, LHS, RHS, Ctx);
625 }
626
627 /// @}
628 /// \name Accessors
629 /// @{
630
631 /// Get the kind of this binary expression.
632 Opcode getOpcode() const { return (Opcode)getSubclassData(); }
633
634 /// Get the left-hand side expression of the binary operator.
635 const MCExpr *getLHS() const { return LHS; }
636
637 /// Get the right-hand side expression of the binary operator.
638 const MCExpr *getRHS() const { return RHS; }
639
640 /// @}
641
642 static bool classof(const MCExpr *E) {
643 return E->getKind() == MCExpr::Binary;
644 }
645};
646
647/// This is an extension point for target-specific MCExpr subclasses to
648/// implement.
649///
650/// NOTE: All subclasses are required to have trivial destructors because
651/// MCExprs are bump pointer allocated and not destructed.
652class MCTargetExpr : public MCExpr {
653 virtual void anchor();
654
655protected:
657 virtual ~MCTargetExpr() = default;
658
659public:
660 virtual void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const = 0;
661 virtual bool evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
662 const MCFixup *Fixup) const = 0;
663 // allow Target Expressions to be checked for equality
664 virtual bool isEqualTo(const MCExpr *x) const { return false; }
665 // This should be set when assigned expressions are not valid ".set"
666 // expressions, e.g. registers, and must be inlined.
667 virtual bool inlineAssignedExpr() const { return false; }
668 virtual void visitUsedExpr(MCStreamer& Streamer) const = 0;
669 virtual MCFragment *findAssociatedFragment() const = 0;
670
671 virtual void fixELFSymbolsInTLSFixups(MCAssembler &) const = 0;
672
673 static bool classof(const MCExpr *E) {
674 return E->getKind() == MCExpr::Target;
675 }
676};
677
678} // end namespace llvm
679
680#endif // LLVM_MC_MCEXPR_H
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This file defines the DenseMap class.
std::string Name
PowerPC TLS Dynamic Call Fixup
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
Value * RHS
Value * LHS
This class represents an Operation in the Expression.
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition: MCAsmInfo.h:56
Binary assembler expressions.
Definition: MCExpr.h:488
const MCExpr * getLHS() const
Get the left-hand side expression of the binary operator.
Definition: MCExpr.h:635
static const MCBinaryExpr * createEQ(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:547
static const MCBinaryExpr * createLShr(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:612
static const MCBinaryExpr * createLAnd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:562
const MCExpr * getRHS() const
Get the right-hand side expression of the binary operator.
Definition: MCExpr.h:638
static const MCBinaryExpr * createXor(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:622
static const MCBinaryExpr * createAnd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:537
static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:532
static bool classof(const MCExpr *E)
Definition: MCExpr.h:642
static const MCBinaryExpr * createLT(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:572
Opcode getOpcode() const
Get the kind of this binary expression.
Definition: MCExpr.h:632
static const MCBinaryExpr * createOr(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:597
static const MCBinaryExpr * createMod(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:582
static const MCBinaryExpr * createLOr(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:567
static const MCBinaryExpr * createNE(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:592
static const MCBinaryExpr * createGTE(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:557
static const MCBinaryExpr * createMul(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:587
static const MCBinaryExpr * createLTE(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:577
static const MCBinaryExpr * createAShr(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:607
static const MCBinaryExpr * createGT(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:552
static const MCBinaryExpr * createDiv(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:542
static const MCBinaryExpr * create(Opcode Op, const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition: MCExpr.cpp:182
static const MCBinaryExpr * createShl(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:602
static const MCBinaryExpr * createSub(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:617
@ Div
Signed division.
Definition: MCExpr.h:493
@ Shl
Shift left.
Definition: MCExpr.h:510
@ AShr
Arithmetic shift right.
Definition: MCExpr.h:511
@ LShr
Logical shift right.
Definition: MCExpr.h:512
@ GTE
Signed greater than or equal comparison (result is either 0 or some target-specific non-zero value).
Definition: MCExpr.h:497
@ EQ
Equality comparison.
Definition: MCExpr.h:494
@ Sub
Subtraction.
Definition: MCExpr.h:513
@ Mul
Multiplication.
Definition: MCExpr.h:506
@ GT
Signed greater than comparison (result is either 0 or some target-specific non-zero value)
Definition: MCExpr.h:495
@ Mod
Signed remainder.
Definition: MCExpr.h:505
@ And
Bitwise and.
Definition: MCExpr.h:492
@ Or
Bitwise or.
Definition: MCExpr.h:508
@ Xor
Bitwise exclusive or.
Definition: MCExpr.h:514
@ OrNot
Bitwise or not.
Definition: MCExpr.h:509
@ LAnd
Logical and.
Definition: MCExpr.h:499
@ LOr
Logical or.
Definition: MCExpr.h:500
@ LT
Signed less than comparison (result is either 0 or some target-specific non-zero value).
Definition: MCExpr.h:501
@ Add
Addition.
Definition: MCExpr.h:491
@ LTE
Signed less than or equal comparison (result is either 0 or some target-specific non-zero value).
Definition: MCExpr.h:503
@ NE
Inequality comparison.
Definition: MCExpr.h:507
static bool classof(const MCExpr *E)
Definition: MCExpr.h:178
bool useHexFormat() const
Definition: MCExpr.h:174
unsigned getSizeInBytes() const
Definition: MCExpr.h:170
int64_t getValue() const
Definition: MCExpr.h:169
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Definition: MCExpr.cpp:193
Context object for machine code objects.
Definition: MCContext.h:83
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:34
bool evaluateAsValue(MCValue &Res, const MCAssembler &Asm) const
Try to evaluate the expression to the form (a - b + constant) where neither a nor b are variables.
Definition: MCExpr.cpp:793
MCExpr & operator=(const MCExpr &)=delete
bool evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm, const MCFixup *Fixup, const SectionAddrMap *Addrs, bool InSet) const
Definition: MCExpr.cpp:813
MCExpr(ExprKind Kind, SMLoc Loc, unsigned SubclassData=0)
Definition: MCExpr.h:59
@ Unary
Unary expressions.
Definition: MCExpr.h:40
@ Constant
Constant expressions.
Definition: MCExpr.h:38
@ SymbolRef
References to labels and assigned expressions.
Definition: MCExpr.h:39
@ Target
Target specific expression.
Definition: MCExpr.h:41
@ Binary
Binary expressions.
Definition: MCExpr.h:37
MCExpr(const MCExpr &)=delete
bool evaluateKnownAbsolute(int64_t &Res, const MCAssembler &Asm) const
Aggressive variant of evaluateAsRelocatable when relocations are unavailable (e.g.
Definition: MCExpr.cpp:565
bool evaluateAsRelocatable(MCValue &Res, const MCAssembler *Asm, const MCFixup *Fixup) const
Try to evaluate the expression to a relocatable value, i.e.
Definition: MCExpr.cpp:788
unsigned getSubclassData() const
Definition: MCExpr.h:69
void print(raw_ostream &OS, const MCAsmInfo *MAI, bool InParens=false) const
Definition: MCExpr.cpp:40
MCFragment * findAssociatedFragment() const
Find the "associated section" for this expression, which is currently defined as the absolute section...
Definition: MCExpr.cpp:1029
void dump() const
Definition: MCExpr.cpp:174
ExprKind getKind() const
Definition: MCExpr.h:78
SMLoc getLoc() const
Definition: MCExpr.h:79
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
Definition: MCFixup.h:71
Streaming machine code generation interface.
Definition: MCStreamer.h:213
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:188
const MCSymbol & getSymbol() const
Definition: MCExpr.h:406
static bool classof(const MCExpr *E)
Definition: MCExpr.h:426
static StringRef getVariantKindName(VariantKind Kind)
Definition: MCExpr.cpp:220
static VariantKind getVariantKindForName(StringRef Name)
Definition: MCExpr.cpp:405
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:393
VariantKind getKind() const
Definition: MCExpr.h:408
bool hasSubsectionsViaSymbols() const
Definition: MCExpr.h:412
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
This is an extension point for target-specific MCExpr subclasses to implement.
Definition: MCExpr.h:652
static bool classof(const MCExpr *E)
Definition: MCExpr.h:673
virtual void visitUsedExpr(MCStreamer &Streamer) const =0
virtual void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const =0
virtual void fixELFSymbolsInTLSFixups(MCAssembler &) const =0
virtual MCFragment * findAssociatedFragment() const =0
virtual bool evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm, const MCFixup *Fixup) const =0
virtual bool isEqualTo(const MCExpr *x) const
Definition: MCExpr.h:664
virtual bool inlineAssignedExpr() const
Definition: MCExpr.h:667
virtual ~MCTargetExpr()=default
Unary assembler expressions.
Definition: MCExpr.h:432
Opcode getOpcode() const
Get the kind of this unary expression.
Definition: MCExpr.h:475
static bool classof(const MCExpr *E)
Definition: MCExpr.h:482
static const MCUnaryExpr * create(Opcode Op, const MCExpr *Expr, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition: MCExpr.cpp:188
static const MCUnaryExpr * createLNot(const MCExpr *Expr, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition: MCExpr.h:454
@ Minus
Unary minus.
Definition: MCExpr.h:436
@ Plus
Unary plus.
Definition: MCExpr.h:438
@ Not
Bitwise negation.
Definition: MCExpr.h:437
@ LNot
Logical negation.
Definition: MCExpr.h:435
const MCExpr * getSubExpr() const
Get the child of this unary expression.
Definition: MCExpr.h:478
static const MCUnaryExpr * createPlus(const MCExpr *Expr, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition: MCExpr.h:466
static const MCUnaryExpr * createNot(const MCExpr *Expr, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition: MCExpr.h:462
static const MCUnaryExpr * createMinus(const MCExpr *Expr, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition: MCExpr.h:458
This represents an "assembler immediate".
Definition: MCValue.h:36
Represents a location in source code.
Definition: SMLoc.h:23
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Target - Wrapper for Target specific information.
LLVM Value Representation.
Definition: Value.h:74
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
DWARFExpression::Operation Op
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:292