mirrors/pound-emu_pound
0
0
Fork 0
mirror of https://github.com/pound-emu/pound.git synced 2025-12-12 01:36:57 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

jit: Add Barr C code standard

Browse source 
Signed-off-by: Ronald Caesar <github43132@proton.me>
This commit is contained in:
Ronald Caesar 2025-10-26 13:59:48 -04:00
parent a543f78b77
commit 1c3b730899
No known key found for this signature in database
GPG key ID: 04307C401999C596
5 changed files with 1628 additions and 136 deletions
Download patch file Download diff file Expand all files Collapse all files

157
.clang-format Executable file → Normal file
View file

@ -1,83 +1,140 @@
# Google C/C++ Code Style settings ---
# https://clang.llvm.org/docs/ClangFormatStyleOptions.html
# Author: Kehan Xue, kehan.xue (at) gmail.com
Language: Cpp Language: Cpp
BasedOnStyle: Google AccessModifierOffset: -4
AccessModifierOffset: -1
AlignAfterOpenBracket: Align AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: None AlignConsecutiveMacros: true
AlignOperands: Align AlignConsecutiveAssignments: true
AlignConsecutiveDeclarations: true
AlignEscapedNewlines: Left
AlignOperands: true
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: true AllowAllArgumentsOnNextLine: true
AllowAllConstructorInitializersOnNextLine: true AllowAllConstructorInitializersOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: false AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: Empty AllowShortBlocksOnASingleLine: Never
AllowShortCaseLabelsOnASingleLine: false AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: Inline AllowShortFunctionsOnASingleLine: None
AllowShortIfStatementsOnASingleLine: Never # To avoid conflict, set this "Never" and each "if statement" should include brace when coding AllowShortLambdasOnASingleLine: All
AllowShortLambdasOnASingleLine: Inline AllowShortIfStatementsOnASingleLine: Never
AllowShortLoopsOnASingleLine: false AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterReturnType: None AlwaysBreakAfterDefinitionReturnType: TopLevel
AlwaysBreakAfterReturnType: TopLevelDefinitions
AlwaysBreakBeforeMultilineStrings: true
AlwaysBreakTemplateDeclarations: Yes AlwaysBreakTemplateDeclarations: Yes
BinPackArguments: true BinPackArguments: false
BreakBeforeBraces: Allman BinPackParameters: false
BraceWrapping: BraceWrapping:
AfterCaseLabel: false AfterCaseLabel: false
AfterClass: false AfterClass: true
AfterStruct: false AfterControlStatement: true
AfterControlStatement: Never AfterEnum: true
AfterEnum: false AfterFunction: true
AfterFunction: false
AfterNamespace: false AfterNamespace: false
AfterUnion: false AfterObjCDeclaration: true
AfterExternBlock: false AfterStruct: true
BeforeCatch: false AfterUnion: true
BeforeElse: false AfterExternBlock: true
BeforeLambdaBody: false BeforeCatch: true
BeforeElse: true
IndentBraces: false IndentBraces: false
SplitEmptyFunction: false SplitEmptyFunction: true
SplitEmptyRecord: false SplitEmptyRecord: true
SplitEmptyNamespace: false SplitEmptyNamespace: true
BreakBeforeBinaryOperators: None BreakBeforeBinaryOperators: All
BreakBeforeBraces: Custom
BreakBeforeInheritanceComma: false
BreakInheritanceList: BeforeComma
BreakBeforeTernaryOperators: true BreakBeforeTernaryOperators: true
BreakConstructorInitializers: BeforeColon BreakConstructorInitializersBeforeComma: false
BreakInheritanceList: BeforeColon BreakConstructorInitializers: BeforeComma
ColumnLimit: 120 BreakAfterJavaFieldAnnotations: true
BreakStringLiterals: true
ColumnLimit: 80
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4 ContinuationIndentWidth: 4
Cpp11BracedListStyle: true Cpp11BracedListStyle: false
DerivePointerAlignment: false # Make sure the * or & align on the left DeriveLineEnding: true
EmptyLineBeforeAccessModifier: LogicalBlock DerivePointerAlignment: false
FixNamespaceComments: true DisableFormat: false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: false
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IncludeBlocks: Preserve IncludeBlocks: Preserve
IncludeCategories:
- Regex: '^"(llvm|llvm-c|clang|clang-c)/'
Priority: 2
SortPriority: 0
- Regex: '^(<|"(gtest|gmock|isl|json)/)'
Priority: 3
SortPriority: 0
- Regex: '.*'
Priority: 1
SortPriority: 0
IncludeIsMainRegex: '(Test)?$'
IncludeIsMainSourceRegex: ''
IndentCaseLabels: true IndentCaseLabels: true
IndentGotoLabels: true
IndentPPDirectives: None IndentPPDirectives: None
IndentWidth: 4 IndentWidth: 4
IndentWrappedFunctionNames: false
InsertBraces: true
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: true KeepEmptyLinesAtTheStartOfBlocks: true
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1 MaxEmptyLinesToKeep: 1
NamespaceIndentation: None NamespaceIndentation: None
ObjCSpaceAfterProperty: false ObjCBinPackProtocolList: Auto
ObjCSpaceBeforeProtocolList: true ObjCBlockIndentWidth: 4
PointerAlignment: Left ObjCSpaceAfterProperty: true
ReflowComments: false ObjCSpaceBeforeProtocolList: false
# SeparateDefinitionBlocks: Always # Only support since clang-format 14 PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 200
PointerAlignment: Right
ReflowComments: true
SortIncludes: false
SortUsingDeclarations: false
SpaceAfterCStyleCast: false SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true SpaceAfterTemplateKeyword: false
SpaceBeforeAssignmentOperators: true SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: false SpaceBeforeCpp11BracedList: true
SpaceBeforeCtorInitializerColon: true SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements SpaceBeforeParens: Custom
SpaceBeforeParensOptions:
AfterControlStatements: true
AfterFunctionDefinitionName: true
SpaceBeforeRangeBasedForLoopColon: true SpaceBeforeRangeBasedForLoopColon: true
SpaceBeforeSquareBrackets: false SpaceInEmptyBlock: false
SpaceInEmptyParentheses: false SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 2 SpacesBeforeTrailingComments: 1
SpacesInAngles: false SpacesInAngles: false
SpacesInCStyleCastParentheses: false SpacesInConditionalStatement: false
SpacesInContainerLiterals: false SpacesInContainerLiterals: false
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false SpacesInParentheses: false
SpacesInSquareBrackets: false SpacesInSquareBrackets: false
Standard: c++11 SpaceBeforeSquareBrackets: false
TabWidth: 4 Standard: Latest
StatementMacros:
- Q_UNUSED
- QT_REQUIRE_VERSION
TabWidth: 8
UseCRLF: false
UseTab: Never UseTab: Never
...

1428
BARC-style-guide.pdf Executable file
View file

File diff suppressed because one or more lines are too long

12
src/jit/CMakeLists.txt
View file

@ -1,12 +0,0 @@
add_library(jit STATIC)
target_sources(jit PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/decoder/arm32.cpp
)
target_link_libraries(jit PRIVATE common host)
target_include_directories(jit PUBLIC
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/..
)

125
src/jit/decoder/arm32.cpp
View file

@ -5,59 +5,69 @@
#define LOG_MODULE "jit" #define LOG_MODULE "jit"
#include "common/logging.h" #include "common/logging.h"
namespace pound::jit::decoder namespace pound::jit::decoder {
{
#define INSTRUCTION_ARRAY_CAPACITY 261 #define INSTRUCTION_ARRAY_CAPACITY 261
#define INSTRUCTION_BITSTRING_LENGTH 32
#define HASH_TABLE_INVALID_INDEX 0xFFFF
/* /*
* ============================================================================ * ============================================================================
* Foward Declarations * Foward Declarations
* ============================================================================ * ============================================================================
*/ */
static void arm32_add_instruction(arm32_decoder_t* decoder, const char* name, const char* bitstring); static void arm32_add_instruction(arm32_decoder_t *p_decoder,
static void arm32_parse_bitstring(const char* bitstring, uint32_t* mask, uint32_t* expected); const char *p_name,
const char *p_bitstring);
static void arm32_parse_bitstring(const char *p_bitstring,
uint32_t *p_mask,
uint32_t *p_expected);
/* /*
* ============================================================================ * ============================================================================
* Public Functions * Public Functions
* ============================================================================ * ============================================================================
*/ */
void arm32_init(pound::host::memory::arena_t allocator, arm32_decoder_t* decoder) void
arm32_init (pound::host::memory::arena_t allocator, arm32_decoder_t *p_decoder)
{ {
PVM_ASSERT(nullptr != decoder); PVM_ASSERT(nullptr != p_decoder);
PVM_ASSERT(nullptr != allocator.data); PVM_ASSERT(nullptr != allocator.data);
(void)memset(decoder, 0, sizeof(arm32_decoder_t)); (void)memset(p_decoder, 0, sizeof(arm32_decoder_t));
decoder->allocator = allocator; p_decoder->allocator = allocator;
/* Setup Instructions array.*/ /* Setup Instructions array.*/
size_t instructions_array_size = INSTRUCTION_ARRAY_CAPACITY * sizeof(arm32_instruction_info_t); size_t instructions_array_size
PVM_ASSERT(instructions_array_size <= decoder->allocator.capacity); = INSTRUCTION_ARRAY_CAPACITY * sizeof(arm32_instruction_info_t);
LOG_TRACE("Allocated %d bytes to instructions array", instructions_array_size); PVM_ASSERT(instructions_array_size <= p_decoder->allocator.capacity);
LOG_TRACE("Allocated %d bytes to instructions array",
instructions_array_size);
void* new_ptr = pound::host::memory::arena_allocate(&decoder->allocator, instructions_array_size); void *p_memory = pound::host::memory::arena_allocate(
PVM_ASSERT(nullptr != new_ptr); &p_decoder->allocator, instructions_array_size);
PVM_ASSERT(nullptr != p_memory);
decoder->instructions = (arm32_instruction_info_t*)new_ptr; p_decoder->p_instructions = (arm32_instruction_info_t *)p_memory;
decoder->instruction_capacity = INSTRUCTION_ARRAY_CAPACITY; p_decoder->instruction_capacity = INSTRUCTION_ARRAY_CAPACITY;
/* Add all Arm32 instructions */ /* Add all Arm32 instructions */
#define INST(fn, name, bitstring) arm32_add_instruction(decoder, name, bitstring); #define INST(fn, name, bitstring) \
arm32_add_instruction(p_decoder, name, bitstring);
#include "./arm32.inc" #include "./arm32.inc"
#undef INST #undef INST
} }
arm32_instruction_info_t* arm32_decode(arm32_decoder_t* decoder, uint32_t instruction) arm32_instruction_info_t *
arm32_decode (arm32_decoder_t *p_decoder, uint32_t instruction)
{ {
for (size_t i = 0; i < decoder->instruction_count; ++i) for (size_t i = 0; i < p_decoder->instruction_count; ++i)
{ {
arm32_instruction_info_t* info = &decoder->instructions[i]; arm32_instruction_info_t *p_info = &p_decoder->p_instructions[i];
if ((instruction & info->mask) == info->expected) if ((instruction & p_info->mask) == p_info->expected)
{ {
LOG_TRACE("Instruction found for 0x%08X: %s", instruction, info->name); LOG_TRACE("Instruction found for 0x%08X: %s",
return info; instruction,
p_info->p_name);
return p_info;
} }
} }
PVM_ASSERT_MSG(false, "No instruction found for 0x%08X", instruction); PVM_ASSERT_MSG(false, "No instruction found for 0x%08X", instruction);
@ -69,55 +79,64 @@ arm32_instruction_info_t* arm32_decode(arm32_decoder_t* decoder, uint32_t instru
* ============================================================================ * ============================================================================
*/ */
static void arm32_add_instruction(arm32_decoder_t* decoder, const char* name, const char* bitstring) static void
arm32_add_instruction (arm32_decoder_t *p_decoder,
const char *p_name,
const char *p_bitstring)
{ {
PVM_ASSERT(nullptr != decoder); PVM_ASSERT(nullptr != p_decoder);
PVM_ASSERT(nullptr != decoder->allocator.data); PVM_ASSERT(nullptr != p_decoder->allocator.data);
PVM_ASSERT(nullptr != name); PVM_ASSERT(nullptr != p_name);
PVM_ASSERT(nullptr != bitstring); PVM_ASSERT(nullptr != p_bitstring);
PVM_ASSERT(decoder->instruction_count < decoder->instruction_capacity); PVM_ASSERT(p_decoder->instruction_count < p_decoder->instruction_capacity);
uint32_t mask = 0; uint32_t mask = 0;
uint32_t expected = 0; uint32_t expected = 0;
arm32_parse_bitstring(bitstring, &mask, &expected); arm32_parse_bitstring(p_bitstring, &mask, &expected);
arm32_instruction_info_t* info = &decoder->instructions[decoder->instruction_count]; arm32_instruction_info_t *p_info
PVM_ASSERT(nullptr != info); = &p_decoder->p_instructions[p_decoder->instruction_count];
info->name = name; PVM_ASSERT(nullptr != p_info);
info->mask = mask; p_info->p_name = p_name;
info->expected = expected; p_info->mask = mask;
p_info->expected = expected;
++decoder->instruction_count; ++p_decoder->instruction_count;
LOG_TRACE("Instruction Registered: %s", info->name); LOG_TRACE("Instruction Registered: %s", p_info->p_name);
LOG_TRACE("Mask: 0x%08X", info->mask); LOG_TRACE("Mask: 0x%08X", p_info->mask);
LOG_TRACE("Expected: 0x%08X", info->expected); LOG_TRACE("Expected: 0x%08X", p_info->expected);
} }
static void arm32_parse_bitstring(const char* bitstring, uint32_t* mask, uint32_t* expected) static void
arm32_parse_bitstring (const char *p_bitstring,
uint32_t *p_mask,
uint32_t *p_expected)
{ {
PVM_ASSERT(nullptr != bitstring); PVM_ASSERT(nullptr != p_bitstring);
PVM_ASSERT(nullptr != mask); PVM_ASSERT(nullptr != p_mask);
PVM_ASSERT(nullptr != expected); PVM_ASSERT(nullptr != p_expected);
PVM_ASSERT(32 == strlen(bitstring)); PVM_ASSERT(INSTRUCTION_BITSTRING_LENGTH == strlen(p_bitstring));
*mask = 0; *p_mask = 0;
*expected = 0; *p_expected = 0;
uint8_t instruction_size_bits = 32; uint8_t instruction_size_bits = 32;
for (unsigned int i = 0; (i < instruction_size_bits) && (bitstring[i] != '\0'); ++i) for (unsigned int i = 0;
(i < instruction_size_bits) && (p_bitstring[i] != '\0');
++i)
{ {
uint32_t bit_position = 31 - i; uint32_t bit_position = 31 - i;
switch (bitstring[i]) switch (p_bitstring[i])
{ {
case '0': case '0':
*mask |= (1U << bit_position); *p_mask |= (1U << bit_position);
break; break;
case '1': case '1':
*mask |= (1U << bit_position); *p_mask |= (1U << bit_position);
*expected |= (1U << bit_position); *p_expected |= (1U << bit_position);
default: default:
break; break;
} }
} }
} }
} // namespace pound::jit::decoder } // namespace pound::jit::p_decoder

14
src/jit/decoder/arm32.h
View file

@ -5,14 +5,12 @@
#include <stdint.h> #include <stdint.h>
#include "host/memory/arena.h" #include "host/memory/arena.h"
namespace pound::jit::decoder namespace pound::jit::decoder {
{
typedef struct arm32_decoder arm32_decoder_t; typedef struct arm32_decoder arm32_decoder_t;
typedef void (*arm32_handler_fn)(arm32_decoder_t* decoder, uint32_t instruction);
typedef struct typedef struct
{ {
const char* name; const char *p_name;
uint32_t mask; uint32_t mask;
uint32_t expected; uint32_t expected;
} arm32_instruction_info_t; } arm32_instruction_info_t;
@ -20,14 +18,16 @@ typedef struct
struct arm32_decoder struct arm32_decoder
{ {
pound::host::memory::arena_t allocator; pound::host::memory::arena_t allocator;
arm32_instruction_info_t* instructions; arm32_instruction_info_t *p_instructions;
size_t instruction_count; size_t instruction_count;
size_t instruction_capacity; size_t instruction_capacity;
}; };
extern arm32_decoder_t g_arm32_decoder; extern arm32_decoder_t g_arm32_decoder;
void arm32_init(pound::host::memory::arena_t allocator, arm32_decoder_t* decoder); void arm32_init(pound::host::memory::arena_t allocator,
arm32_instruction_info_t* arm32_decode(arm32_decoder_t* decoder, uint32_t instruction); arm32_decoder_t *p_decoder);
arm32_instruction_info_t *arm32_decode(arm32_decoder_t *p_decoder,
uint32_t instruction);
} }
#endif // POUND_JIT_DECODER_ARM32_H #endif // POUND_JIT_DECODER_ARM32_H