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
|
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COURGETTE_IMAGE_UTILS_H_
#define COURGETTE_IMAGE_UTILS_H_
#include <stddef.h>
#include <stdint.h>
// COURGETTE_HISTOGRAM_TARGETS prints out a histogram of how frequently
// different target addresses are referenced. Purely for debugging.
#define COURGETTE_HISTOGRAM_TARGETS 0
namespace courgette {
// There are several ways to reason about addresses in an image:
// - File Offset: Position relative to start of image.
// - VA (Virtual Address): Virtual memory address of a loaded image. This is
// subject to relocation by the OS.
// - RVA (Relative Virtual Address): VA relative to some base address. This is
// the preferred way to specify pointers in an image. Two ways to encode RVA
// are:
// - abs32: RVA value is encoded directly.
// - rel32: RVA is encoded as offset from an instruction address. This is
// commonly used for relative branch/call opcodes.
// Courgette operates on File Offsets and RVAs only.
using RVA = uint32_t;
const RVA kUnassignedRVA = 0xFFFFFFFFU;
const RVA kNoRVA = 0xFFFFFFFFU;
using FileOffset = size_t;
const FileOffset kNoFileOffset = UINTPTR_MAX;
// An interface for {File Offset, RVA, pointer to image data} translation.
class AddressTranslator {
public:
// Returns the RVA corresponding to |file_offset|, or kNoRVA if nonexistent.
virtual RVA FileOffsetToRVA(FileOffset file_offset) const = 0;
// Returns the file offset corresponding to |rva|, or kNoFileOffset if
// nonexistent.
virtual FileOffset RVAToFileOffset(RVA rva) const = 0;
// Returns the pointer to the image data for |file_offset|. Assumes that
// 0 <= |file_offset| <= image size. If |file_offset| == image, the resulting
// pointer is an end bound for iteration that should never be dereferenced.
virtual const uint8_t* FileOffsetToPointer(FileOffset file_offset) const = 0;
// Returns the pointer to the image data for |rva|, or null if |rva| is
// invalid.
virtual const uint8_t* RVAToPointer(RVA rva) const = 0;
};
// A Label is a symbolic reference to an address. Unlike a conventional
// assembly language, we always know the address. The address will later be
// stored in a table and the Label will be replaced with the index into the
// table.
// TODO(huangs): Make this a struct, and remove "_" from member names.
class Label {
public:
enum : int { kNoIndex = -1 };
explicit Label(RVA rva) : rva_(rva) {}
Label(RVA rva, int index) : rva_(rva), index_(index) {}
Label(RVA rva, int index, int32_t count)
: rva_(rva), index_(index), count_(count) {}
bool operator==(const Label& other) const {
return rva_ == other.rva_ && index_ == other.index_ &&
count_ == other.count_;
}
RVA rva_ = kUnassignedRVA; // Address referred to by the label.
int index_ = kNoIndex; // Index of address in address table.
int32_t count_ = 0;
};
// These helper functions avoid the need for casts in the main code.
inline uint16_t ReadU16(const uint8_t* address, size_t offset) {
return *reinterpret_cast<const uint16_t*>(address + offset);
}
inline uint32_t ReadU32(const uint8_t* address, size_t offset) {
return *reinterpret_cast<const uint32_t*>(address + offset);
}
inline uint64_t ReadU64(const uint8_t* address, size_t offset) {
return *reinterpret_cast<const uint64_t*>(address + offset);
}
inline uint16_t Read16LittleEndian(const void* address) {
return *reinterpret_cast<const uint16_t*>(address);
}
inline uint32_t Read32LittleEndian(const void* address) {
return *reinterpret_cast<const uint32_t*>(address);
}
inline uint64_t Read64LittleEndian(const void* address) {
return *reinterpret_cast<const uint64_t*>(address);
}
} // namespace courgette
#endif // COURGETTE_IMAGE_UTILS_H_
|
