Formatting: force pointers to the left side.
This commit is contained in:
Ben Vanik
parent
90e86d0172
commit
d7a5c74bf3
|
|
@ -1,2 +1,4 @@
|
|||
---
|
||||
BasedOnStyle: Google
|
||||
DerivePointerAlignment: false
|
||||
PointerAlignment: Left
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ XmaContext::~XmaContext() {
|
|||
}
|
||||
}
|
||||
|
||||
int XmaContext::Setup(uint32_t id, Memory *memory, uint32_t guest_ptr) {
|
||||
int XmaContext::Setup(uint32_t id, Memory* memory, uint32_t guest_ptr) {
|
||||
id_ = id;
|
||||
memory_ = memory;
|
||||
guest_ptr_ = guest_ptr;
|
||||
|
|
@ -94,7 +94,7 @@ int XmaContext::Setup(uint32_t id, Memory *memory, uint32_t guest_ptr) {
|
|||
extra_data_.decode_flags = 0x10D6;
|
||||
|
||||
context_->extradata_size = sizeof(extra_data_);
|
||||
context_->extradata = (uint8_t *)&extra_data_;
|
||||
context_->extradata = (uint8_t*)&extra_data_;
|
||||
|
||||
// Current frame stuff whatever
|
||||
// samples per frame * 2 max channels * output bytes
|
||||
|
|
@ -204,7 +204,7 @@ int XmaContext::GetSampleRate(int id) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
void XmaContext::DecodePackets(XMA_CONTEXT_DATA &data) {
|
||||
void XmaContext::DecodePackets(XMA_CONTEXT_DATA& data) {
|
||||
SCOPE_profile_cpu_f("apu");
|
||||
|
||||
// What I see:
|
||||
|
|
@ -236,7 +236,7 @@ void XmaContext::DecodePackets(XMA_CONTEXT_DATA &data) {
|
|||
// Output buffers are in raw PCM samples, 256 bytes per block.
|
||||
// Output buffer is a ring buffer. We need to write from the write offset
|
||||
// to the read offset.
|
||||
uint8_t *output_buffer = memory()->TranslatePhysical(data.output_buffer_ptr);
|
||||
uint8_t* output_buffer = memory()->TranslatePhysical(data.output_buffer_ptr);
|
||||
uint32_t output_capacity = data.output_buffer_block_count * kBytesPerSubframe;
|
||||
uint32_t output_read_offset =
|
||||
data.output_buffer_read_offset * kBytesPerSubframe;
|
||||
|
|
@ -315,12 +315,12 @@ void XmaContext::DecodePackets(XMA_CONTEXT_DATA &data) {
|
|||
data.output_buffer_valid = 0;
|
||||
}
|
||||
|
||||
int XmaContext::StartPacket(XMA_CONTEXT_DATA &data) {
|
||||
int XmaContext::StartPacket(XMA_CONTEXT_DATA& data) {
|
||||
// Translate pointers for future use.
|
||||
uint8_t *in0 = data.input_buffer_0_valid
|
||||
uint8_t* in0 = data.input_buffer_0_valid
|
||||
? memory()->TranslatePhysical(data.input_buffer_0_ptr)
|
||||
: nullptr;
|
||||
uint8_t *in1 = data.input_buffer_1_valid
|
||||
uint8_t* in1 = data.input_buffer_1_valid
|
||||
? memory()->TranslatePhysical(data.input_buffer_1_ptr)
|
||||
: nullptr;
|
||||
|
||||
|
|
@ -373,7 +373,7 @@ int XmaContext::StartPacket(XMA_CONTEXT_DATA &data) {
|
|||
return input_remaining_bytes;
|
||||
}
|
||||
|
||||
int XmaContext::PreparePacket(uint8_t *input, size_t seq_offset, size_t size,
|
||||
int XmaContext::PreparePacket(uint8_t* input, size_t seq_offset, size_t size,
|
||||
int sample_rate, int channels) {
|
||||
if (size != kBytesPerPacket) {
|
||||
// Invalid packet size!
|
||||
|
|
@ -388,8 +388,8 @@ int XmaContext::PreparePacket(uint8_t *input, size_t seq_offset, size_t size,
|
|||
std::memcpy(packet_data_, input, size);
|
||||
|
||||
// Modify the packet header so it's WMAPro compatible
|
||||
*((int *)packet_data_) = (((seq_offset & 0x7800) | 0x400) >> 7) |
|
||||
(*((int *)packet_data_) & 0xFFFEFF08);
|
||||
*((int*)packet_data_) = (((seq_offset & 0x7800) | 0x400) >> 7) |
|
||||
(*((int*)packet_data_) & 0xFFFEFF08);
|
||||
|
||||
packet_->data = packet_data_;
|
||||
packet_->size = kBytesPerPacket;
|
||||
|
|
@ -422,7 +422,7 @@ void XmaContext::DiscardPacket() {
|
|||
}
|
||||
}
|
||||
|
||||
int XmaContext::DecodePacket(uint8_t *output, size_t output_offset,
|
||||
int XmaContext::DecodePacket(uint8_t* output, size_t output_offset,
|
||||
size_t output_size) {
|
||||
size_t to_copy = 0;
|
||||
size_t original_offset = output_offset;
|
||||
|
|
@ -478,7 +478,7 @@ int XmaContext::DecodePacket(uint8_t *output, size_t output_offset,
|
|||
for (int i = 0; i < decoded_frame_->nb_samples; i++) {
|
||||
for (int j = 0; j < context_->channels; j++) {
|
||||
// Select the appropriate array based on the current channel.
|
||||
float *sample_array = (float *)decoded_frame_->data[j];
|
||||
float* sample_array = (float*)decoded_frame_->data[j];
|
||||
|
||||
// Raw sample should be within [-1, 1].
|
||||
// Clamp it, just in case.
|
||||
|
|
|
|||
|
|
@ -61,12 +61,12 @@ inline uint64_t byte_swap(uint64_t value) {
|
|||
return XENIA_BASE_BYTE_SWAP_64(value);
|
||||
}
|
||||
inline float byte_swap(float value) {
|
||||
uint32_t temp = byte_swap(*reinterpret_cast<uint32_t *>(&value));
|
||||
return *reinterpret_cast<float *>(&temp);
|
||||
uint32_t temp = byte_swap(*reinterpret_cast<uint32_t*>(&value));
|
||||
return *reinterpret_cast<float*>(&temp);
|
||||
}
|
||||
inline double byte_swap(double value) {
|
||||
uint64_t temp = byte_swap(*reinterpret_cast<uint64_t *>(&value));
|
||||
return *reinterpret_cast<double *>(&temp);
|
||||
uint64_t temp = byte_swap(*reinterpret_cast<uint64_t*>(&value));
|
||||
return *reinterpret_cast<double*>(&temp);
|
||||
}
|
||||
template <typename T>
|
||||
inline T byte_swap(T value) {
|
||||
|
|
@ -80,19 +80,19 @@ inline T byte_swap(T value) {
|
|||
template <typename T>
|
||||
struct be {
|
||||
be() = default;
|
||||
be(const T &src) : value(xe::byte_swap(src)) {}
|
||||
be(const be &other) { value = other.value; }
|
||||
be(const T& src) : value(xe::byte_swap(src)) {}
|
||||
be(const be& other) { value = other.value; }
|
||||
operator T() const { return xe::byte_swap(value); }
|
||||
|
||||
be<T> &operator+=(int a) {
|
||||
be<T>& operator+=(int a) {
|
||||
*this = *this + a;
|
||||
return *this;
|
||||
}
|
||||
be<T> &operator-=(int a) {
|
||||
be<T>& operator-=(int a) {
|
||||
*this = *this - a;
|
||||
return *this;
|
||||
}
|
||||
be<T> &operator++() {
|
||||
be<T>& operator++() {
|
||||
*this += 1;
|
||||
return *this;
|
||||
} // ++a
|
||||
|
|
@ -100,7 +100,7 @@ struct be {
|
|||
*this += 1;
|
||||
return (*this - 1);
|
||||
} // a++
|
||||
be<T> &operator--() {
|
||||
be<T>& operator--() {
|
||||
*this -= 1;
|
||||
return *this;
|
||||
} // --a
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ bool IsDebuggerAttached();
|
|||
// If no debugger is present, a signal will be raised.
|
||||
void Break();
|
||||
|
||||
void DebugPrint(const char *fmt, ...);
|
||||
void DebugPrint(const char* fmt, ...);
|
||||
|
||||
} // namespace debugging
|
||||
} // namespace xe
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ bool IsDebuggerAttached() { return IsDebuggerPresent() ? true : false; }
|
|||
|
||||
void Break() { __debugbreak(); }
|
||||
|
||||
void DebugPrint(const char *fmt, ...) {
|
||||
void DebugPrint(const char* fmt, ...) {
|
||||
StringBuffer buff;
|
||||
|
||||
va_list va;
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ namespace xe {
|
|||
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
uint16_t float_to_half(float value) {
|
||||
uint32_t Result;
|
||||
uint32_t IValue = ((uint32_t *)(&value))[0];
|
||||
uint32_t IValue = ((uint32_t*)(&value))[0];
|
||||
uint32_t Sign = (IValue & 0x80000000U) >> 16U;
|
||||
IValue = IValue & 0x7FFFFFFFU; // Hack off the sign
|
||||
if (IValue > 0x47FFEFFFU) {
|
||||
|
|
@ -63,7 +63,7 @@ float half_to_float(uint16_t value) {
|
|||
uint32_t Result = ((value & 0x8000) << 16) | // Sign
|
||||
((Exponent + 112) << 23) | // Exponent
|
||||
(Mantissa << 13); // Mantissa
|
||||
return *(float *)&Result;
|
||||
return *(float*)&Result;
|
||||
}
|
||||
|
||||
} // namespace xe
|
||||
|
|
|
|||
|
|
@ -43,20 +43,20 @@ STRUCT_END(Breakpoint, 4);
|
|||
|
||||
struct ListBreakpointsRequest FLATBUFFERS_FINAL_CLASS
|
||||
: private flatbuffers::Table {
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) && verifier.EndTable();
|
||||
}
|
||||
};
|
||||
|
||||
struct ListBreakpointsRequestBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
ListBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
||||
ListBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
ListBreakpointsRequestBuilder &operator=(
|
||||
const ListBreakpointsRequestBuilder &);
|
||||
ListBreakpointsRequestBuilder& operator=(
|
||||
const ListBreakpointsRequestBuilder&);
|
||||
flatbuffers::Offset<ListBreakpointsRequest> Finish() {
|
||||
auto o =
|
||||
flatbuffers::Offset<ListBreakpointsRequest>(fbb_.EndTable(start_, 0));
|
||||
|
|
@ -65,17 +65,17 @@ struct ListBreakpointsRequestBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<ListBreakpointsRequest> CreateListBreakpointsRequest(
|
||||
flatbuffers::FlatBufferBuilder &_fbb) {
|
||||
flatbuffers::FlatBufferBuilder& _fbb) {
|
||||
ListBreakpointsRequestBuilder builder_(_fbb);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
||||
struct ListBreakpointsResponse FLATBUFFERS_FINAL_CLASS
|
||||
: private flatbuffers::Table {
|
||||
const flatbuffers::Vector<const Breakpoint *> *breakpoints() const {
|
||||
return GetPointer<const flatbuffers::Vector<const Breakpoint *> *>(4);
|
||||
const flatbuffers::Vector<const Breakpoint*>* breakpoints() const {
|
||||
return GetPointer<const flatbuffers::Vector<const Breakpoint*>*>(4);
|
||||
}
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* breakpoints */) &&
|
||||
verifier.Verify(breakpoints()) && verifier.EndTable();
|
||||
|
|
@ -83,18 +83,18 @@ struct ListBreakpointsResponse FLATBUFFERS_FINAL_CLASS
|
|||
};
|
||||
|
||||
struct ListBreakpointsResponseBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_breakpoints(flatbuffers::Offset<
|
||||
flatbuffers::Vector<const Breakpoint *>> breakpoints) {
|
||||
void add_breakpoints(
|
||||
flatbuffers::Offset<flatbuffers::Vector<const Breakpoint*>> breakpoints) {
|
||||
fbb_.AddOffset(4, breakpoints);
|
||||
}
|
||||
ListBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
||||
ListBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
ListBreakpointsResponseBuilder &operator=(
|
||||
const ListBreakpointsResponseBuilder &);
|
||||
ListBreakpointsResponseBuilder& operator=(
|
||||
const ListBreakpointsResponseBuilder&);
|
||||
flatbuffers::Offset<ListBreakpointsResponse> Finish() {
|
||||
auto o =
|
||||
flatbuffers::Offset<ListBreakpointsResponse>(fbb_.EndTable(start_, 1));
|
||||
|
|
@ -104,8 +104,8 @@ struct ListBreakpointsResponseBuilder {
|
|||
|
||||
inline flatbuffers::Offset<ListBreakpointsResponse>
|
||||
CreateListBreakpointsResponse(
|
||||
flatbuffers::FlatBufferBuilder &_fbb,
|
||||
flatbuffers::Offset<flatbuffers::Vector<const Breakpoint *>> breakpoints =
|
||||
flatbuffers::FlatBufferBuilder& _fbb,
|
||||
flatbuffers::Offset<flatbuffers::Vector<const Breakpoint*>> breakpoints =
|
||||
0) {
|
||||
ListBreakpointsResponseBuilder builder_(_fbb);
|
||||
builder_.add_breakpoints(breakpoints);
|
||||
|
|
@ -114,10 +114,10 @@ CreateListBreakpointsResponse(
|
|||
|
||||
struct AddBreakpointsRequest FLATBUFFERS_FINAL_CLASS
|
||||
: private flatbuffers::Table {
|
||||
const flatbuffers::Vector<const Breakpoint *> *breakpoints() const {
|
||||
return GetPointer<const flatbuffers::Vector<const Breakpoint *> *>(4);
|
||||
const flatbuffers::Vector<const Breakpoint*>* breakpoints() const {
|
||||
return GetPointer<const flatbuffers::Vector<const Breakpoint*>*>(4);
|
||||
}
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* breakpoints */) &&
|
||||
verifier.Verify(breakpoints()) && verifier.EndTable();
|
||||
|
|
@ -125,17 +125,17 @@ struct AddBreakpointsRequest FLATBUFFERS_FINAL_CLASS
|
|||
};
|
||||
|
||||
struct AddBreakpointsRequestBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_breakpoints(flatbuffers::Offset<
|
||||
flatbuffers::Vector<const Breakpoint *>> breakpoints) {
|
||||
void add_breakpoints(
|
||||
flatbuffers::Offset<flatbuffers::Vector<const Breakpoint*>> breakpoints) {
|
||||
fbb_.AddOffset(4, breakpoints);
|
||||
}
|
||||
AddBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
||||
AddBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
AddBreakpointsRequestBuilder &operator=(const AddBreakpointsRequestBuilder &);
|
||||
AddBreakpointsRequestBuilder& operator=(const AddBreakpointsRequestBuilder&);
|
||||
flatbuffers::Offset<AddBreakpointsRequest> Finish() {
|
||||
auto o =
|
||||
flatbuffers::Offset<AddBreakpointsRequest>(fbb_.EndTable(start_, 1));
|
||||
|
|
@ -144,8 +144,8 @@ struct AddBreakpointsRequestBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<AddBreakpointsRequest> CreateAddBreakpointsRequest(
|
||||
flatbuffers::FlatBufferBuilder &_fbb,
|
||||
flatbuffers::Offset<flatbuffers::Vector<const Breakpoint *>> breakpoints =
|
||||
flatbuffers::FlatBufferBuilder& _fbb,
|
||||
flatbuffers::Offset<flatbuffers::Vector<const Breakpoint*>> breakpoints =
|
||||
0) {
|
||||
AddBreakpointsRequestBuilder builder_(_fbb);
|
||||
builder_.add_breakpoints(breakpoints);
|
||||
|
|
@ -154,20 +154,20 @@ inline flatbuffers::Offset<AddBreakpointsRequest> CreateAddBreakpointsRequest(
|
|||
|
||||
struct AddBreakpointsResponse FLATBUFFERS_FINAL_CLASS
|
||||
: private flatbuffers::Table {
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) && verifier.EndTable();
|
||||
}
|
||||
};
|
||||
|
||||
struct AddBreakpointsResponseBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
AddBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
||||
AddBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
AddBreakpointsResponseBuilder &operator=(
|
||||
const AddBreakpointsResponseBuilder &);
|
||||
AddBreakpointsResponseBuilder& operator=(
|
||||
const AddBreakpointsResponseBuilder&);
|
||||
flatbuffers::Offset<AddBreakpointsResponse> Finish() {
|
||||
auto o =
|
||||
flatbuffers::Offset<AddBreakpointsResponse>(fbb_.EndTable(start_, 0));
|
||||
|
|
@ -176,17 +176,17 @@ struct AddBreakpointsResponseBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<AddBreakpointsResponse> CreateAddBreakpointsResponse(
|
||||
flatbuffers::FlatBufferBuilder &_fbb) {
|
||||
flatbuffers::FlatBufferBuilder& _fbb) {
|
||||
AddBreakpointsResponseBuilder builder_(_fbb);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
||||
struct UpdateBreakpointsRequest FLATBUFFERS_FINAL_CLASS
|
||||
: private flatbuffers::Table {
|
||||
const flatbuffers::Vector<const Breakpoint *> *breakpoints() const {
|
||||
return GetPointer<const flatbuffers::Vector<const Breakpoint *> *>(4);
|
||||
const flatbuffers::Vector<const Breakpoint*>* breakpoints() const {
|
||||
return GetPointer<const flatbuffers::Vector<const Breakpoint*>*>(4);
|
||||
}
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* breakpoints */) &&
|
||||
verifier.Verify(breakpoints()) && verifier.EndTable();
|
||||
|
|
@ -194,18 +194,18 @@ struct UpdateBreakpointsRequest FLATBUFFERS_FINAL_CLASS
|
|||
};
|
||||
|
||||
struct UpdateBreakpointsRequestBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_breakpoints(flatbuffers::Offset<
|
||||
flatbuffers::Vector<const Breakpoint *>> breakpoints) {
|
||||
void add_breakpoints(
|
||||
flatbuffers::Offset<flatbuffers::Vector<const Breakpoint*>> breakpoints) {
|
||||
fbb_.AddOffset(4, breakpoints);
|
||||
}
|
||||
UpdateBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
||||
UpdateBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
UpdateBreakpointsRequestBuilder &operator=(
|
||||
const UpdateBreakpointsRequestBuilder &);
|
||||
UpdateBreakpointsRequestBuilder& operator=(
|
||||
const UpdateBreakpointsRequestBuilder&);
|
||||
flatbuffers::Offset<UpdateBreakpointsRequest> Finish() {
|
||||
auto o =
|
||||
flatbuffers::Offset<UpdateBreakpointsRequest>(fbb_.EndTable(start_, 1));
|
||||
|
|
@ -215,8 +215,8 @@ struct UpdateBreakpointsRequestBuilder {
|
|||
|
||||
inline flatbuffers::Offset<UpdateBreakpointsRequest>
|
||||
CreateUpdateBreakpointsRequest(
|
||||
flatbuffers::FlatBufferBuilder &_fbb,
|
||||
flatbuffers::Offset<flatbuffers::Vector<const Breakpoint *>> breakpoints =
|
||||
flatbuffers::FlatBufferBuilder& _fbb,
|
||||
flatbuffers::Offset<flatbuffers::Vector<const Breakpoint*>> breakpoints =
|
||||
0) {
|
||||
UpdateBreakpointsRequestBuilder builder_(_fbb);
|
||||
builder_.add_breakpoints(breakpoints);
|
||||
|
|
@ -225,20 +225,20 @@ CreateUpdateBreakpointsRequest(
|
|||
|
||||
struct UpdateBreakpointsResponse FLATBUFFERS_FINAL_CLASS
|
||||
: private flatbuffers::Table {
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) && verifier.EndTable();
|
||||
}
|
||||
};
|
||||
|
||||
struct UpdateBreakpointsResponseBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
UpdateBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
||||
UpdateBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
UpdateBreakpointsResponseBuilder &operator=(
|
||||
const UpdateBreakpointsResponseBuilder &);
|
||||
UpdateBreakpointsResponseBuilder& operator=(
|
||||
const UpdateBreakpointsResponseBuilder&);
|
||||
flatbuffers::Offset<UpdateBreakpointsResponse> Finish() {
|
||||
auto o = flatbuffers::Offset<UpdateBreakpointsResponse>(
|
||||
fbb_.EndTable(start_, 0));
|
||||
|
|
@ -247,17 +247,17 @@ struct UpdateBreakpointsResponseBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<UpdateBreakpointsResponse>
|
||||
CreateUpdateBreakpointsResponse(flatbuffers::FlatBufferBuilder &_fbb) {
|
||||
CreateUpdateBreakpointsResponse(flatbuffers::FlatBufferBuilder& _fbb) {
|
||||
UpdateBreakpointsResponseBuilder builder_(_fbb);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
||||
struct RemoveBreakpointsRequest FLATBUFFERS_FINAL_CLASS
|
||||
: private flatbuffers::Table {
|
||||
const flatbuffers::Vector<const Breakpoint *> *breakpoints() const {
|
||||
return GetPointer<const flatbuffers::Vector<const Breakpoint *> *>(4);
|
||||
const flatbuffers::Vector<const Breakpoint*>* breakpoints() const {
|
||||
return GetPointer<const flatbuffers::Vector<const Breakpoint*>*>(4);
|
||||
}
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* breakpoints */) &&
|
||||
verifier.Verify(breakpoints()) && verifier.EndTable();
|
||||
|
|
@ -265,18 +265,18 @@ struct RemoveBreakpointsRequest FLATBUFFERS_FINAL_CLASS
|
|||
};
|
||||
|
||||
struct RemoveBreakpointsRequestBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_breakpoints(flatbuffers::Offset<
|
||||
flatbuffers::Vector<const Breakpoint *>> breakpoints) {
|
||||
void add_breakpoints(
|
||||
flatbuffers::Offset<flatbuffers::Vector<const Breakpoint*>> breakpoints) {
|
||||
fbb_.AddOffset(4, breakpoints);
|
||||
}
|
||||
RemoveBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
||||
RemoveBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
RemoveBreakpointsRequestBuilder &operator=(
|
||||
const RemoveBreakpointsRequestBuilder &);
|
||||
RemoveBreakpointsRequestBuilder& operator=(
|
||||
const RemoveBreakpointsRequestBuilder&);
|
||||
flatbuffers::Offset<RemoveBreakpointsRequest> Finish() {
|
||||
auto o =
|
||||
flatbuffers::Offset<RemoveBreakpointsRequest>(fbb_.EndTable(start_, 1));
|
||||
|
|
@ -286,8 +286,8 @@ struct RemoveBreakpointsRequestBuilder {
|
|||
|
||||
inline flatbuffers::Offset<RemoveBreakpointsRequest>
|
||||
CreateRemoveBreakpointsRequest(
|
||||
flatbuffers::FlatBufferBuilder &_fbb,
|
||||
flatbuffers::Offset<flatbuffers::Vector<const Breakpoint *>> breakpoints =
|
||||
flatbuffers::FlatBufferBuilder& _fbb,
|
||||
flatbuffers::Offset<flatbuffers::Vector<const Breakpoint*>> breakpoints =
|
||||
0) {
|
||||
RemoveBreakpointsRequestBuilder builder_(_fbb);
|
||||
builder_.add_breakpoints(breakpoints);
|
||||
|
|
@ -296,20 +296,20 @@ CreateRemoveBreakpointsRequest(
|
|||
|
||||
struct RemoveBreakpointsResponse FLATBUFFERS_FINAL_CLASS
|
||||
: private flatbuffers::Table {
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) && verifier.EndTable();
|
||||
}
|
||||
};
|
||||
|
||||
struct RemoveBreakpointsResponseBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
RemoveBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
||||
RemoveBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
RemoveBreakpointsResponseBuilder &operator=(
|
||||
const RemoveBreakpointsResponseBuilder &);
|
||||
RemoveBreakpointsResponseBuilder& operator=(
|
||||
const RemoveBreakpointsResponseBuilder&);
|
||||
flatbuffers::Offset<RemoveBreakpointsResponse> Finish() {
|
||||
auto o = flatbuffers::Offset<RemoveBreakpointsResponse>(
|
||||
fbb_.EndTable(start_, 0));
|
||||
|
|
@ -318,7 +318,7 @@ struct RemoveBreakpointsResponseBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<RemoveBreakpointsResponse>
|
||||
CreateRemoveBreakpointsResponse(flatbuffers::FlatBufferBuilder &_fbb) {
|
||||
CreateRemoveBreakpointsResponse(flatbuffers::FlatBufferBuilder& _fbb) {
|
||||
RemoveBreakpointsResponseBuilder builder_(_fbb);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -33,12 +33,12 @@ enum ContinueAction {
|
|||
ContinueAction_ContinueTo = 1
|
||||
};
|
||||
|
||||
inline const char **EnumNamesContinueAction() {
|
||||
static const char *names[] = {"Continue", "ContinueTo", nullptr};
|
||||
inline const char** EnumNamesContinueAction() {
|
||||
static const char* names[] = {"Continue", "ContinueTo", nullptr};
|
||||
return names;
|
||||
}
|
||||
|
||||
inline const char *EnumNameContinueAction(ContinueAction e) {
|
||||
inline const char* EnumNameContinueAction(ContinueAction e) {
|
||||
return EnumNamesContinueAction()[e];
|
||||
}
|
||||
|
||||
|
|
@ -48,28 +48,28 @@ enum StepAction {
|
|||
StepAction_StepOut = 2
|
||||
};
|
||||
|
||||
inline const char **EnumNamesStepAction() {
|
||||
static const char *names[] = {"StepIn", "StepOver", "StepOut", nullptr};
|
||||
inline const char** EnumNamesStepAction() {
|
||||
static const char* names[] = {"StepIn", "StepOver", "StepOut", nullptr};
|
||||
return names;
|
||||
}
|
||||
|
||||
inline const char *EnumNameStepAction(StepAction e) {
|
||||
inline const char* EnumNameStepAction(StepAction e) {
|
||||
return EnumNamesStepAction()[e];
|
||||
}
|
||||
|
||||
struct StopRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) && verifier.EndTable();
|
||||
}
|
||||
};
|
||||
|
||||
struct StopRequestBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
StopRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
StopRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
StopRequestBuilder &operator=(const StopRequestBuilder &);
|
||||
StopRequestBuilder& operator=(const StopRequestBuilder&);
|
||||
flatbuffers::Offset<StopRequest> Finish() {
|
||||
auto o = flatbuffers::Offset<StopRequest>(fbb_.EndTable(start_, 0));
|
||||
return o;
|
||||
|
|
@ -77,24 +77,24 @@ struct StopRequestBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<StopRequest> CreateStopRequest(
|
||||
flatbuffers::FlatBufferBuilder &_fbb) {
|
||||
flatbuffers::FlatBufferBuilder& _fbb) {
|
||||
StopRequestBuilder builder_(_fbb);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
||||
struct StopResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) && verifier.EndTable();
|
||||
}
|
||||
};
|
||||
|
||||
struct StopResponseBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
StopResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
StopResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
StopResponseBuilder &operator=(const StopResponseBuilder &);
|
||||
StopResponseBuilder& operator=(const StopResponseBuilder&);
|
||||
flatbuffers::Offset<StopResponse> Finish() {
|
||||
auto o = flatbuffers::Offset<StopResponse>(fbb_.EndTable(start_, 0));
|
||||
return o;
|
||||
|
|
@ -102,24 +102,24 @@ struct StopResponseBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<StopResponse> CreateStopResponse(
|
||||
flatbuffers::FlatBufferBuilder &_fbb) {
|
||||
flatbuffers::FlatBufferBuilder& _fbb) {
|
||||
StopResponseBuilder builder_(_fbb);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
||||
struct BreakRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) && verifier.EndTable();
|
||||
}
|
||||
};
|
||||
|
||||
struct BreakRequestBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
BreakRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
BreakRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
BreakRequestBuilder &operator=(const BreakRequestBuilder &);
|
||||
BreakRequestBuilder& operator=(const BreakRequestBuilder&);
|
||||
flatbuffers::Offset<BreakRequest> Finish() {
|
||||
auto o = flatbuffers::Offset<BreakRequest>(fbb_.EndTable(start_, 0));
|
||||
return o;
|
||||
|
|
@ -127,24 +127,24 @@ struct BreakRequestBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<BreakRequest> CreateBreakRequest(
|
||||
flatbuffers::FlatBufferBuilder &_fbb) {
|
||||
flatbuffers::FlatBufferBuilder& _fbb) {
|
||||
BreakRequestBuilder builder_(_fbb);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
||||
struct BreakResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) && verifier.EndTable();
|
||||
}
|
||||
};
|
||||
|
||||
struct BreakResponseBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
BreakResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
BreakResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
BreakResponseBuilder &operator=(const BreakResponseBuilder &);
|
||||
BreakResponseBuilder& operator=(const BreakResponseBuilder&);
|
||||
flatbuffers::Offset<BreakResponse> Finish() {
|
||||
auto o = flatbuffers::Offset<BreakResponse>(fbb_.EndTable(start_, 0));
|
||||
return o;
|
||||
|
|
@ -152,7 +152,7 @@ struct BreakResponseBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<BreakResponse> CreateBreakResponse(
|
||||
flatbuffers::FlatBufferBuilder &_fbb) {
|
||||
flatbuffers::FlatBufferBuilder& _fbb) {
|
||||
BreakResponseBuilder builder_(_fbb);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
|
@ -162,7 +162,7 @@ struct ContinueRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
return static_cast<ContinueAction>(GetField<int8_t>(4, 0));
|
||||
}
|
||||
uint32_t target_address() const { return GetField<uint32_t>(6, 0); }
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<int8_t>(verifier, 4 /* action */) &&
|
||||
VerifyField<uint32_t>(verifier, 6 /* target_address */) &&
|
||||
|
|
@ -171,7 +171,7 @@ struct ContinueRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
};
|
||||
|
||||
struct ContinueRequestBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_action(ContinueAction action) {
|
||||
fbb_.AddElement<int8_t>(4, static_cast<int8_t>(action), 0);
|
||||
|
|
@ -179,10 +179,10 @@ struct ContinueRequestBuilder {
|
|||
void add_target_address(uint32_t target_address) {
|
||||
fbb_.AddElement<uint32_t>(6, target_address, 0);
|
||||
}
|
||||
ContinueRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
ContinueRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
ContinueRequestBuilder &operator=(const ContinueRequestBuilder &);
|
||||
ContinueRequestBuilder& operator=(const ContinueRequestBuilder&);
|
||||
flatbuffers::Offset<ContinueRequest> Finish() {
|
||||
auto o = flatbuffers::Offset<ContinueRequest>(fbb_.EndTable(start_, 2));
|
||||
return o;
|
||||
|
|
@ -190,7 +190,7 @@ struct ContinueRequestBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<ContinueRequest> CreateContinueRequest(
|
||||
flatbuffers::FlatBufferBuilder &_fbb,
|
||||
flatbuffers::FlatBufferBuilder& _fbb,
|
||||
ContinueAction action = ContinueAction_Continue,
|
||||
uint32_t target_address = 0) {
|
||||
ContinueRequestBuilder builder_(_fbb);
|
||||
|
|
@ -200,18 +200,18 @@ inline flatbuffers::Offset<ContinueRequest> CreateContinueRequest(
|
|||
}
|
||||
|
||||
struct ContinueResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) && verifier.EndTable();
|
||||
}
|
||||
};
|
||||
|
||||
struct ContinueResponseBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
ContinueResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
ContinueResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
ContinueResponseBuilder &operator=(const ContinueResponseBuilder &);
|
||||
ContinueResponseBuilder& operator=(const ContinueResponseBuilder&);
|
||||
flatbuffers::Offset<ContinueResponse> Finish() {
|
||||
auto o = flatbuffers::Offset<ContinueResponse>(fbb_.EndTable(start_, 0));
|
||||
return o;
|
||||
|
|
@ -219,7 +219,7 @@ struct ContinueResponseBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<ContinueResponse> CreateContinueResponse(
|
||||
flatbuffers::FlatBufferBuilder &_fbb) {
|
||||
flatbuffers::FlatBufferBuilder& _fbb) {
|
||||
ContinueResponseBuilder builder_(_fbb);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
|
@ -229,7 +229,7 @@ struct StepRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
return static_cast<StepAction>(GetField<int8_t>(4, 0));
|
||||
}
|
||||
uint32_t thread_id() const { return GetField<uint32_t>(6, 0); }
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<int8_t>(verifier, 4 /* action */) &&
|
||||
VerifyField<uint32_t>(verifier, 6 /* thread_id */) &&
|
||||
|
|
@ -238,7 +238,7 @@ struct StepRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
};
|
||||
|
||||
struct StepRequestBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_action(StepAction action) {
|
||||
fbb_.AddElement<int8_t>(4, static_cast<int8_t>(action), 0);
|
||||
|
|
@ -246,10 +246,10 @@ struct StepRequestBuilder {
|
|||
void add_thread_id(uint32_t thread_id) {
|
||||
fbb_.AddElement<uint32_t>(6, thread_id, 0);
|
||||
}
|
||||
StepRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
StepRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
StepRequestBuilder &operator=(const StepRequestBuilder &);
|
||||
StepRequestBuilder& operator=(const StepRequestBuilder&);
|
||||
flatbuffers::Offset<StepRequest> Finish() {
|
||||
auto o = flatbuffers::Offset<StepRequest>(fbb_.EndTable(start_, 2));
|
||||
return o;
|
||||
|
|
@ -257,7 +257,7 @@ struct StepRequestBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<StepRequest> CreateStepRequest(
|
||||
flatbuffers::FlatBufferBuilder &_fbb, StepAction action = StepAction_StepIn,
|
||||
flatbuffers::FlatBufferBuilder& _fbb, StepAction action = StepAction_StepIn,
|
||||
uint32_t thread_id = 0) {
|
||||
StepRequestBuilder builder_(_fbb);
|
||||
builder_.add_thread_id(thread_id);
|
||||
|
|
@ -266,18 +266,18 @@ inline flatbuffers::Offset<StepRequest> CreateStepRequest(
|
|||
}
|
||||
|
||||
struct StepResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) && verifier.EndTable();
|
||||
}
|
||||
};
|
||||
|
||||
struct StepResponseBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
StepResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
StepResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
StepResponseBuilder &operator=(const StepResponseBuilder &);
|
||||
StepResponseBuilder& operator=(const StepResponseBuilder&);
|
||||
flatbuffers::Offset<StepResponse> Finish() {
|
||||
auto o = flatbuffers::Offset<StepResponse>(fbb_.EndTable(start_, 0));
|
||||
return o;
|
||||
|
|
@ -285,7 +285,7 @@ struct StepResponseBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<StepResponse> CreateStepResponse(
|
||||
flatbuffers::FlatBufferBuilder &_fbb) {
|
||||
flatbuffers::FlatBufferBuilder& _fbb) {
|
||||
StepResponseBuilder builder_(_fbb);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
|
@ -293,7 +293,7 @@ inline flatbuffers::Offset<StepResponse> CreateStepResponse(
|
|||
struct BreakpointEvent FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
uint32_t thread_id() const { return GetField<uint32_t>(4, 0); }
|
||||
uint32_t breakpoint_id() const { return GetField<uint32_t>(6, 0); }
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<uint32_t>(verifier, 4 /* thread_id */) &&
|
||||
VerifyField<uint32_t>(verifier, 6 /* breakpoint_id */) &&
|
||||
|
|
@ -302,7 +302,7 @@ struct BreakpointEvent FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
};
|
||||
|
||||
struct BreakpointEventBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_thread_id(uint32_t thread_id) {
|
||||
fbb_.AddElement<uint32_t>(4, thread_id, 0);
|
||||
|
|
@ -310,10 +310,10 @@ struct BreakpointEventBuilder {
|
|||
void add_breakpoint_id(uint32_t breakpoint_id) {
|
||||
fbb_.AddElement<uint32_t>(6, breakpoint_id, 0);
|
||||
}
|
||||
BreakpointEventBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
BreakpointEventBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
BreakpointEventBuilder &operator=(const BreakpointEventBuilder &);
|
||||
BreakpointEventBuilder& operator=(const BreakpointEventBuilder&);
|
||||
flatbuffers::Offset<BreakpointEvent> Finish() {
|
||||
auto o = flatbuffers::Offset<BreakpointEvent>(fbb_.EndTable(start_, 2));
|
||||
return o;
|
||||
|
|
@ -321,7 +321,7 @@ struct BreakpointEventBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<BreakpointEvent> CreateBreakpointEvent(
|
||||
flatbuffers::FlatBufferBuilder &_fbb, uint32_t thread_id = 0,
|
||||
flatbuffers::FlatBufferBuilder& _fbb, uint32_t thread_id = 0,
|
||||
uint32_t breakpoint_id = 0) {
|
||||
BreakpointEventBuilder builder_(_fbb);
|
||||
builder_.add_breakpoint_id(breakpoint_id);
|
||||
|
|
@ -333,7 +333,7 @@ struct AccessViolationEvent FLATBUFFERS_FINAL_CLASS
|
|||
: private flatbuffers::Table {
|
||||
uint32_t thread_id() const { return GetField<uint32_t>(4, 0); }
|
||||
uint32_t target_address() const { return GetField<uint32_t>(6, 0); }
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<uint32_t>(verifier, 4 /* thread_id */) &&
|
||||
VerifyField<uint32_t>(verifier, 6 /* target_address */) &&
|
||||
|
|
@ -342,7 +342,7 @@ struct AccessViolationEvent FLATBUFFERS_FINAL_CLASS
|
|||
};
|
||||
|
||||
struct AccessViolationEventBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_thread_id(uint32_t thread_id) {
|
||||
fbb_.AddElement<uint32_t>(4, thread_id, 0);
|
||||
|
|
@ -350,11 +350,11 @@ struct AccessViolationEventBuilder {
|
|||
void add_target_address(uint32_t target_address) {
|
||||
fbb_.AddElement<uint32_t>(6, target_address, 0);
|
||||
}
|
||||
AccessViolationEventBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
||||
AccessViolationEventBuilder(flatbuffers::FlatBufferBuilder& _fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
AccessViolationEventBuilder &operator=(const AccessViolationEventBuilder &);
|
||||
AccessViolationEventBuilder& operator=(const AccessViolationEventBuilder&);
|
||||
flatbuffers::Offset<AccessViolationEvent> Finish() {
|
||||
auto o =
|
||||
flatbuffers::Offset<AccessViolationEvent>(fbb_.EndTable(start_, 2));
|
||||
|
|
@ -363,7 +363,7 @@ struct AccessViolationEventBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<AccessViolationEvent> CreateAccessViolationEvent(
|
||||
flatbuffers::FlatBufferBuilder &_fbb, uint32_t thread_id = 0,
|
||||
flatbuffers::FlatBufferBuilder& _fbb, uint32_t thread_id = 0,
|
||||
uint32_t target_address = 0) {
|
||||
AccessViolationEventBuilder builder_(_fbb);
|
||||
builder_.add_target_address(target_address);
|
||||
|
|
|
|||
|
|
@ -98,8 +98,8 @@ enum RequestData {
|
|||
RequestData_StepRequest = 14
|
||||
};
|
||||
|
||||
inline const char **EnumNamesRequestData() {
|
||||
static const char *names[] = {
|
||||
inline const char** EnumNamesRequestData() {
|
||||
static const char* names[] = {
|
||||
"NONE", "AttachRequest", "ListBreakpointsRequest",
|
||||
"AddBreakpointsRequest", "UpdateBreakpointsRequest",
|
||||
"RemoveBreakpointsRequest", "ListModulesRequest", "GetModuleRequest",
|
||||
|
|
@ -108,12 +108,12 @@ inline const char **EnumNamesRequestData() {
|
|||
return names;
|
||||
}
|
||||
|
||||
inline const char *EnumNameRequestData(RequestData e) {
|
||||
inline const char* EnumNameRequestData(RequestData e) {
|
||||
return EnumNamesRequestData()[e];
|
||||
}
|
||||
|
||||
inline bool VerifyRequestData(flatbuffers::Verifier &verifier,
|
||||
const void *union_obj, RequestData type);
|
||||
inline bool VerifyRequestData(flatbuffers::Verifier& verifier,
|
||||
const void* union_obj, RequestData type);
|
||||
|
||||
enum ResponseData {
|
||||
ResponseData_NONE = 0,
|
||||
|
|
@ -135,8 +135,8 @@ enum ResponseData {
|
|||
ResponseData_AccessViolationEvent = 16
|
||||
};
|
||||
|
||||
inline const char **EnumNamesResponseData() {
|
||||
static const char *names[] = {
|
||||
inline const char** EnumNamesResponseData() {
|
||||
static const char* names[] = {
|
||||
"NONE", "AttachResponse", "ListBreakpointsResponse",
|
||||
"AddBreakpointsResponse", "UpdateBreakpointsResponse",
|
||||
"RemoveBreakpointsResponse", "ListModulesResponse", "GetModuleResponse",
|
||||
|
|
@ -146,26 +146,26 @@ inline const char **EnumNamesResponseData() {
|
|||
return names;
|
||||
}
|
||||
|
||||
inline const char *EnumNameResponseData(ResponseData e) {
|
||||
inline const char* EnumNameResponseData(ResponseData e) {
|
||||
return EnumNamesResponseData()[e];
|
||||
}
|
||||
|
||||
inline bool VerifyResponseData(flatbuffers::Verifier &verifier,
|
||||
const void *union_obj, ResponseData type);
|
||||
inline bool VerifyResponseData(flatbuffers::Verifier& verifier,
|
||||
const void* union_obj, ResponseData type);
|
||||
|
||||
struct AttachRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) && verifier.EndTable();
|
||||
}
|
||||
};
|
||||
|
||||
struct AttachRequestBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
AttachRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
AttachRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
AttachRequestBuilder &operator=(const AttachRequestBuilder &);
|
||||
AttachRequestBuilder& operator=(const AttachRequestBuilder&);
|
||||
flatbuffers::Offset<AttachRequest> Finish() {
|
||||
auto o = flatbuffers::Offset<AttachRequest>(fbb_.EndTable(start_, 0));
|
||||
return o;
|
||||
|
|
@ -173,27 +173,27 @@ struct AttachRequestBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<AttachRequest> CreateAttachRequest(
|
||||
flatbuffers::FlatBufferBuilder &_fbb) {
|
||||
flatbuffers::FlatBufferBuilder& _fbb) {
|
||||
AttachRequestBuilder builder_(_fbb);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
||||
struct AttachResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
const flatbuffers::String *memory_file() const {
|
||||
return GetPointer<const flatbuffers::String *>(4);
|
||||
const flatbuffers::String* memory_file() const {
|
||||
return GetPointer<const flatbuffers::String*>(4);
|
||||
}
|
||||
const flatbuffers::String *code_cache_file() const {
|
||||
return GetPointer<const flatbuffers::String *>(6);
|
||||
const flatbuffers::String* code_cache_file() const {
|
||||
return GetPointer<const flatbuffers::String*>(6);
|
||||
}
|
||||
uint32_t code_cache_base() const { return GetField<uint32_t>(8, 0); }
|
||||
uint32_t code_cache_size() const { return GetField<uint32_t>(10, 0); }
|
||||
const flatbuffers::String *functions_file() const {
|
||||
return GetPointer<const flatbuffers::String *>(12);
|
||||
const flatbuffers::String* functions_file() const {
|
||||
return GetPointer<const flatbuffers::String*>(12);
|
||||
}
|
||||
const flatbuffers::String *functions_trace_file() const {
|
||||
return GetPointer<const flatbuffers::String *>(14);
|
||||
const flatbuffers::String* functions_trace_file() const {
|
||||
return GetPointer<const flatbuffers::String*>(14);
|
||||
}
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* memory_file */) &&
|
||||
verifier.Verify(memory_file()) &&
|
||||
|
|
@ -212,7 +212,7 @@ struct AttachResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
};
|
||||
|
||||
struct AttachResponseBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_memory_file(flatbuffers::Offset<flatbuffers::String> memory_file) {
|
||||
fbb_.AddOffset(4, memory_file);
|
||||
|
|
@ -235,10 +235,10 @@ struct AttachResponseBuilder {
|
|||
flatbuffers::Offset<flatbuffers::String> functions_trace_file) {
|
||||
fbb_.AddOffset(14, functions_trace_file);
|
||||
}
|
||||
AttachResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
AttachResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
AttachResponseBuilder &operator=(const AttachResponseBuilder &);
|
||||
AttachResponseBuilder& operator=(const AttachResponseBuilder&);
|
||||
flatbuffers::Offset<AttachResponse> Finish() {
|
||||
auto o = flatbuffers::Offset<AttachResponse>(fbb_.EndTable(start_, 6));
|
||||
return o;
|
||||
|
|
@ -246,7 +246,7 @@ struct AttachResponseBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<AttachResponse> CreateAttachResponse(
|
||||
flatbuffers::FlatBufferBuilder &_fbb,
|
||||
flatbuffers::FlatBufferBuilder& _fbb,
|
||||
flatbuffers::Offset<flatbuffers::String> memory_file = 0,
|
||||
flatbuffers::Offset<flatbuffers::String> code_cache_file = 0,
|
||||
uint32_t code_cache_base = 0, uint32_t code_cache_size = 0,
|
||||
|
|
@ -267,8 +267,8 @@ struct Request FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
RequestData request_data_type() const {
|
||||
return static_cast<RequestData>(GetField<uint8_t>(6, 0));
|
||||
}
|
||||
const void *request_data() const { return GetPointer<const void *>(8); }
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
const void* request_data() const { return GetPointer<const void*>(8); }
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<uint32_t>(verifier, 4 /* id */) &&
|
||||
VerifyField<uint8_t>(verifier, 6 /* request_data_type */) &&
|
||||
|
|
@ -280,7 +280,7 @@ struct Request FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
};
|
||||
|
||||
struct RequestBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_id(uint32_t id) { fbb_.AddElement<uint32_t>(4, id, 0); }
|
||||
void add_request_data_type(RequestData request_data_type) {
|
||||
|
|
@ -289,10 +289,10 @@ struct RequestBuilder {
|
|||
void add_request_data(flatbuffers::Offset<void> request_data) {
|
||||
fbb_.AddOffset(8, request_data);
|
||||
}
|
||||
RequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
RequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
RequestBuilder &operator=(const RequestBuilder &);
|
||||
RequestBuilder& operator=(const RequestBuilder&);
|
||||
flatbuffers::Offset<Request> Finish() {
|
||||
auto o = flatbuffers::Offset<Request>(fbb_.EndTable(start_, 3));
|
||||
return o;
|
||||
|
|
@ -300,7 +300,7 @@ struct RequestBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<Request> CreateRequest(
|
||||
flatbuffers::FlatBufferBuilder &_fbb, uint32_t id = 0,
|
||||
flatbuffers::FlatBufferBuilder& _fbb, uint32_t id = 0,
|
||||
RequestData request_data_type = RequestData_NONE,
|
||||
flatbuffers::Offset<void> request_data = 0) {
|
||||
RequestBuilder builder_(_fbb);
|
||||
|
|
@ -315,8 +315,8 @@ struct Response FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
ResponseData response_data_type() const {
|
||||
return static_cast<ResponseData>(GetField<uint8_t>(6, 0));
|
||||
}
|
||||
const void *response_data() const { return GetPointer<const void *>(8); }
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
const void* response_data() const { return GetPointer<const void*>(8); }
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<uint32_t>(verifier, 4 /* id */) &&
|
||||
VerifyField<uint8_t>(verifier, 6 /* response_data_type */) &&
|
||||
|
|
@ -329,7 +329,7 @@ struct Response FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
};
|
||||
|
||||
struct ResponseBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_id(uint32_t id) { fbb_.AddElement<uint32_t>(4, id, 0); }
|
||||
void add_response_data_type(ResponseData response_data_type) {
|
||||
|
|
@ -338,10 +338,10 @@ struct ResponseBuilder {
|
|||
void add_response_data(flatbuffers::Offset<void> response_data) {
|
||||
fbb_.AddOffset(8, response_data);
|
||||
}
|
||||
ResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
ResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
ResponseBuilder &operator=(const ResponseBuilder &);
|
||||
ResponseBuilder& operator=(const ResponseBuilder&);
|
||||
flatbuffers::Offset<Response> Finish() {
|
||||
auto o = flatbuffers::Offset<Response>(fbb_.EndTable(start_, 3));
|
||||
return o;
|
||||
|
|
@ -349,7 +349,7 @@ struct ResponseBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<Response> CreateResponse(
|
||||
flatbuffers::FlatBufferBuilder &_fbb, uint32_t id = 0,
|
||||
flatbuffers::FlatBufferBuilder& _fbb, uint32_t id = 0,
|
||||
ResponseData response_data_type = ResponseData_NONE,
|
||||
flatbuffers::Offset<void> response_data = 0) {
|
||||
ResponseBuilder builder_(_fbb);
|
||||
|
|
@ -359,132 +359,132 @@ inline flatbuffers::Offset<Response> CreateResponse(
|
|||
return builder_.Finish();
|
||||
}
|
||||
|
||||
inline bool VerifyRequestData(flatbuffers::Verifier &verifier,
|
||||
const void *union_obj, RequestData type) {
|
||||
inline bool VerifyRequestData(flatbuffers::Verifier& verifier,
|
||||
const void* union_obj, RequestData type) {
|
||||
switch (type) {
|
||||
case RequestData_NONE:
|
||||
return true;
|
||||
case RequestData_AttachRequest:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const AttachRequest *>(union_obj));
|
||||
reinterpret_cast<const AttachRequest*>(union_obj));
|
||||
case RequestData_ListBreakpointsRequest:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::ListBreakpointsRequest *>(
|
||||
reinterpret_cast<const xe::debug::proto::ListBreakpointsRequest*>(
|
||||
union_obj));
|
||||
case RequestData_AddBreakpointsRequest:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::AddBreakpointsRequest *>(
|
||||
reinterpret_cast<const xe::debug::proto::AddBreakpointsRequest*>(
|
||||
union_obj));
|
||||
case RequestData_UpdateBreakpointsRequest:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::UpdateBreakpointsRequest *>(
|
||||
reinterpret_cast<const xe::debug::proto::UpdateBreakpointsRequest*>(
|
||||
union_obj));
|
||||
case RequestData_RemoveBreakpointsRequest:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::RemoveBreakpointsRequest *>(
|
||||
reinterpret_cast<const xe::debug::proto::RemoveBreakpointsRequest*>(
|
||||
union_obj));
|
||||
case RequestData_ListModulesRequest:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::ListModulesRequest *>(
|
||||
reinterpret_cast<const xe::debug::proto::ListModulesRequest*>(
|
||||
union_obj));
|
||||
case RequestData_GetModuleRequest:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::GetModuleRequest *>(
|
||||
reinterpret_cast<const xe::debug::proto::GetModuleRequest*>(
|
||||
union_obj));
|
||||
case RequestData_ListFunctionsRequest:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::ListFunctionsRequest *>(
|
||||
reinterpret_cast<const xe::debug::proto::ListFunctionsRequest*>(
|
||||
union_obj));
|
||||
case RequestData_GetFunctionRequest:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::GetFunctionRequest *>(
|
||||
reinterpret_cast<const xe::debug::proto::GetFunctionRequest*>(
|
||||
union_obj));
|
||||
case RequestData_ListThreadsRequest:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::ListThreadsRequest *>(
|
||||
reinterpret_cast<const xe::debug::proto::ListThreadsRequest*>(
|
||||
union_obj));
|
||||
case RequestData_StopRequest:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::StopRequest *>(union_obj));
|
||||
reinterpret_cast<const xe::debug::proto::StopRequest*>(union_obj));
|
||||
case RequestData_BreakRequest:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::BreakRequest *>(union_obj));
|
||||
reinterpret_cast<const xe::debug::proto::BreakRequest*>(union_obj));
|
||||
case RequestData_ContinueRequest:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::ContinueRequest *>(
|
||||
reinterpret_cast<const xe::debug::proto::ContinueRequest*>(
|
||||
union_obj));
|
||||
case RequestData_StepRequest:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::StepRequest *>(union_obj));
|
||||
reinterpret_cast<const xe::debug::proto::StepRequest*>(union_obj));
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
inline bool VerifyResponseData(flatbuffers::Verifier &verifier,
|
||||
const void *union_obj, ResponseData type) {
|
||||
inline bool VerifyResponseData(flatbuffers::Verifier& verifier,
|
||||
const void* union_obj, ResponseData type) {
|
||||
switch (type) {
|
||||
case ResponseData_NONE:
|
||||
return true;
|
||||
case ResponseData_AttachResponse:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const AttachResponse *>(union_obj));
|
||||
reinterpret_cast<const AttachResponse*>(union_obj));
|
||||
case ResponseData_ListBreakpointsResponse:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::ListBreakpointsResponse *>(
|
||||
reinterpret_cast<const xe::debug::proto::ListBreakpointsResponse*>(
|
||||
union_obj));
|
||||
case ResponseData_AddBreakpointsResponse:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::AddBreakpointsResponse *>(
|
||||
reinterpret_cast<const xe::debug::proto::AddBreakpointsResponse*>(
|
||||
union_obj));
|
||||
case ResponseData_UpdateBreakpointsResponse:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::UpdateBreakpointsResponse *>(
|
||||
reinterpret_cast<const xe::debug::proto::UpdateBreakpointsResponse*>(
|
||||
union_obj));
|
||||
case ResponseData_RemoveBreakpointsResponse:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::RemoveBreakpointsResponse *>(
|
||||
reinterpret_cast<const xe::debug::proto::RemoveBreakpointsResponse*>(
|
||||
union_obj));
|
||||
case ResponseData_ListModulesResponse:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::ListModulesResponse *>(
|
||||
reinterpret_cast<const xe::debug::proto::ListModulesResponse*>(
|
||||
union_obj));
|
||||
case ResponseData_GetModuleResponse:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::GetModuleResponse *>(
|
||||
reinterpret_cast<const xe::debug::proto::GetModuleResponse*>(
|
||||
union_obj));
|
||||
case ResponseData_ListFunctionsResponse:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::ListFunctionsResponse *>(
|
||||
reinterpret_cast<const xe::debug::proto::ListFunctionsResponse*>(
|
||||
union_obj));
|
||||
case ResponseData_GetFunctionResponse:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::GetFunctionResponse *>(
|
||||
reinterpret_cast<const xe::debug::proto::GetFunctionResponse*>(
|
||||
union_obj));
|
||||
case ResponseData_ListThreadsResponse:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::ListThreadsResponse *>(
|
||||
reinterpret_cast<const xe::debug::proto::ListThreadsResponse*>(
|
||||
union_obj));
|
||||
case ResponseData_StopResponse:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::StopResponse *>(union_obj));
|
||||
reinterpret_cast<const xe::debug::proto::StopResponse*>(union_obj));
|
||||
case ResponseData_BreakResponse:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::BreakResponse *>(union_obj));
|
||||
reinterpret_cast<const xe::debug::proto::BreakResponse*>(union_obj));
|
||||
case ResponseData_ContinueResponse:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::ContinueResponse *>(
|
||||
reinterpret_cast<const xe::debug::proto::ContinueResponse*>(
|
||||
union_obj));
|
||||
case ResponseData_StepResponse:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::StepResponse *>(union_obj));
|
||||
reinterpret_cast<const xe::debug::proto::StepResponse*>(union_obj));
|
||||
case ResponseData_BreakpointEvent:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::BreakpointEvent *>(
|
||||
reinterpret_cast<const xe::debug::proto::BreakpointEvent*>(
|
||||
union_obj));
|
||||
case ResponseData_AccessViolationEvent:
|
||||
return verifier.VerifyTable(
|
||||
reinterpret_cast<const xe::debug::proto::AccessViolationEvent *>(
|
||||
reinterpret_cast<const xe::debug::proto::AccessViolationEvent*>(
|
||||
union_obj));
|
||||
default:
|
||||
return false;
|
||||
|
|
|
|||
|
|
@ -32,12 +32,12 @@ struct GetFunctionResponse;
|
|||
|
||||
enum ModuleType { ModuleType_Kernel = 0, ModuleType_User = 1 };
|
||||
|
||||
inline const char **EnumNamesModuleType() {
|
||||
static const char *names[] = {"Kernel", "User", nullptr};
|
||||
inline const char** EnumNamesModuleType() {
|
||||
static const char* names[] = {"Kernel", "User", nullptr};
|
||||
return names;
|
||||
}
|
||||
|
||||
inline const char *EnumNameModuleType(ModuleType e) {
|
||||
inline const char* EnumNameModuleType(ModuleType e) {
|
||||
return EnumNamesModuleType()[e];
|
||||
}
|
||||
|
||||
|
|
@ -59,19 +59,19 @@ MANUALLY_ALIGNED_STRUCT(4) ListModuleEntry FLATBUFFERS_FINAL_CLASS {
|
|||
STRUCT_END(ListModuleEntry, 8);
|
||||
|
||||
struct Module FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
const xe::debug::proto::XObject *object() const {
|
||||
return GetStruct<const xe::debug::proto::XObject *>(4);
|
||||
const xe::debug::proto::XObject* object() const {
|
||||
return GetStruct<const xe::debug::proto::XObject*>(4);
|
||||
}
|
||||
ModuleType type() const {
|
||||
return static_cast<ModuleType>(GetField<int8_t>(6, 0));
|
||||
}
|
||||
const flatbuffers::String *name() const {
|
||||
return GetPointer<const flatbuffers::String *>(8);
|
||||
const flatbuffers::String* name() const {
|
||||
return GetPointer<const flatbuffers::String*>(8);
|
||||
}
|
||||
const flatbuffers::String *path() const {
|
||||
return GetPointer<const flatbuffers::String *>(10);
|
||||
const flatbuffers::String* path() const {
|
||||
return GetPointer<const flatbuffers::String*>(10);
|
||||
}
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<xe::debug::proto::XObject>(verifier, 4 /* object */) &&
|
||||
VerifyField<int8_t>(verifier, 6 /* type */) &&
|
||||
|
|
@ -83,9 +83,9 @@ struct Module FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
};
|
||||
|
||||
struct ModuleBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_object(const xe::debug::proto::XObject *object) {
|
||||
void add_object(const xe::debug::proto::XObject* object) {
|
||||
fbb_.AddStruct(4, object);
|
||||
}
|
||||
void add_type(ModuleType type) {
|
||||
|
|
@ -97,10 +97,10 @@ struct ModuleBuilder {
|
|||
void add_path(flatbuffers::Offset<flatbuffers::String> path) {
|
||||
fbb_.AddOffset(10, path);
|
||||
}
|
||||
ModuleBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
ModuleBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
ModuleBuilder &operator=(const ModuleBuilder &);
|
||||
ModuleBuilder& operator=(const ModuleBuilder&);
|
||||
flatbuffers::Offset<Module> Finish() {
|
||||
auto o = flatbuffers::Offset<Module>(fbb_.EndTable(start_, 4));
|
||||
return o;
|
||||
|
|
@ -108,8 +108,8 @@ struct ModuleBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<Module> CreateModule(
|
||||
flatbuffers::FlatBufferBuilder &_fbb,
|
||||
const xe::debug::proto::XObject *object = 0,
|
||||
flatbuffers::FlatBufferBuilder& _fbb,
|
||||
const xe::debug::proto::XObject* object = 0,
|
||||
ModuleType type = ModuleType_Kernel,
|
||||
flatbuffers::Offset<flatbuffers::String> name = 0,
|
||||
flatbuffers::Offset<flatbuffers::String> path = 0) {
|
||||
|
|
@ -122,18 +122,18 @@ inline flatbuffers::Offset<Module> CreateModule(
|
|||
}
|
||||
|
||||
struct ListModulesRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) && verifier.EndTable();
|
||||
}
|
||||
};
|
||||
|
||||
struct ListModulesRequestBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
ListModulesRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
ListModulesRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
ListModulesRequestBuilder &operator=(const ListModulesRequestBuilder &);
|
||||
ListModulesRequestBuilder& operator=(const ListModulesRequestBuilder&);
|
||||
flatbuffers::Offset<ListModulesRequest> Finish() {
|
||||
auto o = flatbuffers::Offset<ListModulesRequest>(fbb_.EndTable(start_, 0));
|
||||
return o;
|
||||
|
|
@ -141,17 +141,17 @@ struct ListModulesRequestBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<ListModulesRequest> CreateListModulesRequest(
|
||||
flatbuffers::FlatBufferBuilder &_fbb) {
|
||||
flatbuffers::FlatBufferBuilder& _fbb) {
|
||||
ListModulesRequestBuilder builder_(_fbb);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
||||
struct ListModulesResponse FLATBUFFERS_FINAL_CLASS
|
||||
: private flatbuffers::Table {
|
||||
const flatbuffers::Vector<const ListModuleEntry *> *entry() const {
|
||||
return GetPointer<const flatbuffers::Vector<const ListModuleEntry *> *>(4);
|
||||
const flatbuffers::Vector<const ListModuleEntry*>* entry() const {
|
||||
return GetPointer<const flatbuffers::Vector<const ListModuleEntry*>*>(4);
|
||||
}
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* entry */) &&
|
||||
verifier.Verify(entry()) && verifier.EndTable();
|
||||
|
|
@ -159,17 +159,17 @@ struct ListModulesResponse FLATBUFFERS_FINAL_CLASS
|
|||
};
|
||||
|
||||
struct ListModulesResponseBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_entry(
|
||||
flatbuffers::Offset<flatbuffers::Vector<const ListModuleEntry *>> entry) {
|
||||
flatbuffers::Offset<flatbuffers::Vector<const ListModuleEntry*>> entry) {
|
||||
fbb_.AddOffset(4, entry);
|
||||
}
|
||||
ListModulesResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
||||
ListModulesResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
ListModulesResponseBuilder &operator=(const ListModulesResponseBuilder &);
|
||||
ListModulesResponseBuilder& operator=(const ListModulesResponseBuilder&);
|
||||
flatbuffers::Offset<ListModulesResponse> Finish() {
|
||||
auto o = flatbuffers::Offset<ListModulesResponse>(fbb_.EndTable(start_, 1));
|
||||
return o;
|
||||
|
|
@ -177,8 +177,8 @@ struct ListModulesResponseBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<ListModulesResponse> CreateListModulesResponse(
|
||||
flatbuffers::FlatBufferBuilder &_fbb,
|
||||
flatbuffers::Offset<flatbuffers::Vector<const ListModuleEntry *>> entry =
|
||||
flatbuffers::FlatBufferBuilder& _fbb,
|
||||
flatbuffers::Offset<flatbuffers::Vector<const ListModuleEntry*>> entry =
|
||||
0) {
|
||||
ListModulesResponseBuilder builder_(_fbb);
|
||||
builder_.add_entry(entry);
|
||||
|
|
@ -187,7 +187,7 @@ inline flatbuffers::Offset<ListModulesResponse> CreateListModulesResponse(
|
|||
|
||||
struct GetModuleRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
uint32_t module_id() const { return GetField<uint32_t>(4, 0); }
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<uint32_t>(verifier, 4 /* module_id */) &&
|
||||
verifier.EndTable();
|
||||
|
|
@ -195,15 +195,15 @@ struct GetModuleRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
};
|
||||
|
||||
struct GetModuleRequestBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_module_id(uint32_t module_id) {
|
||||
fbb_.AddElement<uint32_t>(4, module_id, 0);
|
||||
}
|
||||
GetModuleRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
GetModuleRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
GetModuleRequestBuilder &operator=(const GetModuleRequestBuilder &);
|
||||
GetModuleRequestBuilder& operator=(const GetModuleRequestBuilder&);
|
||||
flatbuffers::Offset<GetModuleRequest> Finish() {
|
||||
auto o = flatbuffers::Offset<GetModuleRequest>(fbb_.EndTable(start_, 1));
|
||||
return o;
|
||||
|
|
@ -211,15 +211,15 @@ struct GetModuleRequestBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<GetModuleRequest> CreateGetModuleRequest(
|
||||
flatbuffers::FlatBufferBuilder &_fbb, uint32_t module_id = 0) {
|
||||
flatbuffers::FlatBufferBuilder& _fbb, uint32_t module_id = 0) {
|
||||
GetModuleRequestBuilder builder_(_fbb);
|
||||
builder_.add_module_id(module_id);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
||||
struct GetModuleResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
const Module *module() const { return GetPointer<const Module *>(4); }
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
const Module* module() const { return GetPointer<const Module*>(4); }
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* module */) &&
|
||||
verifier.VerifyTable(module()) && verifier.EndTable();
|
||||
|
|
@ -227,15 +227,15 @@ struct GetModuleResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
};
|
||||
|
||||
struct GetModuleResponseBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_module(flatbuffers::Offset<Module> module) {
|
||||
fbb_.AddOffset(4, module);
|
||||
}
|
||||
GetModuleResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
GetModuleResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
GetModuleResponseBuilder &operator=(const GetModuleResponseBuilder &);
|
||||
GetModuleResponseBuilder& operator=(const GetModuleResponseBuilder&);
|
||||
flatbuffers::Offset<GetModuleResponse> Finish() {
|
||||
auto o = flatbuffers::Offset<GetModuleResponse>(fbb_.EndTable(start_, 1));
|
||||
return o;
|
||||
|
|
@ -243,7 +243,7 @@ struct GetModuleResponseBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<GetModuleResponse> CreateGetModuleResponse(
|
||||
flatbuffers::FlatBufferBuilder &_fbb,
|
||||
flatbuffers::FlatBufferBuilder& _fbb,
|
||||
flatbuffers::Offset<Module> module = 0) {
|
||||
GetModuleResponseBuilder builder_(_fbb);
|
||||
builder_.add_module(module);
|
||||
|
|
@ -254,10 +254,10 @@ struct FunctionEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
uint64_t identifier() const { return GetField<uint64_t>(4, 0); }
|
||||
uint32_t address_start() const { return GetField<uint32_t>(6, 0); }
|
||||
uint32_t address_end() const { return GetField<uint32_t>(8, 0); }
|
||||
const flatbuffers::String *name() const {
|
||||
return GetPointer<const flatbuffers::String *>(10);
|
||||
const flatbuffers::String* name() const {
|
||||
return GetPointer<const flatbuffers::String*>(10);
|
||||
}
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<uint64_t>(verifier, 4 /* identifier */) &&
|
||||
VerifyField<uint32_t>(verifier, 6 /* address_start */) &&
|
||||
|
|
@ -268,7 +268,7 @@ struct FunctionEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
};
|
||||
|
||||
struct FunctionEntryBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_identifier(uint64_t identifier) {
|
||||
fbb_.AddElement<uint64_t>(4, identifier, 0);
|
||||
|
|
@ -282,10 +282,10 @@ struct FunctionEntryBuilder {
|
|||
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
|
||||
fbb_.AddOffset(10, name);
|
||||
}
|
||||
FunctionEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
FunctionEntryBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
FunctionEntryBuilder &operator=(const FunctionEntryBuilder &);
|
||||
FunctionEntryBuilder& operator=(const FunctionEntryBuilder&);
|
||||
flatbuffers::Offset<FunctionEntry> Finish() {
|
||||
auto o = flatbuffers::Offset<FunctionEntry>(fbb_.EndTable(start_, 4));
|
||||
return o;
|
||||
|
|
@ -293,7 +293,7 @@ struct FunctionEntryBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<FunctionEntry> CreateFunctionEntry(
|
||||
flatbuffers::FlatBufferBuilder &_fbb, uint64_t identifier = 0,
|
||||
flatbuffers::FlatBufferBuilder& _fbb, uint64_t identifier = 0,
|
||||
uint32_t address_start = 0, uint32_t address_end = 0,
|
||||
flatbuffers::Offset<flatbuffers::String> name = 0) {
|
||||
FunctionEntryBuilder builder_(_fbb);
|
||||
|
|
@ -308,18 +308,18 @@ struct Function FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
uint64_t identifier() const { return GetField<uint64_t>(4, 0); }
|
||||
uint32_t address_start() const { return GetField<uint32_t>(6, 0); }
|
||||
uint32_t address_end() const { return GetField<uint32_t>(8, 0); }
|
||||
const flatbuffers::String *name() const {
|
||||
return GetPointer<const flatbuffers::String *>(10);
|
||||
const flatbuffers::String* name() const {
|
||||
return GetPointer<const flatbuffers::String*>(10);
|
||||
}
|
||||
uint32_t machine_code_start() const { return GetField<uint32_t>(12, 0); }
|
||||
uint32_t machine_code_end() const { return GetField<uint32_t>(14, 0); }
|
||||
const flatbuffers::String *disasm_hir_raw() const {
|
||||
return GetPointer<const flatbuffers::String *>(16);
|
||||
const flatbuffers::String* disasm_hir_raw() const {
|
||||
return GetPointer<const flatbuffers::String*>(16);
|
||||
}
|
||||
const flatbuffers::String *disasm_hir_opt() const {
|
||||
return GetPointer<const flatbuffers::String *>(18);
|
||||
const flatbuffers::String* disasm_hir_opt() const {
|
||||
return GetPointer<const flatbuffers::String*>(18);
|
||||
}
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<uint64_t>(verifier, 4 /* identifier */) &&
|
||||
VerifyField<uint32_t>(verifier, 6 /* address_start */) &&
|
||||
|
|
@ -338,7 +338,7 @@ struct Function FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
};
|
||||
|
||||
struct FunctionBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_identifier(uint64_t identifier) {
|
||||
fbb_.AddElement<uint64_t>(4, identifier, 0);
|
||||
|
|
@ -366,10 +366,10 @@ struct FunctionBuilder {
|
|||
flatbuffers::Offset<flatbuffers::String> disasm_hir_opt) {
|
||||
fbb_.AddOffset(18, disasm_hir_opt);
|
||||
}
|
||||
FunctionBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
FunctionBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
FunctionBuilder &operator=(const FunctionBuilder &);
|
||||
FunctionBuilder& operator=(const FunctionBuilder&);
|
||||
flatbuffers::Offset<Function> Finish() {
|
||||
auto o = flatbuffers::Offset<Function>(fbb_.EndTable(start_, 8));
|
||||
return o;
|
||||
|
|
@ -377,7 +377,7 @@ struct FunctionBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<Function> CreateFunction(
|
||||
flatbuffers::FlatBufferBuilder &_fbb, uint64_t identifier = 0,
|
||||
flatbuffers::FlatBufferBuilder& _fbb, uint64_t identifier = 0,
|
||||
uint32_t address_start = 0, uint32_t address_end = 0,
|
||||
flatbuffers::Offset<flatbuffers::String> name = 0,
|
||||
uint32_t machine_code_start = 0, uint32_t machine_code_end = 0,
|
||||
|
|
@ -400,7 +400,7 @@ struct ListFunctionsRequest FLATBUFFERS_FINAL_CLASS
|
|||
uint32_t module_id() const { return GetField<uint32_t>(4, 0); }
|
||||
uint32_t function_index_start() const { return GetField<uint32_t>(6, 0); }
|
||||
uint32_t function_index_end() const { return GetField<uint32_t>(8, 0); }
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<uint32_t>(verifier, 4 /* module_id */) &&
|
||||
VerifyField<uint32_t>(verifier, 6 /* function_index_start */) &&
|
||||
|
|
@ -410,7 +410,7 @@ struct ListFunctionsRequest FLATBUFFERS_FINAL_CLASS
|
|||
};
|
||||
|
||||
struct ListFunctionsRequestBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_module_id(uint32_t module_id) {
|
||||
fbb_.AddElement<uint32_t>(4, module_id, 0);
|
||||
|
|
@ -421,11 +421,11 @@ struct ListFunctionsRequestBuilder {
|
|||
void add_function_index_end(uint32_t function_index_end) {
|
||||
fbb_.AddElement<uint32_t>(8, function_index_end, 0);
|
||||
}
|
||||
ListFunctionsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
||||
ListFunctionsRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
ListFunctionsRequestBuilder &operator=(const ListFunctionsRequestBuilder &);
|
||||
ListFunctionsRequestBuilder& operator=(const ListFunctionsRequestBuilder&);
|
||||
flatbuffers::Offset<ListFunctionsRequest> Finish() {
|
||||
auto o =
|
||||
flatbuffers::Offset<ListFunctionsRequest>(fbb_.EndTable(start_, 3));
|
||||
|
|
@ -434,7 +434,7 @@ struct ListFunctionsRequestBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<ListFunctionsRequest> CreateListFunctionsRequest(
|
||||
flatbuffers::FlatBufferBuilder &_fbb, uint32_t module_id = 0,
|
||||
flatbuffers::FlatBufferBuilder& _fbb, uint32_t module_id = 0,
|
||||
uint32_t function_index_start = 0, uint32_t function_index_end = 0) {
|
||||
ListFunctionsRequestBuilder builder_(_fbb);
|
||||
builder_.add_function_index_end(function_index_end);
|
||||
|
|
@ -445,11 +445,11 @@ inline flatbuffers::Offset<ListFunctionsRequest> CreateListFunctionsRequest(
|
|||
|
||||
struct ListFunctionsResponse FLATBUFFERS_FINAL_CLASS
|
||||
: private flatbuffers::Table {
|
||||
const flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>> *entry() const {
|
||||
const flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>>* entry() const {
|
||||
return GetPointer<
|
||||
const flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>> *>(4);
|
||||
const flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>>*>(4);
|
||||
}
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* entry */) &&
|
||||
verifier.Verify(entry()) && verifier.VerifyVectorOfTables(entry()) &&
|
||||
|
|
@ -458,17 +458,17 @@ struct ListFunctionsResponse FLATBUFFERS_FINAL_CLASS
|
|||
};
|
||||
|
||||
struct ListFunctionsResponseBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_entry(flatbuffers::Offset<
|
||||
flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>>> entry) {
|
||||
fbb_.AddOffset(4, entry);
|
||||
}
|
||||
ListFunctionsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
||||
ListFunctionsResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
ListFunctionsResponseBuilder &operator=(const ListFunctionsResponseBuilder &);
|
||||
ListFunctionsResponseBuilder& operator=(const ListFunctionsResponseBuilder&);
|
||||
flatbuffers::Offset<ListFunctionsResponse> Finish() {
|
||||
auto o =
|
||||
flatbuffers::Offset<ListFunctionsResponse>(fbb_.EndTable(start_, 1));
|
||||
|
|
@ -477,7 +477,7 @@ struct ListFunctionsResponseBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<ListFunctionsResponse> CreateListFunctionsResponse(
|
||||
flatbuffers::FlatBufferBuilder &_fbb,
|
||||
flatbuffers::FlatBufferBuilder& _fbb,
|
||||
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>>>
|
||||
entry = 0) {
|
||||
ListFunctionsResponseBuilder builder_(_fbb);
|
||||
|
|
@ -487,7 +487,7 @@ inline flatbuffers::Offset<ListFunctionsResponse> CreateListFunctionsResponse(
|
|||
|
||||
struct GetFunctionRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
uint64_t identifier() const { return GetField<uint64_t>(4, 0); }
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<uint64_t>(verifier, 4 /* identifier */) &&
|
||||
verifier.EndTable();
|
||||
|
|
@ -495,15 +495,15 @@ struct GetFunctionRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
};
|
||||
|
||||
struct GetFunctionRequestBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_identifier(uint64_t identifier) {
|
||||
fbb_.AddElement<uint64_t>(4, identifier, 0);
|
||||
}
|
||||
GetFunctionRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
GetFunctionRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
GetFunctionRequestBuilder &operator=(const GetFunctionRequestBuilder &);
|
||||
GetFunctionRequestBuilder& operator=(const GetFunctionRequestBuilder&);
|
||||
flatbuffers::Offset<GetFunctionRequest> Finish() {
|
||||
auto o = flatbuffers::Offset<GetFunctionRequest>(fbb_.EndTable(start_, 1));
|
||||
return o;
|
||||
|
|
@ -511,7 +511,7 @@ struct GetFunctionRequestBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<GetFunctionRequest> CreateGetFunctionRequest(
|
||||
flatbuffers::FlatBufferBuilder &_fbb, uint64_t identifier = 0) {
|
||||
flatbuffers::FlatBufferBuilder& _fbb, uint64_t identifier = 0) {
|
||||
GetFunctionRequestBuilder builder_(_fbb);
|
||||
builder_.add_identifier(identifier);
|
||||
return builder_.Finish();
|
||||
|
|
@ -519,8 +519,8 @@ inline flatbuffers::Offset<GetFunctionRequest> CreateGetFunctionRequest(
|
|||
|
||||
struct GetFunctionResponse FLATBUFFERS_FINAL_CLASS
|
||||
: private flatbuffers::Table {
|
||||
const Function *function() const { return GetPointer<const Function *>(4); }
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
const Function* function() const { return GetPointer<const Function*>(4); }
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* function */) &&
|
||||
verifier.VerifyTable(function()) && verifier.EndTable();
|
||||
|
|
@ -528,16 +528,16 @@ struct GetFunctionResponse FLATBUFFERS_FINAL_CLASS
|
|||
};
|
||||
|
||||
struct GetFunctionResponseBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_function(flatbuffers::Offset<Function> function) {
|
||||
fbb_.AddOffset(4, function);
|
||||
}
|
||||
GetFunctionResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
||||
GetFunctionResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
GetFunctionResponseBuilder &operator=(const GetFunctionResponseBuilder &);
|
||||
GetFunctionResponseBuilder& operator=(const GetFunctionResponseBuilder&);
|
||||
flatbuffers::Offset<GetFunctionResponse> Finish() {
|
||||
auto o = flatbuffers::Offset<GetFunctionResponse>(fbb_.EndTable(start_, 1));
|
||||
return o;
|
||||
|
|
@ -545,7 +545,7 @@ struct GetFunctionResponseBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<GetFunctionResponse> CreateGetFunctionResponse(
|
||||
flatbuffers::FlatBufferBuilder &_fbb,
|
||||
flatbuffers::FlatBufferBuilder& _fbb,
|
||||
flatbuffers::Offset<Function> function = 0) {
|
||||
GetFunctionResponseBuilder builder_(_fbb);
|
||||
builder_.add_function(function);
|
||||
|
|
|
|||
|
|
@ -23,18 +23,18 @@ struct ListThreadsResponse;
|
|||
|
||||
enum ThreadType { ThreadType_Kernel = 0, ThreadType_User = 1 };
|
||||
|
||||
inline const char **EnumNamesThreadType() {
|
||||
static const char *names[] = {"Kernel", "User", nullptr};
|
||||
inline const char** EnumNamesThreadType() {
|
||||
static const char* names[] = {"Kernel", "User", nullptr};
|
||||
return names;
|
||||
}
|
||||
|
||||
inline const char *EnumNameThreadType(ThreadType e) {
|
||||
inline const char* EnumNameThreadType(ThreadType e) {
|
||||
return EnumNamesThreadType()[e];
|
||||
}
|
||||
|
||||
struct Thread FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
const xe::debug::proto::XObject *object() const {
|
||||
return GetStruct<const xe::debug::proto::XObject *>(4);
|
||||
const xe::debug::proto::XObject* object() const {
|
||||
return GetStruct<const xe::debug::proto::XObject*>(4);
|
||||
}
|
||||
ThreadType type() const {
|
||||
return static_cast<ThreadType>(GetField<int8_t>(6, 0));
|
||||
|
|
@ -48,13 +48,13 @@ struct Thread FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
uint32_t pcr_address() const { return GetField<uint32_t>(20, 0); }
|
||||
uint32_t thread_state_address() const { return GetField<uint32_t>(22, 0); }
|
||||
uint32_t thread_id() const { return GetField<uint32_t>(24, 0); }
|
||||
const flatbuffers::String *name() const {
|
||||
return GetPointer<const flatbuffers::String *>(26);
|
||||
const flatbuffers::String* name() const {
|
||||
return GetPointer<const flatbuffers::String*>(26);
|
||||
}
|
||||
uint32_t priority() const { return GetField<uint32_t>(28, 0); }
|
||||
uint32_t affinity() const { return GetField<uint32_t>(30, 0); }
|
||||
uint32_t state() const { return GetField<uint32_t>(32, 0); }
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<xe::debug::proto::XObject>(verifier, 4 /* object */) &&
|
||||
VerifyField<int8_t>(verifier, 6 /* type */) &&
|
||||
|
|
@ -77,9 +77,9 @@ struct Thread FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|||
};
|
||||
|
||||
struct ThreadBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_object(const xe::debug::proto::XObject *object) {
|
||||
void add_object(const xe::debug::proto::XObject* object) {
|
||||
fbb_.AddStruct(4, object);
|
||||
}
|
||||
void add_type(ThreadType type) {
|
||||
|
|
@ -122,10 +122,10 @@ struct ThreadBuilder {
|
|||
fbb_.AddElement<uint32_t>(30, affinity, 0);
|
||||
}
|
||||
void add_state(uint32_t state) { fbb_.AddElement<uint32_t>(32, state, 0); }
|
||||
ThreadBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
ThreadBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
ThreadBuilder &operator=(const ThreadBuilder &);
|
||||
ThreadBuilder& operator=(const ThreadBuilder&);
|
||||
flatbuffers::Offset<Thread> Finish() {
|
||||
auto o = flatbuffers::Offset<Thread>(fbb_.EndTable(start_, 15));
|
||||
return o;
|
||||
|
|
@ -133,8 +133,8 @@ struct ThreadBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<Thread> CreateThread(
|
||||
flatbuffers::FlatBufferBuilder &_fbb,
|
||||
const xe::debug::proto::XObject *object = 0,
|
||||
flatbuffers::FlatBufferBuilder& _fbb,
|
||||
const xe::debug::proto::XObject* object = 0,
|
||||
ThreadType type = ThreadType_Kernel, uint32_t stack_size = 0,
|
||||
uint32_t xapi_thread_startup = 0, uint32_t start_address = 0,
|
||||
uint32_t start_context = 0, uint32_t creation_flags = 0,
|
||||
|
|
@ -162,18 +162,18 @@ inline flatbuffers::Offset<Thread> CreateThread(
|
|||
}
|
||||
|
||||
struct ListThreadsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) && verifier.EndTable();
|
||||
}
|
||||
};
|
||||
|
||||
struct ListThreadsRequestBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
ListThreadsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
|
||||
ListThreadsRequestBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
ListThreadsRequestBuilder &operator=(const ListThreadsRequestBuilder &);
|
||||
ListThreadsRequestBuilder& operator=(const ListThreadsRequestBuilder&);
|
||||
flatbuffers::Offset<ListThreadsRequest> Finish() {
|
||||
auto o = flatbuffers::Offset<ListThreadsRequest>(fbb_.EndTable(start_, 0));
|
||||
return o;
|
||||
|
|
@ -181,18 +181,18 @@ struct ListThreadsRequestBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<ListThreadsRequest> CreateListThreadsRequest(
|
||||
flatbuffers::FlatBufferBuilder &_fbb) {
|
||||
flatbuffers::FlatBufferBuilder& _fbb) {
|
||||
ListThreadsRequestBuilder builder_(_fbb);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
||||
struct ListThreadsResponse FLATBUFFERS_FINAL_CLASS
|
||||
: private flatbuffers::Table {
|
||||
const flatbuffers::Vector<flatbuffers::Offset<Thread>> *thread() const {
|
||||
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Thread>> *>(
|
||||
const flatbuffers::Vector<flatbuffers::Offset<Thread>>* thread() const {
|
||||
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Thread>>*>(
|
||||
4);
|
||||
}
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(flatbuffers::Verifier& verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* thread */) &&
|
||||
verifier.Verify(thread()) &&
|
||||
|
|
@ -201,17 +201,17 @@ struct ListThreadsResponse FLATBUFFERS_FINAL_CLASS
|
|||
};
|
||||
|
||||
struct ListThreadsResponseBuilder {
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::FlatBufferBuilder& fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
void add_thread(flatbuffers::Offset<
|
||||
flatbuffers::Vector<flatbuffers::Offset<Thread>>> thread) {
|
||||
fbb_.AddOffset(4, thread);
|
||||
}
|
||||
ListThreadsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
||||
ListThreadsResponseBuilder(flatbuffers::FlatBufferBuilder& _fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
ListThreadsResponseBuilder &operator=(const ListThreadsResponseBuilder &);
|
||||
ListThreadsResponseBuilder& operator=(const ListThreadsResponseBuilder&);
|
||||
flatbuffers::Offset<ListThreadsResponse> Finish() {
|
||||
auto o = flatbuffers::Offset<ListThreadsResponse>(fbb_.EndTable(start_, 1));
|
||||
return o;
|
||||
|
|
@ -219,7 +219,7 @@ struct ListThreadsResponseBuilder {
|
|||
};
|
||||
|
||||
inline flatbuffers::Offset<ListThreadsResponse> CreateListThreadsResponse(
|
||||
flatbuffers::FlatBufferBuilder &_fbb,
|
||||
flatbuffers::FlatBufferBuilder& _fbb,
|
||||
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Thread>>>
|
||||
thread = 0) {
|
||||
ListThreadsResponseBuilder builder_(_fbb);
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@
|
|||
|
||||
namespace xe {
|
||||
namespace kernel {
|
||||
uint32_t xex2_get_header_size(const xex2_header *header) {
|
||||
uint32_t xex2_get_header_size(const xex2_header* header) {
|
||||
return header->exe_offset;
|
||||
}
|
||||
} // namespace kernel
|
||||
|
|
@ -48,41 +48,40 @@ uint32_t xex2_get_header_size(const xex2_header *header) {
|
|||
DEFINE_bool(xex_dev_key, false, "Use the devkit key.");
|
||||
|
||||
typedef struct xe_xex2 {
|
||||
xe::Memory *memory;
|
||||
xe::Memory* memory;
|
||||
|
||||
xe_xex2_header_t header;
|
||||
|
||||
std::vector<PESection *> *sections;
|
||||
std::vector<PESection*>* sections;
|
||||
|
||||
struct {
|
||||
size_t count;
|
||||
xe_xex2_import_info_t *infos;
|
||||
xe_xex2_import_info_t* infos;
|
||||
} library_imports[16];
|
||||
} xe_xex2_t;
|
||||
|
||||
int xe_xex2_read_header(const uint8_t *addr, const size_t length,
|
||||
xe_xex2_header_t *header);
|
||||
int xe_xex2_decrypt_key(xe_xex2_header_t *header);
|
||||
int xe_xex2_read_image(xe_xex2_ref xex, const uint8_t *xex_addr,
|
||||
const uint32_t xex_length, xe::Memory *memory);
|
||||
int xe_xex2_read_header(const uint8_t* addr, const size_t length,
|
||||
xe_xex2_header_t* header);
|
||||
int xe_xex2_decrypt_key(xe_xex2_header_t* header);
|
||||
int xe_xex2_read_image(xe_xex2_ref xex, const uint8_t* xex_addr,
|
||||
const uint32_t xex_length, xe::Memory* memory);
|
||||
int xe_xex2_load_pe(xe_xex2_ref xex);
|
||||
int xe_xex2_find_import_infos(xe_xex2_ref xex,
|
||||
const xe_xex2_import_library_t *library);
|
||||
const xe_xex2_import_library_t* library);
|
||||
|
||||
xe_xex2_ref xe_xex2_load(xe::Memory *memory, const void *addr,
|
||||
xe_xex2_ref xe_xex2_load(xe::Memory* memory, const void* addr,
|
||||
const size_t length, xe_xex2_options_t options) {
|
||||
xe_xex2_ref xex = (xe_xex2_ref)calloc(1, sizeof(xe_xex2));
|
||||
|
||||
xex->memory = memory;
|
||||
xex->sections = new std::vector<PESection *>();
|
||||
xex->sections = new std::vector<PESection*>();
|
||||
|
||||
XEEXPECTZERO(
|
||||
xe_xex2_read_header((const uint8_t *)addr, length, &xex->header));
|
||||
XEEXPECTZERO(xe_xex2_read_header((const uint8_t*)addr, length, &xex->header));
|
||||
|
||||
XEEXPECTZERO(xe_xex2_decrypt_key(&xex->header));
|
||||
|
||||
XEEXPECTZERO(
|
||||
xe_xex2_read_image(xex, (const uint8_t *)addr, uint32_t(length), memory));
|
||||
xe_xex2_read_image(xex, (const uint8_t*)addr, uint32_t(length), memory));
|
||||
|
||||
XEEXPECTZERO(xe_xex2_load_pe(xex));
|
||||
|
||||
|
|
@ -103,35 +102,35 @@ void xe_xex2_dealloc(xe_xex2_ref xex) {
|
|||
return;
|
||||
}
|
||||
|
||||
for (std::vector<PESection *>::iterator it = xex->sections->begin();
|
||||
for (std::vector<PESection*>::iterator it = xex->sections->begin();
|
||||
it != xex->sections->end(); ++it) {
|
||||
delete *it;
|
||||
}
|
||||
|
||||
xe_xex2_header_t *header = &xex->header;
|
||||
xe_xex2_header_t* header = &xex->header;
|
||||
free(header->sections);
|
||||
free(header->resource_infos);
|
||||
if (header->file_format_info.compression_type == XEX_COMPRESSION_BASIC) {
|
||||
free(header->file_format_info.compression_info.basic.blocks);
|
||||
}
|
||||
for (size_t n = 0; n < header->import_library_count; n++) {
|
||||
xe_xex2_import_library_t *library = &header->import_libraries[n];
|
||||
xe_xex2_import_library_t* library = &header->import_libraries[n];
|
||||
free(library->records);
|
||||
}
|
||||
|
||||
xex->memory = NULL;
|
||||
}
|
||||
|
||||
const xe_xex2_header_t *xe_xex2_get_header(xe_xex2_ref xex) {
|
||||
const xe_xex2_header_t* xe_xex2_get_header(xe_xex2_ref xex) {
|
||||
return &xex->header;
|
||||
}
|
||||
|
||||
int xe_xex2_read_header(const uint8_t *addr, const size_t length,
|
||||
xe_xex2_header_t *header) {
|
||||
const uint8_t *p = addr;
|
||||
const uint8_t *pc;
|
||||
const uint8_t *ps;
|
||||
xe_xex2_loader_info_t *ldr;
|
||||
int xe_xex2_read_header(const uint8_t* addr, const size_t length,
|
||||
xe_xex2_header_t* header) {
|
||||
const uint8_t* p = addr;
|
||||
const uint8_t* pc;
|
||||
const uint8_t* ps;
|
||||
xe_xex2_loader_info_t* ldr;
|
||||
|
||||
header->xex2 = xe::load_and_swap<uint32_t>(p + 0x00);
|
||||
if (header->xex2 != 'XEX2') {
|
||||
|
|
@ -146,11 +145,11 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
|
|||
header->header_count = xe::load_and_swap<uint32_t>(p + 0x14);
|
||||
|
||||
for (size_t n = 0; n < header->header_count; n++) {
|
||||
const uint8_t *ph = p + 0x18 + (n * 8);
|
||||
const uint8_t* ph = p + 0x18 + (n * 8);
|
||||
const uint32_t key = xe::load_and_swap<uint32_t>(ph + 0x00);
|
||||
const uint32_t data_offset = xe::load_and_swap<uint32_t>(ph + 0x04);
|
||||
|
||||
xe_xex2_opt_header_t *opt_header = &header->headers[n];
|
||||
xe_xex2_opt_header_t* opt_header = &header->headers[n];
|
||||
opt_header->key = key;
|
||||
switch (key & 0xFF) {
|
||||
case 0x01:
|
||||
|
|
@ -170,18 +169,18 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
|
|||
break;
|
||||
}
|
||||
|
||||
const uint8_t *pp = p + opt_header->offset;
|
||||
const uint8_t* pp = p + opt_header->offset;
|
||||
switch (opt_header->key) {
|
||||
case XEX_HEADER_SYSTEM_FLAGS:
|
||||
header->system_flags = (xe_xex2_system_flags)data_offset;
|
||||
break;
|
||||
case XEX_HEADER_RESOURCE_INFO: {
|
||||
header->resource_info_count = (opt_header->length - 4) / 16;
|
||||
header->resource_infos = (xe_xex2_resource_info_t *)calloc(
|
||||
header->resource_infos = (xe_xex2_resource_info_t*)calloc(
|
||||
header->resource_info_count, sizeof(xe_xex2_resource_info_t));
|
||||
const uint8_t *phi = pp + 0x04;
|
||||
const uint8_t* phi = pp + 0x04;
|
||||
for (size_t m = 0; m < header->resource_info_count; m++) {
|
||||
auto &res = header->resource_infos[m];
|
||||
auto& res = header->resource_infos[m];
|
||||
memcpy(res.name, phi + 0x00, 8);
|
||||
res.address = xe::load_and_swap<uint32_t>(phi + 0x08);
|
||||
res.size = xe::load_and_swap<uint32_t>(phi + 0x0C);
|
||||
|
|
@ -189,7 +188,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
|
|||
}
|
||||
} break;
|
||||
case XEX_HEADER_EXECUTION_INFO: {
|
||||
xe_xex2_execution_info_t *ex = &header->execution_info;
|
||||
xe_xex2_execution_info_t* ex = &header->execution_info;
|
||||
ex->media_id = xe::load_and_swap<uint32_t>(pp + 0x00);
|
||||
ex->version.value = xe::load_and_swap<uint32_t>(pp + 0x04);
|
||||
ex->base_version.value = xe::load_and_swap<uint32_t>(pp + 0x08);
|
||||
|
|
@ -201,7 +200,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
|
|||
ex->savegame_id = xe::load_and_swap<uint32_t>(pp + 0x14);
|
||||
} break;
|
||||
case XEX_HEADER_GAME_RATINGS: {
|
||||
xe_xex2_game_ratings_t *ratings = &header->game_ratings;
|
||||
xe_xex2_game_ratings_t* ratings = &header->game_ratings;
|
||||
ratings->esrb =
|
||||
(xe_xex2_rating_esrb_value)xe::load_and_swap<uint8_t>(pp + 0x00);
|
||||
ratings->pegi =
|
||||
|
|
@ -228,7 +227,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
|
|||
(xe_xex2_rating_fpb_value)xe::load_and_swap<uint8_t>(pp + 0x0B);
|
||||
} break;
|
||||
case XEX_HEADER_TLS_INFO: {
|
||||
xe_xex2_tls_info_t *tls = &header->tls_info;
|
||||
xe_xex2_tls_info_t* tls = &header->tls_info;
|
||||
tls->slot_count = xe::load_and_swap<uint32_t>(pp + 0x00);
|
||||
tls->raw_data_address = xe::load_and_swap<uint32_t>(pp + 0x04);
|
||||
tls->data_size = xe::load_and_swap<uint32_t>(pp + 0x08);
|
||||
|
|
@ -263,11 +262,11 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
|
|||
header->import_library_count = count;
|
||||
|
||||
uint32_t string_table_size = xe::load_and_swap<uint32_t>(pp + 0x04);
|
||||
const char *string_table = (const char *)(pp + 0x0C);
|
||||
const char* string_table = (const char*)(pp + 0x0C);
|
||||
|
||||
pp += 12 + string_table_size;
|
||||
for (size_t m = 0; m < count; m++) {
|
||||
xe_xex2_import_library_t *library = &header->import_libraries[m];
|
||||
xe_xex2_import_library_t* library = &header->import_libraries[m];
|
||||
memcpy(library->digest, pp + 0x04, 20);
|
||||
library->import_id = xe::load_and_swap<uint32_t>(pp + 0x18);
|
||||
library->version.value = xe::load_and_swap<uint32_t>(pp + 0x1C);
|
||||
|
|
@ -295,7 +294,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
|
|||
|
||||
library->record_count = xe::load_and_swap<uint16_t>(pp + 0x26);
|
||||
library->records =
|
||||
(uint32_t *)calloc(library->record_count, sizeof(uint32_t));
|
||||
(uint32_t*)calloc(library->record_count, sizeof(uint32_t));
|
||||
XEEXPECTNOTNULL(library->records);
|
||||
pp += 0x28;
|
||||
for (size_t i = 0; i < library->record_count; i++) {
|
||||
|
|
@ -316,7 +315,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
|
|||
header->static_library_count = count;
|
||||
pp += 4;
|
||||
for (size_t m = 0; m < count; m++) {
|
||||
xe_xex2_static_library_t *library = &header->static_libraries[m];
|
||||
xe_xex2_static_library_t* library = &header->static_libraries[m];
|
||||
memcpy(library->name, pp + 0x00, 8);
|
||||
library->name[8] = 0;
|
||||
library->major = xe::load_and_swap<uint16_t>(pp + 0x08);
|
||||
|
|
@ -329,7 +328,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
|
|||
}
|
||||
} break;
|
||||
case XEX_HEADER_FILE_FORMAT_INFO: {
|
||||
xe_xex2_file_format_info_t *fmt = &header->file_format_info;
|
||||
xe_xex2_file_format_info_t* fmt = &header->file_format_info;
|
||||
fmt->encryption_type =
|
||||
(xe_xex2_encryption_type)xe::load_and_swap<uint16_t>(pp + 0x04);
|
||||
fmt->compression_type =
|
||||
|
|
@ -340,17 +339,16 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
|
|||
assert_always();
|
||||
break;
|
||||
case XEX_COMPRESSION_BASIC: {
|
||||
xe_xex2_file_basic_compression_info_t *comp_info =
|
||||
xe_xex2_file_basic_compression_info_t* comp_info =
|
||||
&fmt->compression_info.basic;
|
||||
uint32_t info_size = xe::load_and_swap<uint32_t>(pp + 0x00);
|
||||
comp_info->block_count = (info_size - 8) / 8;
|
||||
comp_info->blocks =
|
||||
(xe_xex2_file_basic_compression_block_t *)calloc(
|
||||
comp_info->blocks = (xe_xex2_file_basic_compression_block_t*)calloc(
|
||||
comp_info->block_count,
|
||||
sizeof(xe_xex2_file_basic_compression_block_t));
|
||||
XEEXPECTNOTNULL(comp_info->blocks);
|
||||
for (size_t m = 0; m < comp_info->block_count; m++) {
|
||||
xe_xex2_file_basic_compression_block_t *block =
|
||||
xe_xex2_file_basic_compression_block_t* block =
|
||||
&comp_info->blocks[m];
|
||||
block->data_size =
|
||||
xe::load_and_swap<uint32_t>(pp + 0x08 + (m * 8));
|
||||
|
|
@ -359,7 +357,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
|
|||
}
|
||||
} break;
|
||||
case XEX_COMPRESSION_NORMAL: {
|
||||
xe_xex2_file_normal_compression_info_t *comp_info =
|
||||
xe_xex2_file_normal_compression_info_t* comp_info =
|
||||
&fmt->compression_info.normal;
|
||||
uint32_t window_size = xe::load_and_swap<uint32_t>(pp + 0x08);
|
||||
uint32_t window_bits = 0;
|
||||
|
|
@ -409,11 +407,11 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
|
|||
ps = p + header->certificate_offset + 0x180;
|
||||
header->section_count = xe::load_and_swap<uint32_t>(ps + 0x000);
|
||||
ps += 4;
|
||||
header->sections = (xe_xex2_section_t *)calloc(header->section_count,
|
||||
header->sections = (xe_xex2_section_t*)calloc(header->section_count,
|
||||
sizeof(xe_xex2_section_t));
|
||||
XEEXPECTNOTNULL(header->sections);
|
||||
for (size_t n = 0; n < header->section_count; n++) {
|
||||
xe_xex2_section_t *section = &header->sections[n];
|
||||
xe_xex2_section_t* section = &header->sections[n];
|
||||
section->page_size =
|
||||
header->exe_address <= 0x90000000 ? 64 * 1024 : 4 * 1024;
|
||||
section->info.value = xe::load_and_swap<uint32_t>(ps);
|
||||
|
|
@ -428,7 +426,7 @@ XECLEANUP:
|
|||
return 1;
|
||||
}
|
||||
|
||||
int xe_xex2_decrypt_key(xe_xex2_header_t *header) {
|
||||
int xe_xex2_decrypt_key(xe_xex2_header_t* header) {
|
||||
const static uint8_t xe_xex2_retail_key[16] = {
|
||||
0x20, 0xB1, 0x85, 0xA5, 0x9D, 0x28, 0xFD, 0xC3,
|
||||
0x40, 0x58, 0x3F, 0xBB, 0x08, 0x96, 0xBF, 0x91};
|
||||
|
|
@ -438,7 +436,7 @@ int xe_xex2_decrypt_key(xe_xex2_header_t *header) {
|
|||
|
||||
// Guess key based on file info.
|
||||
// TODO: better way to finding out which key to use?
|
||||
const uint8_t *xexkey;
|
||||
const uint8_t* xexkey;
|
||||
if (header->execution_info.title_id && !FLAGS_xex_dev_key) {
|
||||
xexkey = xe_xex2_retail_key;
|
||||
} else {
|
||||
|
|
@ -455,18 +453,18 @@ int xe_xex2_decrypt_key(xe_xex2_header_t *header) {
|
|||
|
||||
typedef struct mspack_memory_file_t {
|
||||
struct mspack_system sys;
|
||||
void *buffer;
|
||||
void* buffer;
|
||||
off_t buffer_size;
|
||||
off_t offset;
|
||||
} mspack_memory_file;
|
||||
mspack_memory_file *mspack_memory_open(struct mspack_system *sys, void *buffer,
|
||||
mspack_memory_file* mspack_memory_open(struct mspack_system* sys, void* buffer,
|
||||
const size_t buffer_size) {
|
||||
assert_true(buffer_size < INT_MAX);
|
||||
if (buffer_size >= INT_MAX) {
|
||||
return NULL;
|
||||
}
|
||||
mspack_memory_file *memfile =
|
||||
(mspack_memory_file *)calloc(1, sizeof(mspack_memory_file));
|
||||
mspack_memory_file* memfile =
|
||||
(mspack_memory_file*)calloc(1, sizeof(mspack_memory_file));
|
||||
if (!memfile) {
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -475,36 +473,36 @@ mspack_memory_file *mspack_memory_open(struct mspack_system *sys, void *buffer,
|
|||
memfile->offset = 0;
|
||||
return memfile;
|
||||
}
|
||||
void mspack_memory_close(mspack_memory_file *file) {
|
||||
mspack_memory_file *memfile = (mspack_memory_file *)file;
|
||||
void mspack_memory_close(mspack_memory_file* file) {
|
||||
mspack_memory_file* memfile = (mspack_memory_file*)file;
|
||||
free(memfile);
|
||||
}
|
||||
int mspack_memory_read(struct mspack_file *file, void *buffer, int chars) {
|
||||
mspack_memory_file *memfile = (mspack_memory_file *)file;
|
||||
int mspack_memory_read(struct mspack_file* file, void* buffer, int chars) {
|
||||
mspack_memory_file* memfile = (mspack_memory_file*)file;
|
||||
const off_t remaining = memfile->buffer_size - memfile->offset;
|
||||
const off_t total = std::min(static_cast<off_t>(chars), remaining);
|
||||
memcpy(buffer, (uint8_t *)memfile->buffer + memfile->offset, total);
|
||||
memcpy(buffer, (uint8_t*)memfile->buffer + memfile->offset, total);
|
||||
memfile->offset += total;
|
||||
return (int)total;
|
||||
}
|
||||
int mspack_memory_write(struct mspack_file *file, void *buffer, int chars) {
|
||||
mspack_memory_file *memfile = (mspack_memory_file *)file;
|
||||
int mspack_memory_write(struct mspack_file* file, void* buffer, int chars) {
|
||||
mspack_memory_file* memfile = (mspack_memory_file*)file;
|
||||
const off_t remaining = memfile->buffer_size - memfile->offset;
|
||||
const off_t total = std::min(static_cast<off_t>(chars), remaining);
|
||||
memcpy((uint8_t *)memfile->buffer + memfile->offset, buffer, total);
|
||||
memcpy((uint8_t*)memfile->buffer + memfile->offset, buffer, total);
|
||||
memfile->offset += total;
|
||||
return (int)total;
|
||||
}
|
||||
void *mspack_memory_alloc(struct mspack_system *sys, size_t chars) {
|
||||
void* mspack_memory_alloc(struct mspack_system* sys, size_t chars) {
|
||||
return calloc(chars, 1);
|
||||
}
|
||||
void mspack_memory_free(void *ptr) { free(ptr); }
|
||||
void mspack_memory_copy(void *src, void *dest, size_t chars) {
|
||||
void mspack_memory_free(void* ptr) { free(ptr); }
|
||||
void mspack_memory_copy(void* src, void* dest, size_t chars) {
|
||||
memcpy(dest, src, chars);
|
||||
}
|
||||
struct mspack_system *mspack_memory_sys_create() {
|
||||
struct mspack_system *sys =
|
||||
(struct mspack_system *)calloc(1, sizeof(struct mspack_system));
|
||||
struct mspack_system* mspack_memory_sys_create() {
|
||||
struct mspack_system* sys =
|
||||
(struct mspack_system*)calloc(1, sizeof(struct mspack_system));
|
||||
if (!sys) {
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -515,17 +513,17 @@ struct mspack_system *mspack_memory_sys_create() {
|
|||
sys->copy = mspack_memory_copy;
|
||||
return sys;
|
||||
}
|
||||
void mspack_memory_sys_destroy(struct mspack_system *sys) { free(sys); }
|
||||
void mspack_memory_sys_destroy(struct mspack_system* sys) { free(sys); }
|
||||
|
||||
void xe_xex2_decrypt_buffer(const uint8_t *session_key,
|
||||
const uint8_t *input_buffer,
|
||||
const size_t input_size, uint8_t *output_buffer,
|
||||
void xe_xex2_decrypt_buffer(const uint8_t* session_key,
|
||||
const uint8_t* input_buffer,
|
||||
const size_t input_size, uint8_t* output_buffer,
|
||||
const size_t output_size) {
|
||||
uint32_t rk[4 * (MAXNR + 1)];
|
||||
uint8_t ivec[16] = {0};
|
||||
int32_t Nr = rijndaelKeySetupDec(rk, session_key, 128);
|
||||
const uint8_t *ct = input_buffer;
|
||||
uint8_t *pt = output_buffer;
|
||||
const uint8_t* ct = input_buffer;
|
||||
uint8_t* pt = output_buffer;
|
||||
for (size_t n = 0; n < input_size; n += 16, ct += 16, pt += 16) {
|
||||
// Decrypt 16 uint8_ts from input -> output.
|
||||
rijndaelDecrypt(rk, Nr, ct, pt);
|
||||
|
|
@ -538,10 +536,10 @@ void xe_xex2_decrypt_buffer(const uint8_t *session_key,
|
|||
}
|
||||
}
|
||||
|
||||
int xe_xex2_read_image_uncompressed(const xe_xex2_header_t *header,
|
||||
const uint8_t *xex_addr,
|
||||
int xe_xex2_read_image_uncompressed(const xe_xex2_header_t* header,
|
||||
const uint8_t* xex_addr,
|
||||
const uint32_t xex_length,
|
||||
xe::Memory *memory) {
|
||||
xe::Memory* memory) {
|
||||
// Allocate in-place the XEX memory.
|
||||
const uint32_t exe_length = xex_length - header->exe_offset;
|
||||
uint32_t uncompressed_size = exe_length;
|
||||
|
|
@ -556,10 +554,10 @@ int xe_xex2_read_image_uncompressed(const xe_xex2_header_t *header,
|
|||
uncompressed_size);
|
||||
return 2;
|
||||
}
|
||||
uint8_t *buffer = memory->TranslateVirtual(header->exe_address);
|
||||
uint8_t* buffer = memory->TranslateVirtual(header->exe_address);
|
||||
std::memset(buffer, 0, uncompressed_size);
|
||||
|
||||
const uint8_t *p = (const uint8_t *)xex_addr + header->exe_offset;
|
||||
const uint8_t* p = (const uint8_t*)xex_addr + header->exe_offset;
|
||||
|
||||
switch (header->file_format_info.encryption_type) {
|
||||
case XEX_ENCRYPTION_NONE:
|
||||
|
|
@ -580,17 +578,17 @@ int xe_xex2_read_image_uncompressed(const xe_xex2_header_t *header,
|
|||
return 0;
|
||||
}
|
||||
|
||||
int xe_xex2_read_image_basic_compressed(const xe_xex2_header_t *header,
|
||||
const uint8_t *xex_addr,
|
||||
int xe_xex2_read_image_basic_compressed(const xe_xex2_header_t* header,
|
||||
const uint8_t* xex_addr,
|
||||
const uint32_t xex_length,
|
||||
xe::Memory *memory) {
|
||||
xe::Memory* memory) {
|
||||
const uint32_t exe_length = xex_length - header->exe_offset;
|
||||
const uint8_t *source_buffer = (const uint8_t *)xex_addr + header->exe_offset;
|
||||
const uint8_t *p = source_buffer;
|
||||
const uint8_t* source_buffer = (const uint8_t*)xex_addr + header->exe_offset;
|
||||
const uint8_t* p = source_buffer;
|
||||
|
||||
// Calculate uncompressed length.
|
||||
uint32_t uncompressed_size = 0;
|
||||
const xe_xex2_file_basic_compression_info_t *comp_info =
|
||||
const xe_xex2_file_basic_compression_info_t* comp_info =
|
||||
&header->file_format_info.compression_info.basic;
|
||||
for (uint32_t n = 0; n < comp_info->block_count; n++) {
|
||||
const uint32_t data_size = comp_info->blocks[n].data_size;
|
||||
|
|
@ -601,7 +599,7 @@ int xe_xex2_read_image_basic_compressed(const xe_xex2_header_t *header,
|
|||
// Calculate the total size of the XEX image from its headers.
|
||||
uint32_t total_size = 0;
|
||||
for (uint32_t i = 0; i < header->section_count; i++) {
|
||||
xe_xex2_section_t §ion = header->sections[i];
|
||||
xe_xex2_section_t& section = header->sections[i];
|
||||
|
||||
total_size += section.info.page_count * section.page_size;
|
||||
}
|
||||
|
|
@ -618,9 +616,9 @@ int xe_xex2_read_image_basic_compressed(const xe_xex2_header_t *header,
|
|||
uncompressed_size);
|
||||
return 1;
|
||||
}
|
||||
uint8_t *buffer = memory->TranslateVirtual(header->exe_address);
|
||||
uint8_t* buffer = memory->TranslateVirtual(header->exe_address);
|
||||
std::memset(buffer, 0, total_size); // Quickly zero the contents.
|
||||
uint8_t *d = buffer;
|
||||
uint8_t* d = buffer;
|
||||
|
||||
uint32_t rk[4 * (MAXNR + 1)];
|
||||
uint8_t ivec[16] = {0};
|
||||
|
|
@ -640,8 +638,8 @@ int xe_xex2_read_image_basic_compressed(const xe_xex2_header_t *header,
|
|||
memcpy(d, p, exe_length - (p - source_buffer));
|
||||
break;
|
||||
case XEX_ENCRYPTION_NORMAL: {
|
||||
const uint8_t *ct = p;
|
||||
uint8_t *pt = d;
|
||||
const uint8_t* ct = p;
|
||||
uint8_t* pt = d;
|
||||
for (size_t m = 0; m < data_size; m += 16, ct += 16, pt += 16) {
|
||||
// Decrypt 16 uint8_ts from input -> output.
|
||||
rijndaelDecrypt(rk, Nr, ct, pt);
|
||||
|
|
@ -665,12 +663,12 @@ int xe_xex2_read_image_basic_compressed(const xe_xex2_header_t *header,
|
|||
return 0;
|
||||
}
|
||||
|
||||
int xe_xex2_read_image_compressed(const xe_xex2_header_t *header,
|
||||
const uint8_t *xex_addr,
|
||||
int xe_xex2_read_image_compressed(const xe_xex2_header_t* header,
|
||||
const uint8_t* xex_addr,
|
||||
const uint32_t xex_length,
|
||||
xe::Memory *memory) {
|
||||
xe::Memory* memory) {
|
||||
const uint32_t exe_length = xex_length - header->exe_offset;
|
||||
const uint8_t *exe_buffer = (const uint8_t *)xex_addr + header->exe_offset;
|
||||
const uint8_t* exe_buffer = (const uint8_t*)xex_addr + header->exe_offset;
|
||||
|
||||
// src -> dest:
|
||||
// - decrypt (if encrypted)
|
||||
|
|
@ -682,20 +680,20 @@ int xe_xex2_read_image_compressed(const xe_xex2_header_t *header,
|
|||
|
||||
int result_code = 1;
|
||||
|
||||
uint8_t *compress_buffer = NULL;
|
||||
const uint8_t *p = NULL;
|
||||
uint8_t *d = NULL;
|
||||
uint8_t *deblock_buffer = NULL;
|
||||
uint8_t* compress_buffer = NULL;
|
||||
const uint8_t* p = NULL;
|
||||
uint8_t* d = NULL;
|
||||
uint8_t* deblock_buffer = NULL;
|
||||
size_t block_size = 0;
|
||||
uint32_t uncompressed_size = 0;
|
||||
struct mspack_system *sys = NULL;
|
||||
mspack_memory_file *lzxsrc = NULL;
|
||||
mspack_memory_file *lzxdst = NULL;
|
||||
struct lzxd_stream *lzxd = NULL;
|
||||
struct mspack_system* sys = NULL;
|
||||
mspack_memory_file* lzxsrc = NULL;
|
||||
mspack_memory_file* lzxdst = NULL;
|
||||
struct lzxd_stream* lzxd = NULL;
|
||||
|
||||
// Decrypt (if needed).
|
||||
bool free_input = false;
|
||||
const uint8_t *input_buffer = exe_buffer;
|
||||
const uint8_t* input_buffer = exe_buffer;
|
||||
const size_t input_size = exe_length;
|
||||
switch (header->file_format_info.encryption_type) {
|
||||
case XEX_ENCRYPTION_NONE:
|
||||
|
|
@ -704,28 +702,28 @@ int xe_xex2_read_image_compressed(const xe_xex2_header_t *header,
|
|||
case XEX_ENCRYPTION_NORMAL:
|
||||
// TODO: a way to do without a copy/alloc?
|
||||
free_input = true;
|
||||
input_buffer = (const uint8_t *)calloc(1, input_size);
|
||||
input_buffer = (const uint8_t*)calloc(1, input_size);
|
||||
XEEXPECTNOTNULL(input_buffer);
|
||||
xe_xex2_decrypt_buffer(header->session_key, exe_buffer, exe_length,
|
||||
(uint8_t *)input_buffer, input_size);
|
||||
(uint8_t*)input_buffer, input_size);
|
||||
break;
|
||||
default:
|
||||
assert_always();
|
||||
return false;
|
||||
}
|
||||
|
||||
compress_buffer = (uint8_t *)calloc(1, exe_length);
|
||||
compress_buffer = (uint8_t*)calloc(1, exe_length);
|
||||
XEEXPECTNOTNULL(compress_buffer);
|
||||
|
||||
p = input_buffer;
|
||||
d = compress_buffer;
|
||||
|
||||
// De-block.
|
||||
deblock_buffer = (uint8_t *)calloc(1, input_size);
|
||||
deblock_buffer = (uint8_t*)calloc(1, input_size);
|
||||
XEEXPECTNOTNULL(deblock_buffer);
|
||||
block_size = header->file_format_info.compression_info.normal.block_size;
|
||||
while (block_size) {
|
||||
const uint8_t *pnext = p + block_size;
|
||||
const uint8_t* pnext = p + block_size;
|
||||
const size_t next_size = xe::load_and_swap<int32_t>(p);
|
||||
p += 4;
|
||||
p += 20; // skip 20b hash
|
||||
|
|
@ -760,19 +758,18 @@ int xe_xex2_read_image_compressed(const xe_xex2_header_t *header,
|
|||
result_code = 2;
|
||||
goto XECLEANUP;
|
||||
}
|
||||
uint8_t *buffer = memory->TranslateVirtual(header->exe_address);
|
||||
uint8_t* buffer = memory->TranslateVirtual(header->exe_address);
|
||||
std::memset(buffer, 0, uncompressed_size);
|
||||
|
||||
// Setup decompressor and decompress.
|
||||
sys = mspack_memory_sys_create();
|
||||
XEEXPECTNOTNULL(sys);
|
||||
lzxsrc =
|
||||
mspack_memory_open(sys, (void *)compress_buffer, d - compress_buffer);
|
||||
lzxsrc = mspack_memory_open(sys, (void*)compress_buffer, d - compress_buffer);
|
||||
XEEXPECTNOTNULL(lzxsrc);
|
||||
lzxdst = mspack_memory_open(sys, buffer, uncompressed_size);
|
||||
XEEXPECTNOTNULL(lzxdst);
|
||||
lzxd =
|
||||
lzxd_init(sys, (struct mspack_file *)lzxsrc, (struct mspack_file *)lzxdst,
|
||||
lzxd_init(sys, (struct mspack_file*)lzxsrc, (struct mspack_file*)lzxdst,
|
||||
header->file_format_info.compression_info.normal.window_bits, 0,
|
||||
32768, (off_t)header->loader_info.image_size);
|
||||
XEEXPECTNOTNULL(lzxd);
|
||||
|
|
@ -800,14 +797,14 @@ XECLEANUP:
|
|||
free(compress_buffer);
|
||||
free(deblock_buffer);
|
||||
if (free_input) {
|
||||
free((void *)input_buffer);
|
||||
free((void*)input_buffer);
|
||||
}
|
||||
return result_code;
|
||||
}
|
||||
|
||||
int xe_xex2_read_image(xe_xex2_ref xex, const uint8_t *xex_addr,
|
||||
const uint32_t xex_length, xe::Memory *memory) {
|
||||
const xe_xex2_header_t *header = &xex->header;
|
||||
int xe_xex2_read_image(xe_xex2_ref xex, const uint8_t* xex_addr,
|
||||
const uint32_t xex_length, xe::Memory* memory) {
|
||||
const xe_xex2_header_t* header = &xex->header;
|
||||
switch (header->file_format_info.compression_type) {
|
||||
case XEX_COMPRESSION_NONE:
|
||||
return xe_xex2_read_image_uncompressed(header, xex_addr, xex_length,
|
||||
|
|
@ -825,11 +822,11 @@ int xe_xex2_read_image(xe_xex2_ref xex, const uint8_t *xex_addr,
|
|||
}
|
||||
|
||||
int xe_xex2_load_pe(xe_xex2_ref xex) {
|
||||
const xe_xex2_header_t *header = &xex->header;
|
||||
const uint8_t *p = xex->memory->TranslateVirtual(header->exe_address);
|
||||
const xe_xex2_header_t* header = &xex->header;
|
||||
const uint8_t* p = xex->memory->TranslateVirtual(header->exe_address);
|
||||
|
||||
// Verify DOS signature (MZ).
|
||||
const IMAGE_DOS_HEADER *doshdr = (const IMAGE_DOS_HEADER *)p;
|
||||
const IMAGE_DOS_HEADER* doshdr = (const IMAGE_DOS_HEADER*)p;
|
||||
if (doshdr->e_magic != IMAGE_DOS_SIGNATURE) {
|
||||
XELOGE("PE signature mismatch; likely bad decryption/decompression");
|
||||
return 1;
|
||||
|
|
@ -839,13 +836,13 @@ int xe_xex2_load_pe(xe_xex2_ref xex) {
|
|||
p += doshdr->e_lfanew;
|
||||
|
||||
// Verify NT signature (PE\0\0).
|
||||
const IMAGE_NT_HEADERS32 *nthdr = (const IMAGE_NT_HEADERS32 *)(p);
|
||||
const IMAGE_NT_HEADERS32* nthdr = (const IMAGE_NT_HEADERS32*)(p);
|
||||
if (nthdr->Signature != IMAGE_NT_SIGNATURE) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Verify matches an Xbox PE.
|
||||
const IMAGE_FILE_HEADER *filehdr = &nthdr->FileHeader;
|
||||
const IMAGE_FILE_HEADER* filehdr = &nthdr->FileHeader;
|
||||
if ((filehdr->Machine != IMAGE_FILE_MACHINE_POWERPCBE) ||
|
||||
!(filehdr->Characteristics & IMAGE_FILE_32BIT_MACHINE)) {
|
||||
return 1;
|
||||
|
|
@ -856,7 +853,7 @@ int xe_xex2_load_pe(xe_xex2_ref xex) {
|
|||
}
|
||||
|
||||
// Verify optional header is 32bit.
|
||||
const IMAGE_OPTIONAL_HEADER32 *opthdr = &nthdr->OptionalHeader;
|
||||
const IMAGE_OPTIONAL_HEADER32* opthdr = &nthdr->OptionalHeader;
|
||||
if (opthdr->Magic != IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -882,7 +879,7 @@ int xe_xex2_load_pe(xe_xex2_ref xex) {
|
|||
|
||||
// Quick scan to determine bounds of sections.
|
||||
size_t upper_address = 0;
|
||||
const IMAGE_SECTION_HEADER *sechdr = IMAGE_FIRST_SECTION(nthdr);
|
||||
const IMAGE_SECTION_HEADER* sechdr = IMAGE_FIRST_SECTION(nthdr);
|
||||
for (size_t n = 0; n < filehdr->NumberOfSections; n++, sechdr++) {
|
||||
const size_t physical_address = opthdr->ImageBase + sechdr->VirtualAddress;
|
||||
upper_address =
|
||||
|
|
@ -892,7 +889,7 @@ int xe_xex2_load_pe(xe_xex2_ref xex) {
|
|||
// Setup/load sections.
|
||||
sechdr = IMAGE_FIRST_SECTION(nthdr);
|
||||
for (size_t n = 0; n < filehdr->NumberOfSections; n++, sechdr++) {
|
||||
PESection *section = (PESection *)calloc(1, sizeof(PESection));
|
||||
PESection* section = (PESection*)calloc(1, sizeof(PESection));
|
||||
memcpy(section->name, sechdr->Name, sizeof(sechdr->Name));
|
||||
section->name[8] = 0;
|
||||
section->raw_address = sechdr->PointerToRawData;
|
||||
|
|
@ -908,8 +905,8 @@ int xe_xex2_load_pe(xe_xex2_ref xex) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
const PESection *xe_xex2_get_pe_section(xe_xex2_ref xex, const char *name) {
|
||||
for (std::vector<PESection *>::iterator it = xex->sections->begin();
|
||||
const PESection* xe_xex2_get_pe_section(xe_xex2_ref xex, const char* name) {
|
||||
for (std::vector<PESection*>::iterator it = xex->sections->begin();
|
||||
it != xex->sections->end(); ++it) {
|
||||
if (!strcmp((*it)->name, name)) {
|
||||
return *it;
|
||||
|
|
@ -919,7 +916,7 @@ const PESection *xe_xex2_get_pe_section(xe_xex2_ref xex, const char *name) {
|
|||
}
|
||||
|
||||
int xe_xex2_find_import_infos(xe_xex2_ref xex,
|
||||
const xe_xex2_import_library_t *library) {
|
||||
const xe_xex2_import_library_t* library) {
|
||||
auto header = xe_xex2_get_header(xex);
|
||||
|
||||
// Find library index for verification.
|
||||
|
|
@ -954,8 +951,8 @@ int xe_xex2_find_import_infos(xe_xex2_ref xex,
|
|||
}
|
||||
|
||||
// Allocate storage.
|
||||
xe_xex2_import_info_t *infos = (xe_xex2_import_info_t *)calloc(
|
||||
info_count, sizeof(xe_xex2_import_info_t));
|
||||
xe_xex2_import_info_t* infos =
|
||||
(xe_xex2_import_info_t*)calloc(info_count, sizeof(xe_xex2_import_info_t));
|
||||
assert_not_null(infos);
|
||||
|
||||
assert_not_zero(info_count);
|
||||
|
|
@ -972,14 +969,14 @@ int xe_xex2_find_import_infos(xe_xex2_ref xex,
|
|||
|
||||
switch (type) {
|
||||
case 0x00: {
|
||||
xe_xex2_import_info_t *info = &infos[i++];
|
||||
xe_xex2_import_info_t* info = &infos[i++];
|
||||
info->ordinal = value & 0xFFFF;
|
||||
info->value_address = record;
|
||||
} break;
|
||||
case 0x01: {
|
||||
// Thunk for previous record.
|
||||
assert_true(i > 0);
|
||||
xe_xex2_import_info_t *info = &infos[i - 1];
|
||||
xe_xex2_import_info_t* info = &infos[i - 1];
|
||||
assert_true(info->ordinal == (value & 0xFFFF));
|
||||
info->thunk_address = record;
|
||||
} break;
|
||||
|
|
@ -995,9 +992,9 @@ int xe_xex2_find_import_infos(xe_xex2_ref xex,
|
|||
}
|
||||
|
||||
int xe_xex2_get_import_infos(xe_xex2_ref xex,
|
||||
const xe_xex2_import_library_t *library,
|
||||
xe_xex2_import_info_t **out_import_infos,
|
||||
size_t *out_import_info_count) {
|
||||
const xe_xex2_import_library_t* library,
|
||||
xe_xex2_import_info_t** out_import_infos,
|
||||
size_t* out_import_info_count) {
|
||||
auto header = xe_xex2_get_header(xex);
|
||||
|
||||
// Find library index for verification.
|
||||
|
|
@ -1017,7 +1014,7 @@ int xe_xex2_get_import_infos(xe_xex2_ref xex,
|
|||
return 0;
|
||||
}
|
||||
|
||||
uint32_t xe_xex2_lookup_export(xe_xex2_ref xex, const char *name) {
|
||||
uint32_t xe_xex2_lookup_export(xe_xex2_ref xex, const char* name) {
|
||||
auto header = xe_xex2_get_header(xex);
|
||||
|
||||
// no exports :(
|
||||
|
|
@ -1026,24 +1023,23 @@ uint32_t xe_xex2_lookup_export(xe_xex2_ref xex, const char *name) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
auto e = reinterpret_cast<const IMAGE_EXPORT_DIRECTORY *>(
|
||||
auto e = reinterpret_cast<const IMAGE_EXPORT_DIRECTORY*>(
|
||||
xex->memory->TranslateVirtual(header->exe_address +
|
||||
header->pe_export_table_offset));
|
||||
|
||||
// e->AddressOfX RVAs are relative to the IMAGE_EXPORT_DIRECTORY!
|
||||
uint32_t *function_table = (uint32_t *)((uint64_t)e + e->AddressOfFunctions);
|
||||
uint32_t* function_table = (uint32_t*)((uint64_t)e + e->AddressOfFunctions);
|
||||
|
||||
// Names relative to directory
|
||||
uint32_t *name_table = (uint32_t *)((uint64_t)e + e->AddressOfNames);
|
||||
uint32_t* name_table = (uint32_t*)((uint64_t)e + e->AddressOfNames);
|
||||
|
||||
// Table of ordinals (by name)
|
||||
uint16_t *ordinal_table =
|
||||
(uint16_t *)((uint64_t)e + e->AddressOfNameOrdinals);
|
||||
uint16_t* ordinal_table = (uint16_t*)((uint64_t)e + e->AddressOfNameOrdinals);
|
||||
|
||||
const char *mod_name = (const char *)((uint64_t)e + e->Name);
|
||||
const char* mod_name = (const char*)((uint64_t)e + e->Name);
|
||||
|
||||
for (uint32_t i = 0; i < e->NumberOfNames; i++) {
|
||||
const char *fn_name = (const char *)((uint64_t)e + name_table[i]);
|
||||
const char* fn_name = (const char*)((uint64_t)e + name_table[i]);
|
||||
uint16_t ordinal = ordinal_table[i];
|
||||
uint32_t addr = header->exe_address + function_table[ordinal];
|
||||
|
||||
|
|
@ -1062,7 +1058,7 @@ uint32_t xe_xex2_lookup_export(xe_xex2_ref xex, uint16_t ordinal) {
|
|||
|
||||
// XEX-style export table.
|
||||
if (header->loader_info.export_table) {
|
||||
auto export_table = reinterpret_cast<const xe_xex2_export_table *>(
|
||||
auto export_table = reinterpret_cast<const xe_xex2_export_table*>(
|
||||
xex->memory->TranslateVirtual(header->loader_info.export_table));
|
||||
uint32_t ordinal_count = xe::byte_swap(export_table->count);
|
||||
uint32_t ordinal_base = xe::byte_swap(export_table->base);
|
||||
|
|
@ -1082,22 +1078,21 @@ uint32_t xe_xex2_lookup_export(xe_xex2_ref xex, uint16_t ordinal) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
auto e = reinterpret_cast<const IMAGE_EXPORT_DIRECTORY *>(
|
||||
auto e = reinterpret_cast<const IMAGE_EXPORT_DIRECTORY*>(
|
||||
xex->memory->TranslateVirtual(header->exe_address +
|
||||
header->pe_export_table_offset));
|
||||
|
||||
// e->AddressOfX RVAs are relative to the IMAGE_EXPORT_DIRECTORY!
|
||||
// Functions relative to base
|
||||
uint32_t *function_table = (uint32_t *)((uint64_t)e + e->AddressOfFunctions);
|
||||
uint32_t* function_table = (uint32_t*)((uint64_t)e + e->AddressOfFunctions);
|
||||
|
||||
// Names relative to directory
|
||||
uint32_t *name_table = (uint32_t *)((uint64_t)e + e->AddressOfNames);
|
||||
uint32_t* name_table = (uint32_t*)((uint64_t)e + e->AddressOfNames);
|
||||
|
||||
// Table of ordinals (by name)
|
||||
uint16_t *ordinal_table =
|
||||
(uint16_t *)((uint64_t)e + e->AddressOfNameOrdinals);
|
||||
uint16_t* ordinal_table = (uint16_t*)((uint64_t)e + e->AddressOfNameOrdinals);
|
||||
|
||||
const char *mod_name = (const char *)((uint64_t)e + e->Name);
|
||||
const char* mod_name = (const char*)((uint64_t)e + e->Name);
|
||||
|
||||
if (ordinal < e->NumberOfFunctions) {
|
||||
return header->exe_address + function_table[ordinal];
|
||||
|
|
|
|||
Loading…
Reference in New Issue