[go: nahoru, domu]

blob: c41a71a84e3e27c0f6b085fea81253fc20944206 [file] [log] [blame]
// Copyright 2011 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COURGETTE_ENCODED_PROGRAM_H_
#define COURGETTE_ENCODED_PROGRAM_H_
#include <stddef.h>
#include <stdint.h>
#include <memory>
#include <vector>
#include "courgette/courgette.h"
#include "courgette/image_utils.h"
#include "courgette/instruction_utils.h"
#include "courgette/memory_allocator.h"
#include "courgette/types_elf.h"
namespace courgette {
// Stream indexes.
const int kStreamMisc = 0;
const int kStreamOps = 1;
const int kStreamBytes = 2;
const int kStreamAbs32Indexes = 3;
const int kStreamRel32Indexes = 4;
const int kStreamAbs32Addresses = 5;
const int kStreamRel32Addresses = 6;
const int kStreamCopyCounts = 7;
const int kStreamOriginAddresses = kStreamMisc;
const int kStreamLimit = 9;
class LabelManager;
class SinkStream;
class SinkStreamSet;
class SourceStreamSet;
// EncodedProgram encodes Courgette's simple "binary assembly language", which
// can be assembled to produce a sequence of bytes (e.g., a Windows 32-bit
// executable).
class EncodedProgram {
public:
EncodedProgram();
EncodedProgram(const EncodedProgram&) = delete;
EncodedProgram& operator=(const EncodedProgram&) = delete;
~EncodedProgram();
// Generating an EncodedProgram:
//
// (1) The image base can be specified at any time.
void set_image_base(uint64_t base) { image_base_ = base; }
// (2) Address tables and indexes imported first.
[[nodiscard]] CheckBool ImportLabels(const LabelManager& abs32_label_manager,
const LabelManager& rel32_label_manager);
// (3) Add instructions in the order needed to generate bytes of file.
// NOTE: If any of these methods ever fail, the EncodedProgram instance
// has failed and should be discarded.
[[nodiscard]] CheckBool AddOrigin(RVA rva);
[[nodiscard]] CheckBool AddCopy(size_t count, const void* bytes);
[[nodiscard]] CheckBool AddRel32(int label_index);
[[nodiscard]] CheckBool AddAbs32(int label_index);
[[nodiscard]] CheckBool AddAbs64(int label_index);
[[nodiscard]] CheckBool AddPeMakeRelocs(ExecutableType kind);
[[nodiscard]] CheckBool AddElfMakeRelocs();
// (3) Serialize binary assembly language tables to a set of streams.
[[nodiscard]] CheckBool WriteTo(SinkStreamSet* streams);
// Using an EncodedProgram to generate a byte stream:
//
// (4) Deserializes a fresh EncodedProgram from a set of streams.
bool ReadFrom(SourceStreamSet* streams);
// (5) Assembles the 'binary assembly language' into final file.
[[nodiscard]] CheckBool AssembleTo(SinkStream* buffer);
// Calls |gen| to extract all instructions, which are then encoded and stored.
CheckBool GenerateInstructions(ExecutableType exe_type,
const InstructionGenerator& gen);
private:
// Binary assembly language operations.
// These are part of the patch format. Reusing an existing value will
// break backwards compatibility.
enum OP {
ORIGIN = 0, // ORIGIN <rva> - set address for subsequent assembly.
COPY = 1, // COPY <count> <bytes> - copy bytes to output.
COPY1 = 2, // COPY1 <byte> - same as COPY 1 <byte>.
REL32 = 3, // REL32 <index> - emit rel32 encoded reference to address at
// address table offset <index>.
ABS32 = 4, // ABS32 <index> - emit abs32 encoded reference to address at
// address table offset <index>.
MAKE_PE_RELOCATION_TABLE = 5, // Emit PE base relocation table blocks.
MAKE_ELF_RELOCATION_TABLE = 6, // Emit ELF relocation table for X86.
// DEPCREATED: ELF relocation table for ARM.
// MAKE_ELF_ARM_RELOCATION_TABLE_DEPRECATED = 7,
MAKE_PE64_RELOCATION_TABLE = 8, // Emit PE64 base relocation table blocks.
ABS64 = 9, // ABS64 <index> - emit abs64 encoded reference to address at
// address table offset <index>.
};
typedef NoThrowBuffer<RVA> RvaVector;
typedef NoThrowBuffer<size_t> SizeTVector;
typedef NoThrowBuffer<uint32_t> UInt32Vector;
typedef NoThrowBuffer<uint8_t> UInt8Vector;
typedef NoThrowBuffer<OP> OPVector;
void DebuggingSummary();
// Helper for ImportLabels().
static CheckBool WriteRvasToList(const LabelManager& label_manager,
RvaVector* rvas);
// Helper for ImportLabels().
static void FillUnassignedRvaSlots(RvaVector* rvas);
[[nodiscard]] CheckBool GeneratePeRelocations(SinkStream* buffer,
uint8_t type);
[[nodiscard]] CheckBool GenerateElfRelocations(
Elf32_Word pending_elf_relocation_table,
SinkStream* buffer);
// Binary assembly language tables.
uint64_t image_base_ = 0;
RvaVector rel32_rva_;
RvaVector abs32_rva_;
OPVector ops_;
RvaVector origins_;
SizeTVector copy_counts_;
UInt8Vector copy_bytes_;
UInt32Vector rel32_ix_;
UInt32Vector abs32_ix_;
// Table of the addresses containing abs32 relocations; computed during
// assembly, used to generate base relocation table.
UInt32Vector abs32_relocs_;
};
// Deserializes program from a stream set to |*output|. Returns C_OK if
// successful, otherwise assigns |*output| to null and returns an error status.
Status ReadEncodedProgram(SourceStreamSet* source,
std::unique_ptr<EncodedProgram>* output);
} // namespace courgette
#endif // COURGETTE_ENCODED_PROGRAM_H_