123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174 |
- // 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>
- #include <iterator>
- #include <vector>
- // 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.
- //
- // In Courgette we consider two types of addresses:
- // - abs32: In an image these are directly stored as VA whose locations are
- // stored in the relocation table.
- // - rel32: In an image these appear in branch/call opcodes, and are represented
- // as offsets from an instruction address.
- using RVA = uint32_t;
- const RVA kUnassignedRVA = 0xFFFFFFFFU;
- const RVA kNoRVA = 0xFFFFFFFFU;
- using FileOffset = size_t;
- const FileOffset kNoFileOffset = UINTPTR_MAX;
- // An interface translate and read addresses. The main conversion path is:
- // (1) Location RVA.
- // (2) Location FileOffset.
- // (3) Pointer in image.
- // (4) Target VA (32-bit or 64-bit).
- // (5) Target RVA (32-bit).
- // For abs32, we get (1) from relocation table, and convert to (5).
- // For rel32, we get (2) from scanning opcode, and convert to (1).
- class AddressTranslator {
- public:
- // (2) -> (1): Returns the RVA corresponding to |file_offset|, or kNoRVA if
- // nonexistent.
- virtual RVA FileOffsetToRVA(FileOffset file_offset) const = 0;
- // (1) -> (2): Returns the file offset corresponding to |rva|, or
- // kNoFileOffset if nonexistent.
- virtual FileOffset RVAToFileOffset(RVA rva) const = 0;
- // (2) -> (3): Returns image data pointer correspnoding to |file_offset|.
- // Assumes 0 <= |file_offset| <= image size.
- // If |file_offset| == image size, then the resulting pointer is an end bound
- // for iteration, and should not be dereferenced.
- virtual const uint8_t* FileOffsetToPointer(FileOffset file_offset) const = 0;
- // (1) -> (3): Returns the pointer to the image data for |rva|, or null if
- // |rva| is invalid.
- virtual const uint8_t* RVAToPointer(RVA rva) const = 0;
- // (3) -> (5): Returns the target RVA located at |p|, where |p| is a pointer
- // to image data.
- virtual RVA PointerToTargetRVA(const uint8_t* p) 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;
- };
- // An interface for sequential visit of RVAs.
- // Use case: Translating from RVA locations to RVA targets is platform-specific,
- // and works differently for abs32 vs. rel32. A function that sequentually
- // visits RVA targets only requires an RvaVisitor. The caller can provide an
- // implementation that stores a fixed list of RVA locations, and translates each
- // to the matching RVA target on demand without extra storage.
- class RvaVisitor {
- public:
- virtual ~RvaVisitor() { }
- // Returns the number of remaining RVAs to visit.
- virtual size_t Remaining() const = 0;
- // Returns the current RVA.
- virtual RVA Get() const = 0;
- // Advances to the next RVA.
- virtual void Next() = 0;
- };
- // RvaVisitor whose data are backed by std::vector<T>. Translating from T to RVA
- // is should be implemented in Get().
- template <typename T>
- class VectorRvaVisitor : public RvaVisitor {
- public:
- // Assumes |v| does not change for the lifetime of this instance.
- explicit VectorRvaVisitor(const std::vector<T>& v)
- : it_(v.begin()), end_(v.end()) { }
- ~VectorRvaVisitor() override { }
- // RvaVisitor interfaces.
- size_t Remaining() const override { return std::distance(it_, end_); }
- virtual RVA Get() const override = 0;
- void Next() override { ++it_; }
- protected:
- typename std::vector<T>::const_iterator it_;
- typename std::vector<T>::const_iterator end_;
- };
- // RvaVisitor that simply stores a list of RVAs for traversal. For testing.
- class TrivialRvaVisitor : public VectorRvaVisitor<RVA> {
- public:
- explicit TrivialRvaVisitor(const std::vector<RVA>& rvas)
- : VectorRvaVisitor<RVA>(rvas) { }
- ~TrivialRvaVisitor() override { }
- // VectorRvaVisitor<RVA> interfaces.
- RVA Get() const override { return *it_; }
- };
- // 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_
|