• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===-EDToken.h - LLVM Enhanced Disassembler --------------------*- 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 // This file defines the interface for the Enhanced Disassembly library's token
11 // class.  The token is responsible for vending information about the token,
12 // such as its type and logical value.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_EDTOKEN_H
17 #define LLVM_EDTOKEN_H
18 
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/Support/DataTypes.h"
21 #include <string>
22 #include <vector>
23 
24 namespace llvm {
25 
26 struct EDDisassembler;
27 
28 /// EDToken - Encapsulates a single token, which can provide a string
29 ///   representation of itself or interpret itself in various ways, depending
30 ///   on the token type.
31 struct EDToken {
32   enum tokenType {
33     kTokenWhitespace,
34     kTokenOpcode,
35     kTokenLiteral,
36     kTokenRegister,
37     kTokenPunctuation
38   };
39 
40   /// The parent disassembler
41   EDDisassembler &Disassembler;
42 
43   /// The token's string representation
44   llvm::StringRef Str;
45   /// The token's string representation, but in a form suitable for export
46   std::string PermStr;
47   /// The type of the token, as exposed through the external API
48   enum tokenType Type;
49   /// The type of the token, as recorded by the syntax-specific tokenizer
50   uint64_t LocalType;
51   /// The operand corresponding to the token, or (unsigned int)-1 if not
52   ///   part of an operand.
53   int OperandID;
54 
55   /// The sign if the token is a literal (1 if negative, 0 otherwise)
56   bool LiteralSign;
57   /// The absolute value if the token is a literal
58   uint64_t LiteralAbsoluteValue;
59   /// The LLVM register ID if the token is a register name
60   unsigned RegisterID;
61 
62   /// Constructor - Initializes an EDToken with the information common to all
63   ///   tokens
64   ///
65   /// @arg str          - The string corresponding to the token
66   /// @arg type         - The token's type as exposed through the public API
67   /// @arg localType    - The token's type as recorded by the tokenizer
68   /// @arg disassembler - The disassembler responsible for the token
69   EDToken(llvm::StringRef str,
70           enum tokenType type,
71           uint64_t localType,
72           EDDisassembler &disassembler);
73 
74   /// makeLiteral - Adds the information specific to a literal
75   /// @arg sign           - The sign of the literal (1 if negative, 0
76   ///                       otherwise)
77   ///
78   /// @arg absoluteValue  - The absolute value of the literal
79   void makeLiteral(bool sign, uint64_t absoluteValue);
80   /// makeRegister - Adds the information specific to a register
81   ///
82   /// @arg registerID - The LLVM register ID
83   void makeRegister(unsigned registerID);
84 
85   /// setOperandID - Links the token to a numbered operand
86   ///
87   /// @arg operandID  - The operand ID to link to
88   void setOperandID(int operandID);
89 
90   ~EDToken();
91 
92   /// type - Returns the public type of the token
93   enum tokenType type() const;
94   /// localType - Returns the tokenizer-specific type of the token
95   uint64_t localType() const;
96   /// string - Returns the string representation of the token
97   llvm::StringRef string() const;
98   /// operandID - Returns the operand ID of the token
99   int operandID() const;
100 
101   /// literalSign - Returns the sign of the token
102   ///   (1 if negative, 0 if positive or unsigned, -1 if it is not a literal)
103   int literalSign() const;
104   /// literalAbsoluteValue - Retrieves the absolute value of the token, and
105   ///   returns -1 if the token is not a literal
106   /// @arg value  - A reference to a value that is filled in with the absolute
107   ///               value, if it is valid
108   int literalAbsoluteValue(uint64_t &value) const;
109   /// registerID - Retrieves the register ID of the token, and returns -1 if the
110   ///   token is not a register
111   ///
112   /// @arg registerID - A reference to a value that is filled in with the
113   ///                   register ID, if it is valid
114   int registerID(unsigned &registerID) const;
115 
116   /// tokenize - Tokenizes a string using the platform- and syntax-specific
117   ///   tokenizer, and returns 0 on success (-1 on failure)
118   ///
119   /// @arg tokens       - A vector that will be filled in with pointers to
120   ///                     allocated tokens
121   /// @arg str          - The string, as outputted by the AsmPrinter
122   /// @arg operandOrder - The order of the operands from the operandFlags array
123   ///                     as they appear in str
124   /// @arg disassembler - The disassembler for the desired target and
125   //                      assembly syntax
126   static int tokenize(std::vector<EDToken*> &tokens,
127                       std::string &str,
128                       const signed char *operandOrder,
129                       EDDisassembler &disassembler);
130 
131   /// getString - Directs a character pointer to the string, returning 0 on
132   ///   success (-1 on failure)
133   /// @arg buf  - A reference to a pointer that is set to point to the string.
134   ///   The string is still owned by the token.
135   int getString(const char*& buf);
136 };
137 
138 } // end namespace llvm
139 #endif
140