diff --git a/.clang-format b/.clang-format index f1ad04b..1911dbb 100644 --- a/.clang-format +++ b/.clang-format @@ -48,7 +48,7 @@ BreakConstructorInitializersBeforeComma: false BreakConstructorInitializers: BeforeComma BreakAfterJavaFieldAnnotations: true BreakStringLiterals: true -ColumnLimit: 80 +ColumnLimit: 100 CommentPragmas: '^ IWYU pragma:' CompactNamespaces: false ConstructorInitializerAllOnOneLineOrOnePerLine: false @@ -104,7 +104,7 @@ PenaltyExcessCharacter: 1000000 PenaltyReturnTypeOnItsOwnLine: 200 PointerAlignment: Right ReflowComments: true -SortIncludes: false +SortIncludes: true SortUsingDeclarations: false SpaceAfterCStyleCast: false SpaceAfterLogicalNot: false @@ -116,7 +116,8 @@ SpaceBeforeInheritanceColon: true SpaceBeforeParens: Custom SpaceBeforeParensOptions: AfterControlStatements: true - AfterFunctionDefinitionName: true + AfterFunctionDefinitionName: false + AfterFunctionDeclarationName: false SpaceBeforeRangeBasedForLoopColon: true SpaceInEmptyBlock: false SpaceInEmptyParentheses: false diff --git a/include/bal_decoder.h b/include/bal_decoder.h index 0a2d56a..6051a3a 100644 --- a/include/bal_decoder.h +++ b/include/bal_decoder.h @@ -19,35 +19,36 @@ extern "C" { #endif - #define BAL_OPERANDS_SIZE 4 - #define BAL_OPERAND_BIT_WIDTH 5 +#define BAL_OPERANDS_SIZE 4 +#define BAL_OPERAND_BIT_WIDTH 5 /// The type of an instruction operand. typedef enum { - BAL_OPERAND_TYPE_NONE = 0, + BAL_OPERAND_TYPE_NONE = 0, BAL_OPERAND_TYPE_REGISTER_32 = 1, - BAL_OPERAND_TYPE_REGISTER_64 = 2, + BAL_OPERAND_TYPE_REGISTER_64 = 2, BAL_OPERAND_TYPE_REGISTER_128 = 3, - BAL_OPERAND_TYPE_IMMEDIATE = 4, - BAL_OPERAND_TYPE_CONDITION = 5, + BAL_OPERAND_TYPE_IMMEDIATE = 4, + BAL_OPERAND_TYPE_CONDITION = 5, } bal_decoder_operand_type_t; /// Descriptor for a single operand. typedef struct { /// Operand type. See [`bal_decoder_operand_type_t`]. - uint16_t type : 5; + uint16_t type : 5; /// Bit position in the instruction. uint16_t bit_position : 6; /// Bit width of the field. - uint16_t bit_width : BAL_OPERAND_BIT_WIDTH; + uint16_t bit_width : BAL_OPERAND_BIT_WIDTH; } bal_decoder_operand_t; static_assert(2 == sizeof(bal_decoder_operand_t), "Expected operand struct to be 2 bytes."); - static_assert(5 == BAL_OPERAND_BIT_WIDTH, "Operand bit width must be less than 32 to prevent shift overflow."); + static_assert(5 == BAL_OPERAND_BIT_WIDTH, + "Operand bit width must be less than 32 to prevent shift overflow."); /// Represents static metadata aasociated with a specific ARM instruction. BAL_ALIGNED(32) typedef struct @@ -73,7 +74,8 @@ extern "C" bal_decoder_operand_t operands[BAL_OPERANDS_SIZE]; } bal_decoder_instruction_metadata_t; - static_assert(32 == sizeof(bal_decoder_instruction_metadata_t), "Expected decoder metadata struct to be 32 bytes."); + static_assert(32 == sizeof(bal_decoder_instruction_metadata_t), + "Expected decoder metadata struct to be 32 bytes."); /// Decodes a raw ARM64 instruction. /// @@ -85,8 +87,7 @@ extern "C" /// /// The pointer refers to static readonly memory. It is valid for the /// lifetime of the program and must not be freed. - BAL_HOT const bal_decoder_instruction_metadata_t *bal_decode_arm64( - const uint32_t instruction); + BAL_HOT const bal_decoder_instruction_metadata_t *bal_decode_arm64(const uint32_t instruction); #ifdef __cplusplus } diff --git a/include/bal_engine.h b/include/bal_engine.h index 31af5fb..14bded7 100644 --- a/include/bal_engine.h +++ b/include/bal_engine.h @@ -2,9 +2,9 @@ #define BALLISTIC_ENGINE_H #include "bal_attributes.h" -#include "bal_types.h" -#include "bal_memory.h" #include "bal_errors.h" +#include "bal_memory.h" +#include "bal_types.h" #include /// A byte pattern written to memory during initialization, poisoning allocated @@ -75,7 +75,7 @@ BAL_ALIGNED(64) typedef struct /// The base pointer returned during the underlying heap allocation. This /// is required to correctly free the engine's internal arrays. - void *arena_base; + void *arena_base; /// The total size of the allocated arena. size_t arena_size; @@ -96,8 +96,7 @@ BAL_ALIGNED(64) typedef struct /// /// Returns [`BAL_ERROR_ALLOCATION_FAILED`] if the allocator cannot fulfill the /// request. -BAL_COLD bal_error_t bal_engine_init(bal_allocator_t *allocator, - bal_engine_t *engine); +BAL_COLD bal_error_t bal_engine_init(bal_allocator_t *allocator, bal_engine_t *engine); /// Translates machine code starting at `arm_entry_point` into the engine's /// internal IR. `interface` provides memory access handling (like instruction @@ -109,17 +108,16 @@ BAL_COLD bal_error_t bal_engine_init(bal_allocator_t *allocator, /// /// Returns [`BAL_ERROR_ENGINE_STATE_INVALID`] if `engine` is not initialized /// or `engine->status != BAL_SUCCESS`. -BAL_HOT bal_error_t -bal_engine_translate(bal_engine_t *BAL_RESTRICT engine, - bal_memory_interface_t *BAL_RESTRICT interface, - const uint32_t *BAL_RESTRICT arm_entry_point); +BAL_HOT bal_error_t bal_engine_translate(bal_engine_t *BAL_RESTRICT engine, + bal_memory_interface_t *BAL_RESTRICT interface, + const uint32_t *BAL_RESTRICT arm_entry_point); /// Resets `engine` for the next compilation unit. This is a low cost memory /// operation designed to be called between translation units. /// /// Returns [`BAL_SUCCESS`] on success. /// -/// # Errors +/// # Errors /// /// Returns [`BAL_ERROR_INVALID_ARGUMENT`] if `engine` is `NULl`. BAL_HOT bal_error_t bal_engine_reset(bal_engine_t *engine); @@ -130,8 +128,7 @@ BAL_HOT bal_error_t bal_engine_reset(bal_engine_t *engine); /// /// This function does not free the [`bal_engine_t`] struct itself, as the /// caller may have allocated it on the stack. -BAL_COLD void bal_engine_destroy(bal_allocator_t *allocator, - bal_engine_t *engine); +BAL_COLD void bal_engine_destroy(bal_allocator_t *allocator, bal_engine_t *engine); #endif /* BALLISTIC_ENGINE_H */ /*** end of file ***/ diff --git a/include/bal_memory.h b/include/bal_memory.h index f366bba..7cdf64d 100644 --- a/include/bal_memory.h +++ b/include/bal_memory.h @@ -2,10 +2,10 @@ #define BALLISTIC_MEMORY_H #include "bal_attributes.h" -#include "bal_types.h" #include "bal_errors.h" -#include +#include "bal_types.h" #include +#include /// A function signature for allocating aligned memory. /// @@ -16,9 +16,7 @@ /// /// Returns a pointer to the allocated memory, or `NULL` if the request could /// not be fulfilled. -typedef void *(*bal_allocate_function_t)(void *allocator, - size_t alignment, - size_t size); +typedef void *(*bal_allocate_function_t)(void *allocator, size_t alignment, size_t size); /// A function signature for releasing memory. /// @@ -26,29 +24,26 @@ typedef void *(*bal_allocate_function_t)(void *allocator, /// previously allocated by the corresponding allocate function. The `size` /// parameter indicates the size of the allocation being freed. Access to the /// heap state is provided via `allocator`. -typedef void (*bal_free_function_t)(void *allocator, - void *pointer, - size_t size); +typedef void (*bal_free_function_t)(void *allocator, void *pointer, size_t size); /// Translates a Guest Virtual Address (GVA) to a Host Virtual Address (HVA). /// -/// Ballistic invokes this callback when it needs to fetch instructions or +/// Ballistic invokes this callback when it needs to fetch instructions or /// access data. The implementation must translate the provided `guest_address` -/// using the opaque `context` and return a pointer to the corresponding host -/// memory. +/// using the opaque `context` and return a pointer to the corresponding host +/// memory. /// /// Returns a pointer to the host memory containing the data at `guest_address`, or `NULL` /// if the address is unmapped or invalid. /// -/// # Safety +/// # Safety /// -/// The implementation must write the number of contiguous, readable bytes +/// The implementation must write the number of contiguous, readable bytes /// available at the returned pointer into `max_readable_size`. This prevents /// Ballistic from reading beyond the end of a mapped page or buffer. -typedef const uint8_t *(*bal_translate_function_t)( - void *context, - bal_guest_address_t guest_address, - size_t *max_readable_size); +typedef const uint8_t *(*bal_translate_function_t)(void *context, + bal_guest_address_t guest_address, + size_t *max_readable_size); /// The host application is responsible for providing an allocator capable of /// handling aligned memory requests. @@ -74,9 +69,9 @@ typedef struct /// Defines the interface for translating guest addresses to host memory. typedef struct { - /// An opaque pointer to the context required for address translation + /// An opaque pointer to the context required for address translation /// (e.g, a page walker or a buffer descriptor.). - void *context; + void *context; /// The callback invoked to perform address translation. bal_translate_function_t translate; @@ -100,7 +95,7 @@ BAL_COLD void bal_get_default_allocator(bal_allocator_t *out_allocator); /// /// The internal interface is allocated with `allocator`. `interface` is /// populated with the resulting context and translation callbacks. `buffer` -/// must be a pre-allocated block of host memory of at least `size bytes. +/// must be a pre-allocated block of host memory of at least `size bytes. /// /// Returns [`BAL_SUCCESS`] on success. /// @@ -115,11 +110,10 @@ BAL_COLD void bal_get_default_allocator(bal_allocator_t *out_allocator); /// /// The caller retains ownership of `buffer`. It must remain valid and /// unmodified for the lifetime of the created interface. -BAL_COLD bal_error_t -bal_memory_init_flat(bal_allocator_t *BAL_RESTRICT allocator, - bal_memory_interface_t *BAL_RESTRICT interface, - void *BAL_RESTRICT buffer, - size_t size); +BAL_COLD bal_error_t bal_memory_init_flat(bal_allocator_t *BAL_RESTRICT allocator, + bal_memory_interface_t *BAL_RESTRICT interface, + void *BAL_RESTRICT buffer, + size_t size); /// Frees the internal sttae allocated within `interface` using the provided /// `allocator`. diff --git a/include/bal_platform.h b/include/bal_platform.h index 18934ca..a3f77e5 100644 --- a/include/bal_platform.h +++ b/include/bal_platform.h @@ -1,7 +1,6 @@ #ifndef BALLISTIC_PLATFORM_H #define BALLISTIC_PLATFORM_H - #if defined(_WIN32) || defined(_WIN64) #define BAL_PLATFORM_WINDOWS 1 diff --git a/include/bal_types.h b/include/bal_types.h index b7ca4b9..5079c66 100644 --- a/include/bal_types.h +++ b/include/bal_types.h @@ -1,14 +1,13 @@ /** @file bal_types.h * * @brief Defines types used by Ballistic. - */ + */ #ifndef BALLISTIC_TYPES_H #define BALLISTIC_TYPES_H #include - typedef uint64_t bal_guest_address_t; typedef uint64_t bal_instruction_t; typedef uint32_t bal_constant_t; @@ -42,6 +41,6 @@ typedef enum OPCODE_EMUM_END = 0x7FF, // Force enum to 2 bytes. } bal_opcode_t; -#endif /* BALLISTIC_TYPES_H */ +#endif /* BALLISTIC_TYPES_H */ /*** end of file ***/ diff --git a/src/bal_engine.c b/src/bal_engine.c index 8803b4e..e42d910 100644 --- a/src/bal_engine.c +++ b/src/bal_engine.c @@ -27,47 +27,39 @@ #define BAL_ALIGN_UP(x, memory_alignment) \ (((x) + ((memory_alignment) - 1)) & ~((memory_alignment) - 1)) -static uint32_t extract_operand_value(const uint32_t, - const bal_decoder_operand_t *); -static uint32_t intern_constant(bal_constant_t, - bal_constant_t *, - bal_constant_count_t *, - size_t, - bal_error_t *); +static uint32_t extract_operand_value(const uint32_t, const bal_decoder_operand_t *); +static uint32_t intern_constant( + bal_constant_t, bal_constant_t *, bal_constant_count_t *, size_t, bal_error_t *); bal_error_t -bal_engine_init (bal_allocator_t *allocator, bal_engine_t *engine) +bal_engine_init(bal_allocator_t *allocator, bal_engine_t *engine) { if (NULL == allocator || NULL == engine) { return BAL_ERROR_INVALID_ARGUMENT; } - size_t source_variables_size - = MAX_GUEST_REGISTERS * sizeof(bal_source_variable_t); - - size_t ssa_bit_widths_size = MAX_INSTRUCTIONS * sizeof(bal_bit_width_t); - size_t instructions_size = MAX_INSTRUCTIONS * sizeof(bal_instruction_t); - size_t constants_size = MAX_INSTRUCTIONS * sizeof(bal_instruction_t); + size_t source_variables_size = MAX_GUEST_REGISTERS * sizeof(bal_source_variable_t); + size_t ssa_bit_widths_size = MAX_INSTRUCTIONS * sizeof(bal_bit_width_t); + size_t instructions_size = MAX_INSTRUCTIONS * sizeof(bal_instruction_t); + size_t constants_size = MAX_INSTRUCTIONS * sizeof(bal_instruction_t); // Calculate amount of memory needed for all arrays in engine. // - size_t memory_alignment = 64U; + size_t memory_alignment = 64U; + size_t offset_instructions = BAL_ALIGN_UP(source_variables_size, memory_alignment); - size_t offset_instructions - = BAL_ALIGN_UP(source_variables_size, memory_alignment); + size_t offset_ssa_bit_widths + = BAL_ALIGN_UP((offset_instructions + instructions_size), memory_alignment); - size_t offset_ssa_bit_widths = BAL_ALIGN_UP( - (offset_instructions + instructions_size), memory_alignment); - - size_t offset_constants = BAL_ALIGN_UP( - (offset_ssa_bit_widths + ssa_bit_widths_size), memory_alignment); + size_t offset_constants + = BAL_ALIGN_UP((offset_ssa_bit_widths + ssa_bit_widths_size), memory_alignment); size_t total_size_with_padding = BAL_ALIGN_UP((offset_constants + constants_size), memory_alignment); - uint8_t *data = (uint8_t *)allocator->allocate( - allocator, memory_alignment, total_size_with_padding); + uint8_t *data + = (uint8_t *)allocator->allocate(allocator, memory_alignment, total_size_with_padding); if (NULL == data) { @@ -75,40 +67,30 @@ bal_engine_init (bal_allocator_t *allocator, bal_engine_t *engine) return engine->status; } - engine->source_variables = (bal_source_variable_t *)data; - engine->instructions = (bal_instruction_t *)(data + offset_instructions); - engine->ssa_bit_widths = (bal_bit_width_t *)(data + offset_ssa_bit_widths); - engine->constants = (bal_constant_t *)(data + offset_constants); - engine->source_variables_size - = source_variables_size / sizeof(bal_source_variable_t); - engine->instructions_size = instructions_size / sizeof(bal_instruction_t); - engine->constants_size = constants_size / sizeof(bal_constant_t); - engine->instruction_count = 0; - engine->status = BAL_SUCCESS; - engine->arena_base = (void *)data; - engine->arena_size = total_size_with_padding; + engine->source_variables = (bal_source_variable_t *)data; + engine->instructions = (bal_instruction_t *)(data + offset_instructions); + engine->ssa_bit_widths = (bal_bit_width_t *)(data + offset_ssa_bit_widths); + engine->constants = (bal_constant_t *)(data + offset_constants); + engine->source_variables_size = source_variables_size / sizeof(bal_source_variable_t); + engine->instructions_size = instructions_size / sizeof(bal_instruction_t); + engine->constants_size = constants_size / sizeof(bal_constant_t); + engine->instruction_count = 0; + engine->status = BAL_SUCCESS; + engine->arena_base = (void *)data; + engine->arena_size = total_size_with_padding; - (void)memset(engine->source_variables, - POISON_UNINITIALIZED_MEMORY, - source_variables_size); - - (void)memset( - engine->instructions, POISON_UNINITIALIZED_MEMORY, instructions_size); - - (void)memset(engine->ssa_bit_widths, - POISON_UNINITIALIZED_MEMORY, - ssa_bit_widths_size); - - (void)memset( - engine->constants, POISON_UNINITIALIZED_MEMORY, constants_size); + (void)memset(engine->source_variables, POISON_UNINITIALIZED_MEMORY, source_variables_size); + (void)memset(engine->instructions, POISON_UNINITIALIZED_MEMORY, instructions_size); + (void)memset(engine->ssa_bit_widths, POISON_UNINITIALIZED_MEMORY, ssa_bit_widths_size); + (void)memset(engine->constants, POISON_UNINITIALIZED_MEMORY, constants_size); return engine->status; } bal_error_t -bal_engine_translate (bal_engine_t *BAL_RESTRICT engine, - bal_memory_interface_t *BAL_RESTRICT interface, - const uint32_t *BAL_RESTRICT arm_entry_point) +bal_engine_translate(bal_engine_t *BAL_RESTRICT engine, + bal_memory_interface_t *BAL_RESTRICT interface, + const uint32_t *BAL_RESTRICT arm_entry_point) { if (BAL_UNLIKELY(NULL == engine || NULL == arm_entry_point)) { @@ -124,14 +106,13 @@ bal_engine_translate (bal_engine_t *BAL_RESTRICT engine, bal_bit_width_t *BAL_RESTRICT bit_width_cursor = engine->ssa_bit_widths + engine->instruction_count; - bal_source_variable_t *BAL_RESTRICT source_variables - = engine->source_variables; + bal_source_variable_t *BAL_RESTRICT source_variables = engine->source_variables; - bal_constant_t *BAL_RESTRICT constants = engine->constants; - bal_constant_count_t constant_count = engine->constant_count; - bal_instruction_count_t instruction_count = engine->instruction_count; - bal_error_t status = engine->status; - const uint32_t *BAL_RESTRICT arm_instruction_cursor = arm_entry_point; + bal_constant_t *BAL_RESTRICT constants = engine->constants; + bal_constant_count_t constant_count = engine->constant_count; + bal_instruction_count_t instruction_count = engine->instruction_count; + bal_error_t status = engine->status; + const uint32_t *BAL_RESTRICT arm_instruction_cursor = arm_entry_point; uint32_t arm_registers[BAL_OPERANDS_SIZE] = { 0 }; while (ir_instruction_cursor < ir_instruction_end) @@ -142,8 +123,7 @@ bal_engine_translate (bal_engine_t *BAL_RESTRICT engine, for (size_t i = 0; i < BAL_OPERANDS_SIZE; ++i) { - arm_registers[i] - = extract_operand_value(*arm_instruction_cursor, operands); + arm_registers[i] = extract_operand_value(*arm_instruction_cursor, operands); ++operands; } @@ -155,9 +135,8 @@ bal_engine_translate (bal_engine_t *BAL_RESTRICT engine, uint32_t hw = arm_registers[2]; uint32_t shift = hw * 16; - uint64_t mask = (32 == operands[0].bit_width) - ? 0xFFFFFFFFULL - : 0xFFFFFFFFFFFFFFFFULL; + uint64_t mask + = (32 == operands[0].bit_width) ? 0xFFFFFFFFULL : 0xFFFFFFFFFFFFFFFFULL; // Calculate the shifted immediate value. // uint64_t value = (imm16 << shift) & mask; @@ -179,72 +158,61 @@ bal_engine_translate (bal_engine_t *BAL_RESTRICT engine, // new_val = cleared_val + (imm << shift) uint32_t old_ssa - = (31 == rd) ? intern_constant(0, - constants, - &constant_count, - engine->constants_size, - &status) - : source_variables[rd].current_ssa_index; + = (31 == rd) + ? intern_constant( + 0, constants, &constant_count, engine->constants_size, &status) + : source_variables[rd].current_ssa_index; uint64_t clear_mask = (~(0xFFFFULL << shift)) & mask; - uint32_t mask_index - = intern_constant((uint32_t)clear_mask, - constants, - &constant_count, - engine->constants_size, - &status); + uint32_t mask_index = intern_constant((uint32_t)clear_mask, + constants, + &constant_count, + engine->constants_size, + &status); if (BAL_UNLIKELY(status != BAL_SUCCESS)) { break; } - *ir_instruction_cursor = ((bal_instruction_t)OPCODE_AND - << BAL_OPCODE_SHIFT_POSITION) - | ((bal_instruction_t)old_ssa - << BAL_SOURCE1_SHIFT_POSITION) - | ((bal_instruction_t)mask_index - << BAL_SOURCE2_SHIFT_POSITION); + *ir_instruction_cursor + = ((bal_instruction_t)OPCODE_AND << BAL_OPCODE_SHIFT_POSITION) + | ((bal_instruction_t)old_ssa << BAL_SOURCE1_SHIFT_POSITION) + | ((bal_instruction_t)mask_index << BAL_SOURCE2_SHIFT_POSITION); ++ir_instruction_cursor; ++bit_width_cursor; ++instruction_count; - uint32_t value_index - = intern_constant((uint32_t)value, - constants, - &constant_count, - engine->constants_size, - &status); + uint32_t value_index = intern_constant((uint32_t)value, + constants, + &constant_count, + engine->constants_size, + &status); // Source 1 is the result of the AND instruction. // - uint32_t masked_ssa = instruction_count - 1; - *ir_instruction_cursor = ((bal_instruction_t)OPCODE_ADD - << BAL_OPCODE_SHIFT_POSITION) - | ((bal_instruction_t)masked_ssa - << BAL_SOURCE1_SHIFT_POSITION) - | ((bal_instruction_t)value_index - << BAL_SOURCE2_SHIFT_POSITION); + uint32_t masked_ssa = instruction_count - 1; + *ir_instruction_cursor + = ((bal_instruction_t)OPCODE_ADD << BAL_OPCODE_SHIFT_POSITION) + | ((bal_instruction_t)masked_ssa << BAL_SOURCE1_SHIFT_POSITION) + | ((bal_instruction_t)value_index << BAL_SOURCE2_SHIFT_POSITION); } else { - uint32_t constant_index - = intern_constant((uint32_t)value, - constants, - &constant_count, - engine->constants_size, - &status); + uint32_t constant_index = intern_constant((uint32_t)value, + constants, + &constant_count, + engine->constants_size, + &status); if (BAL_UNLIKELY(status != BAL_SUCCESS)) { - break; + break; } *ir_instruction_cursor - = ((bal_instruction_t)OPCODE_CONST - << BAL_OPCODE_SHIFT_POSITION) - | ((bal_instruction_t)constant_index - << BAL_SOURCE1_SHIFT_POSITION); + = ((bal_instruction_t)OPCODE_CONST << BAL_OPCODE_SHIFT_POSITION) + | ((bal_instruction_t)constant_index << BAL_SOURCE1_SHIFT_POSITION); } // Only update the SSA map is not writing to XZR/WZR. @@ -269,7 +237,7 @@ bal_engine_translate (bal_engine_t *BAL_RESTRICT engine, } bal_error_t -bal_engine_reset (bal_engine_t *engine) +bal_engine_reset(bal_engine_t *engine) { if (BAL_UNLIKELY(NULL == engine)) { @@ -279,18 +247,16 @@ bal_engine_reset (bal_engine_t *engine) engine->instruction_count = 0; engine->status = BAL_SUCCESS; - (void)memset(engine->source_variables, - POISON_UNINITIALIZED_MEMORY, - engine->source_variables_size); - (void)memset( - engine->constants, POISON_UNINITIALIZED_MEMORY, engine->constants_size); + engine->source_variables, POISON_UNINITIALIZED_MEMORY, engine->source_variables_size); + + (void)memset(engine->constants, POISON_UNINITIALIZED_MEMORY, engine->constants_size); return engine->status; } void -bal_engine_destroy (bal_allocator_t *allocator, bal_engine_t *engine) +bal_engine_destroy(bal_allocator_t *allocator, bal_engine_t *engine) { // No argument error handling. Segfault if user passes NULL. @@ -302,8 +268,7 @@ bal_engine_destroy (bal_allocator_t *allocator, bal_engine_t *engine) } BAL_HOT static uint32_t -extract_operand_value (const uint32_t instruction, - const bal_decoder_operand_t *operand) +extract_operand_value(const uint32_t instruction, const bal_decoder_operand_t *operand) { if (BAL_OPERAND_TYPE_NONE == operand->type) { @@ -316,11 +281,11 @@ extract_operand_value (const uint32_t instruction, } BAL_HOT static uint32_t -intern_constant (bal_constant_t constant, - bal_constant_t *BAL_RESTRICT constants, - bal_constant_count_t *BAL_RESTRICT count, - size_t constants_max_size, - bal_error_t *BAL_RESTRICT status) +intern_constant(bal_constant_t constant, + bal_constant_t *BAL_RESTRICT constants, + bal_constant_count_t *BAL_RESTRICT count, + size_t constants_max_size, + bal_error_t *BAL_RESTRICT status) { if (BAL_UNLIKELY(*status != BAL_SUCCESS)) { diff --git a/src/bal_memory.c b/src/bal_memory.c index 0a21d85..02af942 100644 --- a/src/bal_memory.c +++ b/src/bal_memory.c @@ -1,12 +1,10 @@ #include "bal_memory.h" -#include #include +#include static void *default_allocate(void *, size_t, size_t); static void default_free(void *, void *, size_t); -BAL_HOT static const uint8_t *_bal_translate_flat(void *, - bal_guest_address_t, - size_t *); +BAL_HOT static const uint8_t *_bal_translate_flat(void *, bal_guest_address_t, size_t *); typedef struct { @@ -15,7 +13,7 @@ typedef struct } flat_translation_interface_t; void -bal_get_default_allocator (bal_allocator_t *out_allocator) +bal_get_default_allocator(bal_allocator_t *out_allocator) { out_allocator->allocator = NULL; out_allocator->allocate = default_allocate; @@ -23,10 +21,10 @@ bal_get_default_allocator (bal_allocator_t *out_allocator) } bal_error_t -bal_memory_init_flat (bal_allocator_t *BAL_RESTRICT allocator, - bal_memory_interface_t *BAL_RESTRICT interface, - void *BAL_RESTRICT buffer, - size_t size) +bal_memory_init_flat(bal_allocator_t *BAL_RESTRICT allocator, + bal_memory_interface_t *BAL_RESTRICT interface, + void *BAL_RESTRICT buffer, + size_t size) { if (NULL == allocator || NULL == interface || NULL == buffer || 0 == size) { @@ -53,8 +51,7 @@ bal_memory_init_flat (bal_allocator_t *BAL_RESTRICT allocator, } void -bal_memory_destroy_flat (bal_allocator_t *allocator, - bal_memory_interface_t *interface) +bal_memory_destroy_flat(bal_allocator_t *allocator, bal_memory_interface_t *interface) { if (NULL == allocator || NULL == interface) { @@ -66,14 +63,13 @@ bal_memory_destroy_flat (bal_allocator_t *allocator, return; } - allocator->free( - allocator, interface->context, sizeof(flat_translation_interface_t)); + allocator->free(allocator, interface->context, sizeof(flat_translation_interface_t)); } #if BAL_PLATFORM_POSIX static void * -default_allocate (void *allocator, size_t alignment, size_t size) +default_allocate(void *allocator, size_t alignment, size_t size) { if (0 == size) { @@ -85,7 +81,7 @@ default_allocate (void *allocator, size_t alignment, size_t size) } static void -default_free (void *allocator, void *pointer, size_t size) +default_free(void *allocator, void *pointer, size_t size) { free(pointer); } @@ -97,7 +93,7 @@ default_free (void *allocator, void *pointer, size_t size) #include static void * -default_allocate (void *allocator, size_t alignment, size_t size) +default_allocate(void *allocator, size_t alignment, size_t size) { if (0 == size) { @@ -109,7 +105,7 @@ default_allocate (void *allocator, size_t alignment, size_t size) } static void -default_free (void *allocator, void *pointer, size_t size) +default_free(void *allocator, void *pointer, size_t size) { _aligned_free(pointer); } @@ -117,19 +113,17 @@ default_free (void *allocator, void *pointer, size_t size) #endif /* BAL_PLATFORM_WINDOWS */ static const uint8_t * -_bal_translate_flat (void *BAL_RESTRICT interface, - bal_guest_address_t guest_address, - size_t *BAL_RESTRICT max_readable_size) +_bal_translate_flat(void *BAL_RESTRICT interface, + bal_guest_address_t guest_address, + size_t *BAL_RESTRICT max_readable_size) { - if (BAL_UNLIKELY(NULL == interface || 0 == guest_address - || NULL == max_readable_size)) + if (BAL_UNLIKELY(NULL == interface || 0 == guest_address || NULL == max_readable_size)) { return NULL; } flat_translation_interface_t *BAL_RESTRICT context - = (flat_translation_interface_t *)((bal_memory_interface_t *)interface) - ->context; + = (flat_translation_interface_t *)((bal_memory_interface_t *)interface)->context; // Is address out of bounds. // diff --git a/src/decoder.c b/src/decoder.c index 5b5b2a2..df4076a 100644 --- a/src/decoder.c +++ b/src/decoder.c @@ -12,7 +12,7 @@ bal_decode_arm64(const uint32_t instruction) const decoder_bucket_t *bucket = &g_decoder_lookup_table[index]; for (size_t i = 0; i < bucket->count; ++i) { - const bal_decoder_instruction_metadata_t* metadata = bucket->instructions[i]; + const bal_decoder_instruction_metadata_t *metadata = bucket->instructions[i]; if ((instruction & metadata->mask) == metadata->expected) {