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