1//===- Operand.h ----------------------------------------------------------===//
2//
3//                     The MCLinker Project
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9#ifndef MCLD_SCRIPT_OPERAND_H_
10#define MCLD_SCRIPT_OPERAND_H_
11
12#include "mcld/Config/Config.h"
13#include "mcld/Object/SectionMap.h"
14#include "mcld/Script/ExprToken.h"
15#include "mcld/Support/Allocators.h"
16
17#include <llvm/Support/DataTypes.h>
18
19#include <string>
20
21#include <cassert>
22
23namespace mcld {
24
25/** \class Operand
26 *  \brief This class defines the interfaces to an operand token.
27 */
28
29class Operand : public ExprToken {
30 public:
31  enum Type { SYMBOL, INTEGER, SECTION, SECTION_DESC, FRAGMENT };
32
33 protected:
34  explicit Operand(Type pType);
35  virtual ~Operand();
36
37 public:
38  Type type() const { return m_Type; }
39
40  virtual bool isDot() const { return false; }
41
42  virtual uint64_t value() const = 0;
43
44  static bool classof(const ExprToken* pToken) {
45    return pToken->kind() == ExprToken::OPERAND;
46  }
47
48 private:
49  Type m_Type;
50};
51
52/** \class SymOperand
53 *  \brief This class defines the interfaces to a symbol operand.
54 */
55
56class SymOperand : public Operand {
57 private:
58  friend class Chunk<SymOperand, MCLD_SYMBOLS_PER_INPUT>;
59  SymOperand();
60  explicit SymOperand(const std::string& pName);
61
62 public:
63  void dump() const;
64
65  const std::string& name() const { return m_Name; }
66
67  bool isDot() const;
68
69  uint64_t value() const { return m_Value; }
70
71  void setValue(uint64_t pValue) { m_Value = pValue; }
72
73  static bool classof(const Operand* pOperand) {
74    return pOperand->type() == Operand::SYMBOL;
75  }
76
77  /* factory method */
78  static SymOperand* create(const std::string& pName);
79  static void destroy(SymOperand*& pOperand);
80  static void clear();
81
82 private:
83  std::string m_Name;
84  uint64_t m_Value;
85};
86
87/** \class IntOperand
88 *  \brief This class defines the interfaces to an integer operand.
89 */
90
91class IntOperand : public Operand {
92 private:
93  friend class Chunk<IntOperand, MCLD_SYMBOLS_PER_INPUT>;
94  IntOperand();
95  explicit IntOperand(uint64_t pValue);
96
97 public:
98  void dump() const;
99
100  uint64_t value() const { return m_Value; }
101
102  void setValue(uint64_t pValue) { m_Value = pValue; }
103
104  static bool classof(const Operand* pOperand) {
105    return pOperand->type() == Operand::INTEGER;
106  }
107
108  /* factory method */
109  static IntOperand* create(uint64_t pValue);
110  static void destroy(IntOperand*& pOperand);
111  static void clear();
112
113 private:
114  uint64_t m_Value;
115};
116
117/** \class SectOperand
118 *  \brief This class defines the interfaces to an section name operand.
119 */
120class LDSection;
121
122class SectOperand : public Operand {
123 private:
124  friend class Chunk<SectOperand, MCLD_SECTIONS_PER_INPUT>;
125  SectOperand();
126  explicit SectOperand(const std::string& pName);
127
128 public:
129  void dump() const;
130
131  const std::string& name() const { return m_Name; }
132
133  uint64_t value() const {
134    assert(0);
135    return 0;
136  }
137
138  static bool classof(const Operand* pOperand) {
139    return pOperand->type() == Operand::SECTION;
140  }
141
142  /* factory method */
143  static SectOperand* create(const std::string& pName);
144  static void destroy(SectOperand*& pOperand);
145  static void clear();
146
147 private:
148  std::string m_Name;
149};
150
151/** \class SectDescOperand
152 *  \brief This class defines the interfaces to an section name operand.
153 */
154
155class SectDescOperand : public Operand {
156 private:
157  friend class Chunk<SectDescOperand, MCLD_SECTIONS_PER_INPUT>;
158  SectDescOperand();
159  explicit SectDescOperand(const SectionMap::Output* pOutputDesc);
160
161 public:
162  void dump() const;
163
164  const SectionMap::Output* outputDesc() const { return m_pOutputDesc; }
165
166  uint64_t value() const {
167    assert(0);
168    return 0;
169  }
170
171  static bool classof(const Operand* pOperand) {
172    return pOperand->type() == Operand::SECTION_DESC;
173  }
174
175  /* factory method */
176  static SectDescOperand* create(const SectionMap::Output* pOutputDesc);
177  static void destroy(SectDescOperand*& pOperand);
178  static void clear();
179
180 private:
181  const SectionMap::Output* m_pOutputDesc;
182};
183
184/** \class FragOperand
185 *  \brief This class defines the interfaces to a fragment operand.
186 */
187
188class Fragment;
189
190class FragOperand : public Operand {
191 private:
192  friend class Chunk<FragOperand, MCLD_SYMBOLS_PER_INPUT>;
193  FragOperand();
194  explicit FragOperand(Fragment& pFragment);
195
196 public:
197  void dump() const;
198
199  const Fragment* frag() const { return m_pFragment; }
200  Fragment* frag() { return m_pFragment; }
201
202  uint64_t value() const;
203
204  static bool classof(const Operand* pOperand) {
205    return pOperand->type() == Operand::FRAGMENT;
206  }
207
208  /* factory method */
209  static FragOperand* create(Fragment& pFragment);
210  static void destroy(FragOperand*& pOperand);
211  static void clear();
212
213 private:
214  Fragment* m_pFragment;
215};
216
217}  // namespace mcld
218
219#endif  // MCLD_SCRIPT_OPERAND_H_
220