1 //===- llvm/MC/MCParsedAsmOperand.h - Asm Parser Operand --------*- 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_MCPARSER_MCPARSEDASMOPERAND_H 10 #define LLVM_MC_MCPARSER_MCPARSEDASMOPERAND_H 11 12 #include "llvm/ADT/StringRef.h" 13 #include "llvm/Support/SMLoc.h" 14 #include <string> 15 16 namespace llvm { 17 18 class MCRegister; 19 class raw_ostream; 20 21 /// MCParsedAsmOperand - This abstract class represents a source-level assembly 22 /// instruction operand. It should be subclassed by target-specific code. This 23 /// base class is used by target-independent clients and is the interface 24 /// between parsing an asm instruction and recognizing it. 25 class MCParsedAsmOperand { 26 /// MCOperandNum - The corresponding MCInst operand number. Only valid when 27 /// parsing MS-style inline assembly. 28 unsigned MCOperandNum = ~0u; 29 30 /// Constraint - The constraint on this operand. Only valid when parsing 31 /// MS-style inline assembly. 32 std::string Constraint; 33 34 protected: 35 // This only seems to need to be movable (by ARMOperand) but ARMOperand has 36 // lots of members and MSVC doesn't support defaulted move ops, so to avoid 37 // that verbosity, just rely on defaulted copy ops. It's only the Constraint 38 // string member that would benefit from movement anyway. 39 MCParsedAsmOperand() = default; 40 MCParsedAsmOperand(const MCParsedAsmOperand &RHS) = default; 41 MCParsedAsmOperand &operator=(const MCParsedAsmOperand &) = default; 42 43 public: 44 virtual ~MCParsedAsmOperand() = default; 45 setConstraint(StringRef C)46 void setConstraint(StringRef C) { Constraint = C.str(); } getConstraint()47 StringRef getConstraint() { return Constraint; } 48 setMCOperandNum(unsigned OpNum)49 void setMCOperandNum (unsigned OpNum) { MCOperandNum = OpNum; } getMCOperandNum()50 unsigned getMCOperandNum() { return MCOperandNum; } 51 getSymName()52 virtual StringRef getSymName() { return StringRef(); } getOpDecl()53 virtual void *getOpDecl() { return nullptr; } 54 55 /// isToken - Is this a token operand? 56 virtual bool isToken() const = 0; 57 /// isImm - Is this an immediate operand? 58 virtual bool isImm() const = 0; 59 /// isReg - Is this a register operand? 60 virtual bool isReg() const = 0; 61 virtual MCRegister getReg() const = 0; 62 63 /// isMem - Is this a memory operand? 64 virtual bool isMem() const = 0; 65 66 /// isMemUseUpRegs - Is memory operand use up regs, for example, intel MS 67 /// inline asm may use ARR[baseReg + IndexReg + ...] which may use up regs 68 /// in [...] expr, so ARR[baseReg + IndexReg + ...] can not use extra reg 69 /// for ARR. For example, calculating ARR address to a reg or use another 70 /// base reg in PIC model. isMemUseUpRegs()71 virtual bool isMemUseUpRegs() const { return false; } 72 73 /// getStartLoc - Get the location of the first token of this operand. 74 virtual SMLoc getStartLoc() const = 0; 75 /// getEndLoc - Get the location of the last token of this operand. 76 virtual SMLoc getEndLoc() const = 0; 77 78 /// needAddressOf - Do we need to emit code to get the address of the 79 /// variable/label? Only valid when parsing MS-style inline assembly. needAddressOf()80 virtual bool needAddressOf() const { return false; } 81 82 /// isOffsetOfLocal - Do we need to emit code to get the offset of the local 83 /// variable, rather than its value? Only valid when parsing MS-style inline 84 /// assembly. isOffsetOfLocal()85 virtual bool isOffsetOfLocal() const { return false; } 86 87 /// getOffsetOfLoc - Get the location of the offset operator. getOffsetOfLoc()88 virtual SMLoc getOffsetOfLoc() const { return SMLoc(); } 89 90 /// print - Print a debug representation of the operand to the given stream. 91 virtual void print(raw_ostream &OS) const = 0; 92 93 /// dump - Print to the debug stream. 94 virtual void dump() const; 95 }; 96 97 //===----------------------------------------------------------------------===// 98 // Debugging Support 99 100 inline raw_ostream& operator<<(raw_ostream &OS, const MCParsedAsmOperand &MO) { 101 MO.print(OS); 102 return OS; 103 } 104 105 } // end namespace llvm 106 107 #endif // LLVM_MC_MCPARSER_MCPARSEDASMOPERAND_H 108