← Back to branch summary

~ubuntu-branches/ubuntu/feisty/clamav/feisty

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/CodeGen/ObjectCodeEmitter.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook
  • Date: 2007-02-20 10:33:44 UTC
  • mto: This revision was merged to the branch mainline in revision 16.
  • Revision ID: james.westby@ubuntu.com-20070220103344-zgcu2psnx9d98fpa
Tags: upstream-0.90
Import upstream version 0.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/CodeGen/ObjectCodeEmitter.cpp
1
 
//===-- llvm/CodeGen/ObjectCodeEmitter.cpp -------------------- -*- 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
 
#include "llvm/CodeGen/BinaryObject.h"
11
 
#include "llvm/CodeGen/MachineBasicBlock.h"
12
 
#include "llvm/CodeGen/MachineRelocation.h"
13
 
#include "llvm/CodeGen/ObjectCodeEmitter.h"
14
 
 
15
 
//===----------------------------------------------------------------------===//
16
 
//                       ObjectCodeEmitter Implementation
17
 
//===----------------------------------------------------------------------===//
18
 
 
19
 
namespace llvm {
20
 
 
21
 
ObjectCodeEmitter::ObjectCodeEmitter() : BO(0) {}
22
 
ObjectCodeEmitter::ObjectCodeEmitter(BinaryObject *bo) : BO(bo) {}
23
 
ObjectCodeEmitter::~ObjectCodeEmitter() {}
24
 
 
25
 
/// setBinaryObject - set the BinaryObject we are writting to
26
 
void ObjectCodeEmitter::setBinaryObject(BinaryObject *bo) { BO = bo; }
27
 
 
28
 
/// emitByte - This callback is invoked when a byte needs to be
29
 
/// written to the data stream, without buffer overflow testing.
30
 
void ObjectCodeEmitter::emitByte(uint8_t B) {
31
 
  BO->emitByte(B);
32
 
}
33
 
 
34
 
/// emitWordLE - This callback is invoked when a 32-bit word needs to be
35
 
/// written to the data stream in little-endian format.
36
 
void ObjectCodeEmitter::emitWordLE(uint32_t W) {
37
 
  BO->emitWordLE(W);
38
 
}
39
 
 
40
 
/// emitWordBE - This callback is invoked when a 32-bit word needs to be
41
 
/// written to the data stream in big-endian format.
42
 
void ObjectCodeEmitter::emitWordBE(uint32_t W) {
43
 
  BO->emitWordBE(W);
44
 
}
45
 
 
46
 
/// emitDWordLE - This callback is invoked when a 64-bit word needs to be
47
 
/// written to the data stream in little-endian format.
48
 
void ObjectCodeEmitter::emitDWordLE(uint64_t W) {
49
 
  BO->emitDWordLE(W);
50
 
}
51
 
 
52
 
/// emitDWordBE - This callback is invoked when a 64-bit word needs to be
53
 
/// written to the data stream in big-endian format.
54
 
void ObjectCodeEmitter::emitDWordBE(uint64_t W) {
55
 
  BO->emitDWordBE(W);
56
 
}
57
 
 
58
 
/// emitAlignment - Align 'BO' to the necessary alignment boundary.
59
 
void ObjectCodeEmitter::emitAlignment(unsigned Alignment /* 0 */,
60
 
                                      uint8_t fill /* 0 */) {
61
 
  BO->emitAlignment(Alignment, fill);
62
 
}
63
 
 
64
 
/// emitULEB128Bytes - This callback is invoked when a ULEB128 needs to be
65
 
/// written to the data stream.
66
 
void ObjectCodeEmitter::emitULEB128Bytes(uint64_t Value) {
67
 
  BO->emitULEB128Bytes(Value);
68
 
}
69
 
 
70
 
/// emitSLEB128Bytes - This callback is invoked when a SLEB128 needs to be
71
 
/// written to the data stream.
72
 
void ObjectCodeEmitter::emitSLEB128Bytes(uint64_t Value) {
73
 
  BO->emitSLEB128Bytes(Value);
74
 
}
75
 
 
76
 
/// emitString - This callback is invoked when a String needs to be
77
 
/// written to the data stream.
78
 
void ObjectCodeEmitter::emitString(const std::string &String) {
79
 
  BO->emitString(String);
80
 
}
81
 
 
82
 
/// getCurrentPCValue - This returns the address that the next emitted byte
83
 
/// will be output to.
84
 
uintptr_t ObjectCodeEmitter::getCurrentPCValue() const {
85
 
  return BO->getCurrentPCOffset();
86
 
}
87
 
 
88
 
/// getCurrentPCOffset - Return the offset from the start of the emitted
89
 
/// buffer that we are currently writing to.
90
 
uintptr_t ObjectCodeEmitter::getCurrentPCOffset() const {
91
 
  return BO->getCurrentPCOffset();
92
 
}
93
 
 
94
 
/// addRelocation - Whenever a relocatable address is needed, it should be
95
 
/// noted with this interface.
96
 
void ObjectCodeEmitter::addRelocation(const MachineRelocation& relocation) {
97
 
  BO->addRelocation(relocation);
98
 
}
99
 
 
100
 
/// StartMachineBasicBlock - This should be called by the target when a new
101
 
/// basic block is about to be emitted.  This way the MCE knows where the
102
 
/// start of the block is, and can implement getMachineBasicBlockAddress.
103
 
void ObjectCodeEmitter::StartMachineBasicBlock(MachineBasicBlock *MBB) {
104
 
  if (MBBLocations.size() <= (unsigned)MBB->getNumber())
105
 
    MBBLocations.resize((MBB->getNumber()+1)*2);
106
 
  MBBLocations[MBB->getNumber()] = getCurrentPCOffset();
107
 
}
108
 
 
109
 
/// getMachineBasicBlockAddress - Return the address of the specified
110
 
/// MachineBasicBlock, only usable after the label for the MBB has been
111
 
/// emitted.
112
 
uintptr_t
113
 
ObjectCodeEmitter::getMachineBasicBlockAddress(MachineBasicBlock *MBB) const {
114
 
  assert(MBBLocations.size() > (unsigned)MBB->getNumber() &&
115
 
         MBBLocations[MBB->getNumber()] && "MBB not emitted!");
116
 
  return MBBLocations[MBB->getNumber()];
117
 
}
118
 
 
119
 
/// getJumpTableEntryAddress - Return the address of the jump table with index
120
 
/// 'Index' in the function that last called initJumpTableInfo.
121
 
uintptr_t ObjectCodeEmitter::getJumpTableEntryAddress(unsigned Index) const {
122
 
  assert(JTLocations.size() > Index && "JT not emitted!");
123
 
  return JTLocations[Index];
124
 
}
125
 
 
126
 
/// getConstantPoolEntryAddress - Return the address of the 'Index' entry in
127
 
/// the constant pool that was last emitted with the emitConstantPool method.
128
 
uintptr_t ObjectCodeEmitter::getConstantPoolEntryAddress(unsigned Index) const {
129
 
  assert(CPLocations.size() > Index && "CP not emitted!");
130
 
  return CPLocations[Index];
131
 
}
132
 
 
133
 
/// getConstantPoolEntrySection - Return the section of the 'Index' entry in
134
 
/// the constant pool that was last emitted with the emitConstantPool method.
135
 
uintptr_t ObjectCodeEmitter::getConstantPoolEntrySection(unsigned Index) const {
136
 
  assert(CPSections.size() > Index && "CP not emitted!");
137
 
  return CPSections[Index];
138
 
}
139
 
 
140
 
} // end namespace llvm
141