LCOV - code coverage report
Current view: top level - include/llvm/MC - MCExpr.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 23 27 85.2 %
Date: 2018-05-20 00:06:23 Functions: 0 0 -
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13