Operand.cpp revision 37b74a387bb3993387029859c2d9d051c41c724e 
1//===- Operand.cpp --------------------------------------------------------===//
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#include "mcld/Script/Operand.h"
10
11#include "mcld/Fragment/Fragment.h"
12#include "mcld/LD/LDSection.h"
13#include "mcld/LD/SectionData.h"
14#include "mcld/Support/GCFactory.h"
15#include "mcld/Support/raw_ostream.h"
16
17#include <llvm/Support/ManagedStatic.h>
18
19namespace mcld {
20
21//===----------------------------------------------------------------------===//
22// Operand
23//===----------------------------------------------------------------------===//
24Operand::Operand(Type pType) : ExprToken(ExprToken::OPERAND), m_Type(pType) {
25}
26
27Operand::~Operand() {
28}
29
30//===----------------------------------------------------------------------===//
31// SymOperand
32//===----------------------------------------------------------------------===//
33typedef GCFactory<SymOperand, MCLD_SYMBOLS_PER_INPUT> SymOperandFactory;
34static llvm::ManagedStatic<SymOperandFactory> g_SymOperandFactory;
35
36SymOperand::SymOperand() : Operand(Operand::SYMBOL), m_Value(0) {
37}
38
39SymOperand::SymOperand(const std::string& pName)
40    : Operand(Operand::SYMBOL), m_Name(pName), m_Value(0) {
41}
42
43void SymOperand::dump() const {
44  mcld::outs() << m_Name;
45}
46
47bool SymOperand::isDot() const {
48  assert(!m_Name.empty());
49  return m_Name.size() == 1 && m_Name[0] == '.';
50}
51
52SymOperand* SymOperand::create(const std::string& pName) {
53  SymOperand* result = g_SymOperandFactory->allocate();
54  new (result) SymOperand(pName);
55  return result;
56}
57
58void SymOperand::destroy(SymOperand*& pOperand) {
59  g_SymOperandFactory->destroy(pOperand);
60  g_SymOperandFactory->deallocate(pOperand);
61  pOperand = NULL;
62}
63
64void SymOperand::clear() {
65  g_SymOperandFactory->clear();
66}
67
68//===----------------------------------------------------------------------===//
69// IntOperand
70//===----------------------------------------------------------------------===//
71typedef GCFactory<IntOperand, MCLD_SYMBOLS_PER_INPUT> IntOperandFactory;
72static llvm::ManagedStatic<IntOperandFactory> g_IntOperandFactory;
73
74IntOperand::IntOperand() : Operand(Operand::INTEGER), m_Value(0) {
75}
76
77IntOperand::IntOperand(uint64_t pValue)
78    : Operand(Operand::INTEGER), m_Value(pValue) {
79}
80
81void IntOperand::dump() const {
82  mcld::outs() << m_Value;
83}
84
85IntOperand* IntOperand::create(uint64_t pValue) {
86  IntOperand* result = g_IntOperandFactory->allocate();
87  new (result) IntOperand(pValue);
88  return result;
89}
90
91void IntOperand::destroy(IntOperand*& pOperand) {
92  g_IntOperandFactory->destroy(pOperand);
93  g_IntOperandFactory->deallocate(pOperand);
94  pOperand = NULL;
95}
96
97void IntOperand::clear() {
98  g_IntOperandFactory->clear();
99}
100
101//===----------------------------------------------------------------------===//
102// SectOperand
103//===----------------------------------------------------------------------===//
104typedef GCFactory<SectOperand, MCLD_SECTIONS_PER_INPUT> SectOperandFactory;
105static llvm::ManagedStatic<SectOperandFactory> g_SectOperandFactory;
106SectOperand::SectOperand() : Operand(Operand::SECTION) {
107}
108
109SectOperand::SectOperand(const std::string& pName)
110    : Operand(Operand::SECTION), m_Name(pName) {
111}
112
113void SectOperand::dump() const {
114  mcld::outs() << m_Name;
115}
116
117SectOperand* SectOperand::create(const std::string& pName) {
118  SectOperand* result = g_SectOperandFactory->allocate();
119  new (result) SectOperand(pName);
120  return result;
121}
122
123void SectOperand::destroy(SectOperand*& pOperand) {
124  g_SectOperandFactory->destroy(pOperand);
125  g_SectOperandFactory->deallocate(pOperand);
126  pOperand = NULL;
127}
128
129void SectOperand::clear() {
130  g_SectOperandFactory->clear();
131}
132
133//===----------------------------------------------------------------------===//
134// SectDescOperand
135//===----------------------------------------------------------------------===//
136typedef GCFactory<SectDescOperand, MCLD_SECTIONS_PER_INPUT>
137    SectDescOperandFactory;
138static llvm::ManagedStatic<SectDescOperandFactory> g_SectDescOperandFactory;
139SectDescOperand::SectDescOperand()
140    : Operand(Operand::SECTION_DESC), m_pOutputDesc(NULL) {
141}
142
143SectDescOperand::SectDescOperand(const SectionMap::Output* pOutputDesc)
144    : Operand(Operand::SECTION_DESC), m_pOutputDesc(pOutputDesc) {
145}
146
147void SectDescOperand::dump() const {
148  assert(m_pOutputDesc != NULL);
149  mcld::outs() << m_pOutputDesc->getSection()->name();
150}
151
152SectDescOperand* SectDescOperand::create(
153    const SectionMap::Output* pOutputDesc) {
154  SectDescOperand* result = g_SectDescOperandFactory->allocate();
155  new (result) SectDescOperand(pOutputDesc);
156  return result;
157}
158
159void SectDescOperand::destroy(SectDescOperand*& pOperand) {
160  g_SectDescOperandFactory->destroy(pOperand);
161  g_SectDescOperandFactory->deallocate(pOperand);
162  pOperand = NULL;
163}
164
165void SectDescOperand::clear() {
166  g_SectDescOperandFactory->clear();
167}
168
169//===----------------------------------------------------------------------===//
170// FragOperand
171//===----------------------------------------------------------------------===//
172typedef GCFactory<FragOperand, MCLD_SYMBOLS_PER_INPUT> FragOperandFactory;
173static llvm::ManagedStatic<FragOperandFactory> g_FragOperandFactory;
174
175FragOperand::FragOperand() : Operand(Operand::FRAGMENT), m_pFragment(NULL) {
176}
177
178FragOperand::FragOperand(Fragment& pFragment)
179    : Operand(Operand::FRAGMENT), m_pFragment(&pFragment) {
180}
181
182void FragOperand::dump() const {
183  mcld::outs() << "fragment";
184}
185
186uint64_t FragOperand::value() const {
187  return m_pFragment->getOffset() +
188         m_pFragment->getParent()->getSection().addr();
189}
190
191FragOperand* FragOperand::create(Fragment& pFragment) {
192  FragOperand* result = g_FragOperandFactory->allocate();
193  new (result) FragOperand(pFragment);
194  return result;
195}
196
197void FragOperand::destroy(FragOperand*& pOperand) {
198  g_FragOperandFactory->destroy(pOperand);
199  g_FragOperandFactory->deallocate(pOperand);
200  pOperand = NULL;
201}
202
203void FragOperand::clear() {
204  g_FragOperandFactory->clear();
205}
206
207}  // namespace mcld
208