LCOV - code coverage report
Current view: top level - include/llvm/MC - MCExpr.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 23 28 82.1 %
Date: 2018-07-13 00:08:38 Functions: 0 1 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    10209117 :   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       11688 :   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     5612176 :       : 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     7984865 :     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_HIGH,           // symbol@high
     222             :     VK_PPC_HIGHA,          // symbol@higha
     223             :     VK_PPC_HIGHER,         // symbol@higher
     224             :     VK_PPC_HIGHERA,        // symbol@highera
     225             :     VK_PPC_HIGHEST,        // symbol@highest
     226             :     VK_PPC_HIGHESTA,       // symbol@highesta
     227             :     VK_PPC_GOT_LO,         // symbol@got@l
     228             :     VK_PPC_GOT_HI,         // symbol@got@h
     229             :     VK_PPC_GOT_HA,         // symbol@got@ha
     230             :     VK_PPC_TOCBASE,        // symbol@tocbase
     231             :     VK_PPC_TOC,            // symbol@toc
     232             :     VK_PPC_TOC_LO,         // symbol@toc@l
     233             :     VK_PPC_TOC_HI,         // symbol@toc@h
     234             :     VK_PPC_TOC_HA,         // symbol@toc@ha
     235             :     VK_PPC_DTPMOD,         // symbol@dtpmod
     236             :     VK_PPC_TPREL_LO,       // symbol@tprel@l
     237             :     VK_PPC_TPREL_HI,       // symbol@tprel@h
     238             :     VK_PPC_TPREL_HA,       // symbol@tprel@ha
     239             :     VK_PPC_TPREL_HIGH,     // symbol@tprel@high
     240             :     VK_PPC_TPREL_HIGHA,    // symbol@tprel@higha
     241             :     VK_PPC_TPREL_HIGHER,   // symbol@tprel@higher
     242             :     VK_PPC_TPREL_HIGHERA,  // symbol@tprel@highera
     243             :     VK_PPC_TPREL_HIGHEST,  // symbol@tprel@highest
     244             :     VK_PPC_TPREL_HIGHESTA, // symbol@tprel@highesta
     245             :     VK_PPC_DTPREL_LO,      // symbol@dtprel@l
     246             :     VK_PPC_DTPREL_HI,      // symbol@dtprel@h
     247             :     VK_PPC_DTPREL_HA,      // symbol@dtprel@ha
     248             :     VK_PPC_DTPREL_HIGH,    // symbol@dtprel@high
     249             :     VK_PPC_DTPREL_HIGHA,   // symbol@dtprel@higha
     250             :     VK_PPC_DTPREL_HIGHER,  // symbol@dtprel@higher
     251             :     VK_PPC_DTPREL_HIGHERA, // symbol@dtprel@highera
     252             :     VK_PPC_DTPREL_HIGHEST, // symbol@dtprel@highest
     253             :     VK_PPC_DTPREL_HIGHESTA,// symbol@dtprel@highesta
     254             :     VK_PPC_GOT_TPREL,      // symbol@got@tprel
     255             :     VK_PPC_GOT_TPREL_LO,   // symbol@got@tprel@l
     256             :     VK_PPC_GOT_TPREL_HI,   // symbol@got@tprel@h
     257             :     VK_PPC_GOT_TPREL_HA,   // symbol@got@tprel@ha
     258             :     VK_PPC_GOT_DTPREL,     // symbol@got@dtprel
     259             :     VK_PPC_GOT_DTPREL_LO,  // symbol@got@dtprel@l
     260             :     VK_PPC_GOT_DTPREL_HI,  // symbol@got@dtprel@h
     261             :     VK_PPC_GOT_DTPREL_HA,  // symbol@got@dtprel@ha
     262             :     VK_PPC_TLS,            // symbol@tls
     263             :     VK_PPC_GOT_TLSGD,      // symbol@got@tlsgd
     264             :     VK_PPC_GOT_TLSGD_LO,   // symbol@got@tlsgd@l
     265             :     VK_PPC_GOT_TLSGD_HI,   // symbol@got@tlsgd@h
     266             :     VK_PPC_GOT_TLSGD_HA,   // symbol@got@tlsgd@ha
     267             :     VK_PPC_TLSGD,          // symbol@tlsgd
     268             :     VK_PPC_GOT_TLSLD,      // symbol@got@tlsld
     269             :     VK_PPC_GOT_TLSLD_LO,   // symbol@got@tlsld@l
     270             :     VK_PPC_GOT_TLSLD_HI,   // symbol@got@tlsld@h
     271             :     VK_PPC_GOT_TLSLD_HA,   // symbol@got@tlsld@ha
     272             :     VK_PPC_TLSLD,          // symbol@tlsld
     273             :     VK_PPC_LOCAL,          // symbol@local
     274             : 
     275             :     VK_COFF_IMGREL32, // symbol@imgrel (image-relative)
     276             : 
     277             :     VK_Hexagon_PCREL,
     278             :     VK_Hexagon_LO16,
     279             :     VK_Hexagon_HI16,
     280             :     VK_Hexagon_GPREL,
     281             :     VK_Hexagon_GD_GOT,
     282             :     VK_Hexagon_LD_GOT,
     283             :     VK_Hexagon_GD_PLT,
     284             :     VK_Hexagon_LD_PLT,
     285             :     VK_Hexagon_IE,
     286             :     VK_Hexagon_IE_GOT,
     287             : 
     288             :     VK_WebAssembly_FUNCTION, // Function table index, rather than virtual addr
     289             :     VK_WebAssembly_TYPEINDEX,// Type table index
     290             : 
     291             :     VK_AMDGPU_GOTPCREL32_LO, // symbol@gotpcrel32@lo
     292             :     VK_AMDGPU_GOTPCREL32_HI, // symbol@gotpcrel32@hi
     293             :     VK_AMDGPU_REL32_LO,      // symbol@rel32@lo
     294             :     VK_AMDGPU_REL32_HI,      // symbol@rel32@hi
     295             :     VK_AMDGPU_REL64,         // symbol@rel64
     296             : 
     297             :     VK_TPREL,
     298             :     VK_DTPREL
     299             :   };
     300             : 
     301             : private:
     302             :   /// The symbol reference modifier.
     303             :   const VariantKind Kind;
     304             : 
     305             :   /// Specifies how the variant kind should be printed.
     306             :   const unsigned UseParensForSymbolVariant : 1;
     307             : 
     308             :   // FIXME: Remove this bit.
     309             :   const unsigned HasSubsectionsViaSymbols : 1;
     310             : 
     311             :   /// The symbol being referenced.
     312             :   const MCSymbol *Symbol;
     313             : 
     314             :   explicit MCSymbolRefExpr(const MCSymbol *Symbol, VariantKind Kind,
     315             :                            const MCAsmInfo *MAI, SMLoc Loc = SMLoc());
     316             : 
     317             : public:
     318             :   /// \name Construction
     319             :   /// @{
     320             : 
     321             :   static const MCSymbolRefExpr *create(const MCSymbol *Symbol, MCContext &Ctx) {
     322     2037864 :     return MCSymbolRefExpr::create(Symbol, VK_None, Ctx);
     323             :   }
     324             : 
     325             :   static const MCSymbolRefExpr *create(const MCSymbol *Symbol, VariantKind Kind,
     326             :                                        MCContext &Ctx, SMLoc Loc = SMLoc());
     327             :   static const MCSymbolRefExpr *create(StringRef Name, VariantKind Kind,
     328             :                                        MCContext &Ctx);
     329             : 
     330             :   /// @}
     331             :   /// \name Accessors
     332             :   /// @{
     333             : 
     334             :   const MCSymbol &getSymbol() const { return *Symbol; }
     335             : 
     336             :   VariantKind getKind() const { return Kind; }
     337             : 
     338             :   void printVariantKind(raw_ostream &OS) const;
     339             : 
     340       13912 :   bool hasSubsectionsViaSymbols() const { return HasSubsectionsViaSymbols; }
     341             : 
     342             :   /// @}
     343             :   /// \name Static Utility Functions
     344             :   /// @{
     345             : 
     346             :   static StringRef getVariantKindName(VariantKind Kind);
     347             : 
     348             :   static VariantKind getVariantKindForName(StringRef Name);
     349             : 
     350             :   /// @}
     351             : 
     352             :   static bool classof(const MCExpr *E) {
     353      203918 :     return E->getKind() == MCExpr::SymbolRef;
     354             :   }
     355             : };
     356             : 
     357             : /// Unary assembler expressions.
     358             : class MCUnaryExpr : public MCExpr {
     359             : public:
     360             :   enum Opcode {
     361             :     LNot,  ///< Logical negation.
     362             :     Minus, ///< Unary minus.
     363             :     Not,   ///< Bitwise negation.
     364             :     Plus   ///< Unary plus.
     365             :   };
     366             : 
     367             : private:
     368             :   Opcode Op;
     369             :   const MCExpr *Expr;
     370             : 
     371             :   MCUnaryExpr(Opcode Op, const MCExpr *Expr, SMLoc Loc)
     372       39080 :       : MCExpr(MCExpr::Unary, Loc), Op(Op), Expr(Expr) {}
     373             : 
     374             : public:
     375             :   /// \name Construction
     376             :   /// @{
     377             : 
     378             :   static const MCUnaryExpr *create(Opcode Op, const MCExpr *Expr,
     379             :                                    MCContext &Ctx, SMLoc Loc = SMLoc());
     380             : 
     381             :   static const MCUnaryExpr *createLNot(const MCExpr *Expr, MCContext &Ctx, SMLoc Loc = SMLoc()) {
     382           4 :     return create(LNot, Expr, Ctx, Loc);
     383             :   }
     384             : 
     385             :   static const MCUnaryExpr *createMinus(const MCExpr *Expr, MCContext &Ctx, SMLoc Loc = SMLoc()) {
     386       19355 :     return create(Minus, Expr, Ctx, Loc);
     387             :   }
     388             : 
     389             :   static const MCUnaryExpr *createNot(const MCExpr *Expr, MCContext &Ctx, SMLoc Loc = SMLoc()) {
     390         148 :     return create(Not, Expr, Ctx, Loc);
     391             :   }
     392             : 
     393             :   static const MCUnaryExpr *createPlus(const MCExpr *Expr, MCContext &Ctx, SMLoc Loc = SMLoc()) {
     394          29 :     return create(Plus, Expr, Ctx, Loc);
     395             :   }
     396             : 
     397             :   /// @}
     398             :   /// \name Accessors
     399             :   /// @{
     400             : 
     401             :   /// Get the kind of this unary expression.
     402             :   Opcode getOpcode() const { return Op; }
     403             : 
     404             :   /// Get the child of this unary expression.
     405             :   const MCExpr *getSubExpr() const { return Expr; }
     406             : 
     407             :   /// @}
     408             : 
     409             :   static bool classof(const MCExpr *E) {
     410           6 :     return E->getKind() == MCExpr::Unary;
     411             :   }
     412             : };
     413             : 
     414             : /// Binary assembler expressions.
     415             : class MCBinaryExpr : public MCExpr {
     416             : public:
     417             :   enum Opcode {
     418             :     Add,  ///< Addition.
     419             :     And,  ///< Bitwise and.
     420             :     Div,  ///< Signed division.
     421             :     EQ,   ///< Equality comparison.
     422             :     GT,   ///< Signed greater than comparison (result is either 0 or some
     423             :           ///< target-specific non-zero value)
     424             :     GTE,  ///< Signed greater than or equal comparison (result is either 0 or
     425             :           ///< some target-specific non-zero value).
     426             :     LAnd, ///< Logical and.
     427             :     LOr,  ///< Logical or.
     428             :     LT,   ///< Signed less than comparison (result is either 0 or
     429             :           ///< some target-specific non-zero value).
     430             :     LTE,  ///< Signed less than or equal comparison (result is either 0 or
     431             :           ///< some target-specific non-zero value).
     432             :     Mod,  ///< Signed remainder.
     433             :     Mul,  ///< Multiplication.
     434             :     NE,   ///< Inequality comparison.
     435             :     Or,   ///< Bitwise or.
     436             :     Shl,  ///< Shift left.
     437             :     AShr, ///< Arithmetic shift right.
     438             :     LShr, ///< Logical shift right.
     439             :     Sub,  ///< Subtraction.
     440             :     Xor   ///< Bitwise exclusive or.
     441             :   };
     442             : 
     443             : private:
     444             :   Opcode Op;
     445             :   const MCExpr *LHS, *RHS;
     446             : 
     447             :   MCBinaryExpr(Opcode Op, const MCExpr *LHS, const MCExpr *RHS,
     448             :                SMLoc Loc = SMLoc())
     449     4566474 :       : MCExpr(MCExpr::Binary, Loc), Op(Op), LHS(LHS), RHS(RHS) {}
     450             : 
     451             : public:
     452             :   /// \name Construction
     453             :   /// @{
     454             : 
     455             :   static const MCBinaryExpr *create(Opcode Op, const MCExpr *LHS,
     456             :                                     const MCExpr *RHS, MCContext &Ctx,
     457             :                                     SMLoc Loc = SMLoc());
     458             : 
     459             :   static const MCBinaryExpr *createAdd(const MCExpr *LHS, const MCExpr *RHS,
     460             :                                        MCContext &Ctx) {
     461      813547 :     return create(Add, LHS, RHS, Ctx);
     462             :   }
     463             : 
     464             :   static const MCBinaryExpr *createAnd(const MCExpr *LHS, const MCExpr *RHS,
     465             :                                        MCContext &Ctx) {
     466          12 :     return create(And, LHS, RHS, Ctx);
     467             :   }
     468             : 
     469             :   static const MCBinaryExpr *createDiv(const MCExpr *LHS, const MCExpr *RHS,
     470             :                                        MCContext &Ctx) {
     471         388 :     return create(Div, LHS, RHS, Ctx);
     472             :   }
     473             : 
     474             :   static const MCBinaryExpr *createEQ(const MCExpr *LHS, const MCExpr *RHS,
     475             :                                       MCContext &Ctx) {
     476             :     return create(EQ, LHS, RHS, Ctx);
     477             :   }
     478             : 
     479             :   static const MCBinaryExpr *createGT(const MCExpr *LHS, const MCExpr *RHS,
     480             :                                       MCContext &Ctx) {
     481             :     return create(GT, LHS, RHS, Ctx);
     482             :   }
     483             : 
     484             :   static const MCBinaryExpr *createGTE(const MCExpr *LHS, const MCExpr *RHS,
     485             :                                        MCContext &Ctx) {
     486             :     return create(GTE, LHS, RHS, Ctx);
     487             :   }
     488             : 
     489             :   static const MCBinaryExpr *createLAnd(const MCExpr *LHS, const MCExpr *RHS,
     490             :                                         MCContext &Ctx) {
     491             :     return create(LAnd, LHS, RHS, Ctx);
     492             :   }
     493             : 
     494             :   static const MCBinaryExpr *createLOr(const MCExpr *LHS, const MCExpr *RHS,
     495             :                                        MCContext &Ctx) {
     496             :     return create(LOr, LHS, RHS, Ctx);
     497             :   }
     498             : 
     499             :   static const MCBinaryExpr *createLT(const MCExpr *LHS, const MCExpr *RHS,
     500             :                                       MCContext &Ctx) {
     501             :     return create(LT, LHS, RHS, Ctx);
     502             :   }
     503             : 
     504             :   static const MCBinaryExpr *createLTE(const MCExpr *LHS, const MCExpr *RHS,
     505             :                                        MCContext &Ctx) {
     506             :     return create(LTE, LHS, RHS, Ctx);
     507             :   }
     508             : 
     509             :   static const MCBinaryExpr *createMod(const MCExpr *LHS, const MCExpr *RHS,
     510             :                                        MCContext &Ctx) {
     511           0 :     return create(Mod, LHS, RHS, Ctx);
     512             :   }
     513             : 
     514             :   static const MCBinaryExpr *createMul(const MCExpr *LHS, const MCExpr *RHS,
     515             :                                        MCContext &Ctx) {
     516           1 :     return create(Mul, LHS, RHS, Ctx);
     517             :   }
     518             : 
     519             :   static const MCBinaryExpr *createNE(const MCExpr *LHS, const MCExpr *RHS,
     520             :                                       MCContext &Ctx) {
     521             :     return create(NE, LHS, RHS, Ctx);
     522             :   }
     523             : 
     524             :   static const MCBinaryExpr *createOr(const MCExpr *LHS, const MCExpr *RHS,
     525             :                                       MCContext &Ctx) {
     526           0 :     return create(Or, LHS, RHS, Ctx);
     527             :   }
     528             : 
     529             :   static const MCBinaryExpr *createShl(const MCExpr *LHS, const MCExpr *RHS,
     530             :                                        MCContext &Ctx) {
     531           0 :     return create(Shl, LHS, RHS, Ctx);
     532             :   }
     533             : 
     534             :   static const MCBinaryExpr *createAShr(const MCExpr *LHS, const MCExpr *RHS,
     535             :                                        MCContext &Ctx) {
     536             :     return create(AShr, LHS, RHS, Ctx);
     537             :   }
     538             : 
     539             :   static const MCBinaryExpr *createLShr(const MCExpr *LHS, const MCExpr *RHS,
     540             :                                        MCContext &Ctx) {
     541           5 :     return create(LShr, LHS, RHS, Ctx);
     542             :   }
     543             : 
     544             :   static const MCBinaryExpr *createSub(const MCExpr *LHS, const MCExpr *RHS,
     545             :                                        MCContext &Ctx) {
     546      334361 :     return create(Sub, LHS, RHS, Ctx);
     547             :   }
     548             : 
     549             :   static const MCBinaryExpr *createXor(const MCExpr *LHS, const MCExpr *RHS,
     550             :                                        MCContext &Ctx) {
     551           0 :     return create(Xor, LHS, RHS, Ctx);
     552             :   }
     553             : 
     554             :   /// @}
     555             :   /// \name Accessors
     556             :   /// @{
     557             : 
     558             :   /// Get the kind of this binary expression.
     559             :   Opcode getOpcode() const { return Op; }
     560             : 
     561             :   /// Get the left-hand side expression of the binary operator.
     562             :   const MCExpr *getLHS() const { return LHS; }
     563             : 
     564             :   /// Get the right-hand side expression of the binary operator.
     565             :   const MCExpr *getRHS() const { return RHS; }
     566             : 
     567             :   /// @}
     568             : 
     569             :   static bool classof(const MCExpr *E) {
     570       13352 :     return E->getKind() == MCExpr::Binary;
     571             :   }
     572             : };
     573             : 
     574             : /// This is an extension point for target-specific MCExpr subclasses to
     575             : /// implement.
     576             : ///
     577             : /// NOTE: All subclasses are required to have trivial destructors because
     578             : /// MCExprs are bump pointer allocated and not destructed.
     579             : class MCTargetExpr : public MCExpr {
     580             :   virtual void anchor();
     581             : 
     582             : protected:
     583       85681 :   MCTargetExpr() : MCExpr(Target, SMLoc()) {}
     584             :   virtual ~MCTargetExpr() = default;
     585             : 
     586             : public:
     587             :   virtual void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const = 0;
     588             :   virtual bool evaluateAsRelocatableImpl(MCValue &Res,
     589             :                                          const MCAsmLayout *Layout,
     590             :                                          const MCFixup *Fixup) const = 0;
     591             :   // This should be set when assigned expressions are not valid ".set"
     592             :   // expressions, e.g. registers, and must be inlined.
     593           0 :   virtual bool inlineAssignedExpr() const { return false; }
     594             :   virtual void visitUsedExpr(MCStreamer& Streamer) const = 0;
     595             :   virtual MCFragment *findAssociatedFragment() const = 0;
     596             : 
     597             :   virtual void fixELFSymbolsInTLSFixups(MCAssembler &) const = 0;
     598             : 
     599             :   static bool classof(const MCExpr *E) {
     600        4307 :     return E->getKind() == MCExpr::Target;
     601             :   }
     602             : };
     603             : 
     604             : } // end namespace llvm
     605             : 
     606             : #endif // LLVM_MC_MCEXPR_H

Generated by: LCOV version 1.13