forked from cseagle/blc
-
Notifications
You must be signed in to change notification settings - Fork 0
/
loadimage.cc
112 lines (97 loc) · 3.02 KB
/
loadimage.cc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
/* ###
* IP: GHIDRA
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "loadimage.hh"
/// This is a convenience method wrapped around the core
/// loadFill() routine. It automatically allocates an array
/// of the desired size, and then fills it with load image data.
/// If the array cannot be allocated, an exception is thrown.
/// The caller assumes the responsibility of freeing the
/// array after it has been used.
/// \param size is the number of bytes to read from the image
/// \param addr is the address of the first byte being read
/// \return a pointer to the desired bytes
uint1 *LoadImage::load(int4 size,const Address &addr)
{
uint1 *buf = new uint1[ size ];
if (buf == (uint1 *)0)
throw LowlevelError("Out of memory");
loadFill(buf,size,addr);
return buf;
}
RawLoadImage::RawLoadImage(const string &f) : LoadImage(f)
{
vma = 0;
thefile = (ifstream *)0;
spaceid = (AddrSpace *)0;
filesize = 0;
}
RawLoadImage::~RawLoadImage(void)
{
if (thefile != (ifstream *)0) {
thefile->close();
delete thefile;
}
}
/// The file is opened and its size immediately recovered.
void RawLoadImage::open(void)
{
if (thefile != (ifstream *)0) throw LowlevelError("loadimage is already open");
thefile = new ifstream(filename.c_str());
if (!(*thefile)) {
string errmsg = "Unable to open raw image file: "+filename;
throw LowlevelError(errmsg);
}
thefile->seekg(0,ios::end);
filesize = thefile->tellg();
}
string RawLoadImage::getArchType(void) const
{
return "unknown";
}
void RawLoadImage::adjustVma(long adjust)
{
adjust = AddrSpace::addressToByte(adjust,spaceid->getWordSize());
vma += adjust;
}
void RawLoadImage::loadFill(uint1 *ptr,int4 size,const Address &addr)
{
uintb curaddr = addr.getOffset();
uintb offset = 0;
uintb readsize;
curaddr -= vma; // Get relative offset of first byte
while(size>0) {
if (curaddr >= filesize) {
if (offset == 0) // Initial address not within file
break;
memset(ptr+offset,0,size); // Fill out the rest of the buffer with 0
return;
}
readsize = size;
if (curaddr + readsize > filesize) // Adjust to biggest possible read
readsize = filesize - curaddr;
thefile->seekg(curaddr);
thefile->read((char *)(ptr+offset),readsize);
offset += readsize;
size -= readsize;
curaddr += readsize;
}
if (size > 0) {
ostringstream errmsg;
errmsg << "Unable to load " << dec << size << " bytes at " << addr.getShortcut();
addr.printRaw(errmsg);
throw DataUnavailError(errmsg.str());
}
}