mirror of
https://github.com/Atmosphere-NX/Atmosphere.git
synced 2025-05-27 21:24:11 -04:00
svc: use m_ for member variables
This commit is contained in:
Michael Scire
parent
00116450c3
commit
ce28591ab2
8 changed files with 281 additions and 280 deletions
|
|
@ -144,11 +144,11 @@ namespace ams::svc::codegen::impl {
|
|||
template<size_t N>
|
||||
class RegisterAllocator {
|
||||
public:
|
||||
std::array<bool, N> map;
|
||||
std::array<bool, N> m_map;
|
||||
public:
|
||||
constexpr explicit RegisterAllocator() : map() { /* ... */ }
|
||||
constexpr explicit RegisterAllocator() : m_map() { /* ... */ }
|
||||
|
||||
constexpr bool IsAllocated(size_t i) const { return this->map[i]; }
|
||||
constexpr bool IsAllocated(size_t i) const { return m_map[i]; }
|
||||
constexpr bool IsFree(size_t i) const { return !this->IsAllocated(i); }
|
||||
|
||||
constexpr void Allocate(size_t i) {
|
||||
|
|
@ -156,7 +156,7 @@ namespace ams::svc::codegen::impl {
|
|||
std::abort();
|
||||
}
|
||||
|
||||
this->map[i] = true;
|
||||
m_map[i] = true;
|
||||
}
|
||||
|
||||
constexpr bool TryAllocate(size_t i) {
|
||||
|
|
@ -164,14 +164,14 @@ namespace ams::svc::codegen::impl {
|
|||
return false;
|
||||
}
|
||||
|
||||
this->map[i] = true;
|
||||
m_map[i] = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
constexpr size_t AllocateFirstFree() {
|
||||
for (size_t i = 0; i < N; i++) {
|
||||
if (!this->IsAllocated(i)) {
|
||||
this->map[i] = true;
|
||||
m_map[i] = true;
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
|
@ -184,7 +184,7 @@ namespace ams::svc::codegen::impl {
|
|||
std::abort();
|
||||
}
|
||||
|
||||
this->map[i] = false;
|
||||
m_map[i] = false;
|
||||
}
|
||||
|
||||
constexpr size_t GetRegisterCount() const {
|
||||
|
|
|
|||
|
|
@ -26,30 +26,30 @@ namespace ams::svc::codegen::impl {
|
|||
static constexpr size_t InvalidIndex = std::numeric_limits<size_t>::max();
|
||||
public:
|
||||
/* ABI parameters. */
|
||||
Abi abi;
|
||||
Abi m_abi;
|
||||
|
||||
/* Parameter storage. */
|
||||
size_t num_parameters;
|
||||
Parameter parameters[MaxParameters];
|
||||
size_t m_num_parameters;
|
||||
Parameter m_parameters[MaxParameters];
|
||||
public:
|
||||
constexpr explicit ParameterLayout(Abi a)
|
||||
: abi(a), num_parameters(0), parameters()
|
||||
: m_abi(a), m_num_parameters(0), m_parameters()
|
||||
{ /* ... */ }
|
||||
|
||||
constexpr void AddSingle(Parameter::Identifier id, ArgumentType type, size_t ts, size_t ps, bool p, bool b, Storage s, size_t idx) {
|
||||
for (size_t i = 0; i < this->num_parameters; i++) {
|
||||
if (this->parameters[i].Is(id)) {
|
||||
this->parameters[i].AddLocation(Location(s, idx));
|
||||
for (size_t i = 0; i < m_num_parameters; i++) {
|
||||
if (m_parameters[i].Is(id)) {
|
||||
m_parameters[i].AddLocation(Location(s, idx));
|
||||
return;
|
||||
}
|
||||
}
|
||||
this->parameters[this->num_parameters++] = Parameter(id, type, ts, ps, p, b, Location(s, idx));
|
||||
m_parameters[m_num_parameters++] = Parameter(id, type, ts, ps, p, b, Location(s, idx));
|
||||
}
|
||||
|
||||
constexpr size_t Add(Parameter::Identifier id, ArgumentType type, size_t ts, size_t ps, bool p, bool b, Storage s, size_t i) {
|
||||
size_t required_registers = 0;
|
||||
|
||||
while (required_registers * this->abi.register_size < ps) {
|
||||
while (required_registers * m_abi.register_size < ps) {
|
||||
this->AddSingle(id, type, ts, ps, p, b, s, i++);
|
||||
required_registers++;
|
||||
}
|
||||
|
|
@ -58,8 +58,8 @@ namespace ams::svc::codegen::impl {
|
|||
}
|
||||
|
||||
constexpr bool UsesLocation(Location l) const {
|
||||
for (size_t i = 0; i < this->num_parameters; i++) {
|
||||
if (this->parameters[i].UsesLocation(l)) {
|
||||
for (size_t i = 0; i < m_num_parameters; i++) {
|
||||
if (m_parameters[i].UsesLocation(l)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
@ -75,16 +75,16 @@ namespace ams::svc::codegen::impl {
|
|||
}
|
||||
|
||||
constexpr size_t GetNumParameters() const {
|
||||
return this->num_parameters;
|
||||
return m_num_parameters;
|
||||
}
|
||||
|
||||
constexpr Parameter GetParameter(size_t i) const {
|
||||
return this->parameters[i];
|
||||
return m_parameters[i];
|
||||
}
|
||||
|
||||
constexpr bool HasParameter(Parameter::Identifier id) const {
|
||||
for (size_t i = 0; i < this->num_parameters; i++) {
|
||||
if (this->parameters[i].Is(id)) {
|
||||
for (size_t i = 0; i < m_num_parameters; i++) {
|
||||
if (m_parameters[i].Is(id)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
@ -92,20 +92,21 @@ namespace ams::svc::codegen::impl {
|
|||
}
|
||||
|
||||
constexpr Parameter GetParameter(Parameter::Identifier id) const {
|
||||
for (size_t i = 0; i < this->num_parameters; i++) {
|
||||
if (this->parameters[i].Is(id)) {
|
||||
return this->parameters[i];
|
||||
for (size_t i = 0; i < m_num_parameters; i++) {
|
||||
if (m_parameters[i].Is(id)) {
|
||||
return m_parameters[i];
|
||||
}
|
||||
}
|
||||
std::abort();
|
||||
|
||||
AMS_ASSUME(false);
|
||||
}
|
||||
};
|
||||
|
||||
class ProcedureLayout {
|
||||
public:
|
||||
Abi abi;
|
||||
ParameterLayout input;
|
||||
ParameterLayout output;
|
||||
Abi m_abi;
|
||||
ParameterLayout m_input;
|
||||
ParameterLayout m_output;
|
||||
private:
|
||||
template<typename AbiType, typename ArgType>
|
||||
constexpr void ProcessArgument(size_t i, size_t &NGRN, size_t &NSAA) {
|
||||
|
|
@ -136,19 +137,19 @@ namespace ams::svc::codegen::impl {
|
|||
const size_t registers_available = AbiType::RegisterCount - NGRN;
|
||||
if constexpr (!PassedByPointer && IsIntegralOrUserPointer<ArgType> && ArgumentTypeSize > AbiType::RegisterSize) {
|
||||
if (registers_available >= 2) {
|
||||
this->input.Add(id, Type, ArgumentTypeSize, ArgumentPassSize, PassedByPointer, IsBoolean, Storage::Register, NGRN);
|
||||
m_input.Add(id, Type, ArgumentTypeSize, ArgumentPassSize, PassedByPointer, IsBoolean, Storage::Register, NGRN);
|
||||
NGRN += 2;
|
||||
} else {
|
||||
/* Argument went on stack, so stop allocating arguments in registers. */
|
||||
NGRN = AbiType::RegisterCount;
|
||||
|
||||
NSAA += (NSAA & 1);
|
||||
this->input.Add(id, Type, ArgumentTypeSize, ArgumentPassSize, PassedByPointer, IsBoolean, Storage::Stack, NSAA);
|
||||
m_input.Add(id, Type, ArgumentTypeSize, ArgumentPassSize, PassedByPointer, IsBoolean, Storage::Stack, NSAA);
|
||||
NSAA += 2;
|
||||
}
|
||||
} else {
|
||||
if (ArgumentPassSize <= AbiType::RegisterSize * registers_available) {
|
||||
NGRN += this->input.Add(id, Type, ArgumentTypeSize, ArgumentPassSize, PassedByPointer, IsBoolean, Storage::Register, NGRN);
|
||||
NGRN += m_input.Add(id, Type, ArgumentTypeSize, ArgumentPassSize, PassedByPointer, IsBoolean, Storage::Register, NGRN);
|
||||
} else {
|
||||
/* Argument went on stack, so stop allocating arguments in registers. */
|
||||
NGRN = AbiType::RegisterCount;
|
||||
|
|
@ -156,12 +157,12 @@ namespace ams::svc::codegen::impl {
|
|||
/* TODO: Stack pointer alignment is only ensured for aapcs64. */
|
||||
/* What should we do here? */
|
||||
|
||||
NSAA += this->input.Add(id, Type, ArgumentTypeSize, ArgumentPassSize, PassedByPointer, IsBoolean, Storage::Stack, NSAA);
|
||||
NSAA += m_input.Add(id, Type, ArgumentTypeSize, ArgumentPassSize, PassedByPointer, IsBoolean, Storage::Stack, NSAA);
|
||||
}
|
||||
}
|
||||
}
|
||||
public:
|
||||
constexpr explicit ProcedureLayout(Abi a) : abi(a), input(a), output(a) { /* ... */ }
|
||||
constexpr explicit ProcedureLayout(Abi a) : m_abi(a), m_input(a), m_output(a) { /* ... */ }
|
||||
|
||||
template<typename AbiType, typename ReturnType, typename... ArgumentTypes>
|
||||
static constexpr ProcedureLayout Create() {
|
||||
|
|
@ -177,7 +178,7 @@ namespace ams::svc::codegen::impl {
|
|||
/* TODO: It's unclear how to handle the non-integral and too-large case. */
|
||||
if constexpr (!std::is_same<ReturnType, void>::value) {
|
||||
constexpr size_t ReturnTypeSize = AbiType::template Size<ReturnType>;
|
||||
layout.output.Add(Parameter::Identifier("ReturnType"), ArgumentType::Invalid, ReturnTypeSize, ReturnTypeSize, false, false /* TODO */, Storage::Register, 0);
|
||||
layout.m_output.Add(Parameter::Identifier("ReturnType"), ArgumentType::Invalid, ReturnTypeSize, ReturnTypeSize, false, false /* TODO */, Storage::Register, 0);
|
||||
static_assert(IsIntegral<ReturnType> || ReturnTypeSize <= AbiType::RegisterSize);
|
||||
}
|
||||
|
||||
|
|
@ -189,27 +190,27 @@ namespace ams::svc::codegen::impl {
|
|||
}
|
||||
|
||||
constexpr ParameterLayout GetInputLayout() const {
|
||||
return this->input;
|
||||
return m_input;
|
||||
}
|
||||
|
||||
constexpr ParameterLayout GetOutputLayout() const {
|
||||
return this->output;
|
||||
return m_output;
|
||||
}
|
||||
|
||||
constexpr Parameter GetParameter(Parameter::Identifier id) const {
|
||||
if (this->input.HasParameter(id)) {
|
||||
return this->input.GetParameter(id);
|
||||
if (m_input.HasParameter(id)) {
|
||||
return m_input.GetParameter(id);
|
||||
} else {
|
||||
return this->output.GetParameter(id);
|
||||
return m_output.GetParameter(id);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
class SvcInvocationLayout {
|
||||
public:
|
||||
Abi abi;
|
||||
ParameterLayout input;
|
||||
ParameterLayout output;
|
||||
Abi m_abi;
|
||||
ParameterLayout m_input;
|
||||
ParameterLayout m_output;
|
||||
private:
|
||||
template<typename F>
|
||||
constexpr void ForEachInputArgument(ParameterLayout param_layout, F f) {
|
||||
|
|
@ -296,7 +297,7 @@ namespace ams::svc::codegen::impl {
|
|||
}
|
||||
}
|
||||
public:
|
||||
constexpr explicit SvcInvocationLayout(Abi a) : abi(a), input(a), output(a) { /* ... */ }
|
||||
constexpr explicit SvcInvocationLayout(Abi a) : m_abi(a), m_input(a), m_output(a) { /* ... */ }
|
||||
|
||||
template<typename AbiType>
|
||||
static constexpr SvcInvocationLayout Create(ProcedureLayout procedure_layout) {
|
||||
|
|
@ -305,17 +306,17 @@ namespace ams::svc::codegen::impl {
|
|||
|
||||
/* Input first wants to map in register -> register */
|
||||
layout.ForEachInputArgument(procedure_layout.GetInputLayout(), [&](Parameter parameter) {
|
||||
AddRegisterParameter(layout.input, input_register_allocator, parameter);
|
||||
AddRegisterParameter(layout.m_input, input_register_allocator, parameter);
|
||||
});
|
||||
|
||||
/* And then input wants to map in stack -> stack */
|
||||
layout.ForEachInputArgument(procedure_layout.GetInputLayout(), [&](Parameter parameter) {
|
||||
AddStackParameter(layout.input, input_register_allocator, parameter);
|
||||
AddStackParameter(layout.m_input, input_register_allocator, parameter);
|
||||
});
|
||||
|
||||
/* And then input wants to map in indirects -> register */
|
||||
layout.ForEachInputPointerArgument(procedure_layout.GetInputLayout(), [&](Parameter parameter) {
|
||||
AddIndirectParameter<AbiType>(layout.input, input_register_allocator, parameter);
|
||||
AddIndirectParameter<AbiType>(layout.m_input, input_register_allocator, parameter);
|
||||
});
|
||||
|
||||
/* Handle the return type. */
|
||||
|
|
@ -327,23 +328,23 @@ namespace ams::svc::codegen::impl {
|
|||
if (return_param.GetIdentifier() != Parameter::Identifier("ReturnType")) {
|
||||
std::abort();
|
||||
}
|
||||
AddRegisterParameter(layout.output, output_register_allocator, return_param);
|
||||
AddRegisterParameter(layout.m_output, output_register_allocator, return_param);
|
||||
}
|
||||
|
||||
/* Handle other outputs. */
|
||||
layout.ForEachOutputArgument(procedure_layout.GetInputLayout(), [&](Parameter parameter) {
|
||||
AddIndirectParameter<AbiType>(layout.output, output_register_allocator, parameter);
|
||||
AddIndirectParameter<AbiType>(layout.m_output, output_register_allocator, parameter);
|
||||
});
|
||||
|
||||
return layout;
|
||||
}
|
||||
|
||||
constexpr ParameterLayout GetInputLayout() const {
|
||||
return this->input;
|
||||
return m_input;
|
||||
}
|
||||
|
||||
constexpr ParameterLayout GetOutputLayout() const {
|
||||
return this->output;
|
||||
return m_output;
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -82,21 +82,21 @@ namespace ams::svc::codegen::impl {
|
|||
return op;
|
||||
}
|
||||
public:
|
||||
size_t num_operations;
|
||||
std::array<Operation, MaxOperations> operations;
|
||||
size_t m_num_operations;
|
||||
std::array<Operation, MaxOperations> m_operations;
|
||||
public:
|
||||
constexpr explicit MetaCode() : num_operations(0), operations() { /* ... */ }
|
||||
constexpr explicit MetaCode() : m_num_operations(0), m_operations() { /* ... */ }
|
||||
|
||||
constexpr size_t GetNumOperations() const {
|
||||
return this->num_operations;
|
||||
return m_num_operations;
|
||||
}
|
||||
|
||||
constexpr Operation GetOperation(size_t i) const {
|
||||
return this->operations[i];
|
||||
return m_operations[i];
|
||||
}
|
||||
|
||||
constexpr void AddOperation(Operation op) {
|
||||
this->operations[this->num_operations++] = op;
|
||||
m_operations[m_num_operations++] = op;
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -140,102 +140,102 @@ namespace ams::svc::codegen::impl {
|
|||
private:
|
||||
using OperationKind = typename MetaCode::OperationKind;
|
||||
private:
|
||||
MetaCode meta_code;
|
||||
MetaCode m_meta_code;
|
||||
public:
|
||||
constexpr explicit MetaCodeGenerator() : meta_code() { /* ... */ }
|
||||
constexpr explicit MetaCodeGenerator() : m_meta_code() { /* ... */ }
|
||||
|
||||
constexpr MetaCode GetMetaCode() const {
|
||||
return this->meta_code;
|
||||
return m_meta_code;
|
||||
}
|
||||
|
||||
constexpr void AddOperationDirectly(MetaCode::Operation op) {
|
||||
this->meta_code.AddOperation(op);
|
||||
m_meta_code.AddOperation(op);
|
||||
}
|
||||
|
||||
template<size_t... Registers>
|
||||
constexpr void SaveRegisters() {
|
||||
constexpr auto op = MetaCode::MakeOperation<OperationKind::SaveRegisters, Registers...>();
|
||||
this->meta_code.AddOperation(op);
|
||||
m_meta_code.AddOperation(op);
|
||||
}
|
||||
|
||||
template<size_t... Registers>
|
||||
constexpr void RestoreRegisters() {
|
||||
constexpr auto op = MetaCode::MakeOperation<OperationKind::RestoreRegisters, Registers...>();
|
||||
this->meta_code.AddOperation(op);
|
||||
m_meta_code.AddOperation(op);
|
||||
}
|
||||
|
||||
template<size_t... Registers>
|
||||
constexpr void ClearRegisters() {
|
||||
constexpr auto op = MetaCode::MakeOperation<OperationKind::ClearRegisters, Registers...>();
|
||||
this->meta_code.AddOperation(op);
|
||||
m_meta_code.AddOperation(op);
|
||||
}
|
||||
|
||||
template<size_t Size>
|
||||
constexpr void AllocateStackSpace() {
|
||||
constexpr auto op = MetaCode::MakeOperation<OperationKind::AllocateStackSpace, Size>();
|
||||
this->meta_code.AddOperation(op);
|
||||
m_meta_code.AddOperation(op);
|
||||
}
|
||||
|
||||
template<size_t Size>
|
||||
constexpr void FreeStackSpace() {
|
||||
constexpr auto op = MetaCode::MakeOperation<OperationKind::FreeStackSpace, Size>();
|
||||
this->meta_code.AddOperation(op);
|
||||
m_meta_code.AddOperation(op);
|
||||
}
|
||||
|
||||
template<size_t Dst, size_t Src>
|
||||
constexpr void MoveRegister() {
|
||||
constexpr auto op = MetaCode::MakeOperation<OperationKind::MoveRegister, Dst, Src>();
|
||||
this->meta_code.AddOperation(op);
|
||||
m_meta_code.AddOperation(op);
|
||||
}
|
||||
|
||||
template<size_t Reg>
|
||||
constexpr void ConvertToBoolean() {
|
||||
constexpr auto op = MetaCode::MakeOperation<OperationKind::ConvertToBoolean, Reg>();
|
||||
this->meta_code.AddOperation(op);
|
||||
m_meta_code.AddOperation(op);
|
||||
}
|
||||
|
||||
template<size_t Reg, size_t Offset, size_t Size = 0>
|
||||
constexpr void LoadFromStack() {
|
||||
constexpr auto op = MetaCode::MakeOperation<OperationKind::LoadFromStack, Reg, Offset, Size>();
|
||||
this->meta_code.AddOperation(op);
|
||||
m_meta_code.AddOperation(op);
|
||||
}
|
||||
|
||||
template<size_t Reg0, size_t Reg1, size_t Offset, size_t Size>
|
||||
constexpr void LoadPairFromStack() {
|
||||
static_assert(Offset % Size == 0);
|
||||
constexpr auto op = MetaCode::MakeOperation<OperationKind::LoadPairFromStack, Reg0, Reg1, Offset, Size>();
|
||||
this->meta_code.AddOperation(op);
|
||||
m_meta_code.AddOperation(op);
|
||||
}
|
||||
|
||||
template<size_t Reg, size_t Offset, size_t Size = 0>
|
||||
constexpr void StoreToStack() {
|
||||
constexpr auto op = MetaCode::MakeOperation<OperationKind::StoreToStack, Reg, Offset, Size>();
|
||||
this->meta_code.AddOperation(op);
|
||||
m_meta_code.AddOperation(op);
|
||||
}
|
||||
|
||||
template<size_t Reg0, size_t Reg1, size_t Offset, size_t Size>
|
||||
constexpr void StorePairToStack() {
|
||||
static_assert(Offset % Size == 0);
|
||||
constexpr auto op = MetaCode::MakeOperation<OperationKind::StorePairToStack, Reg0, Reg1, Offset, Size>();
|
||||
this->meta_code.AddOperation(op);
|
||||
m_meta_code.AddOperation(op);
|
||||
}
|
||||
|
||||
template<size_t Dst, size_t Low, size_t High>
|
||||
constexpr void Pack() {
|
||||
constexpr auto op = MetaCode::MakeOperation<OperationKind::Pack, Dst, Low, High>();
|
||||
this->meta_code.AddOperation(op);
|
||||
m_meta_code.AddOperation(op);
|
||||
}
|
||||
|
||||
template<size_t Low, size_t High, size_t Src>
|
||||
constexpr void Unpack() {
|
||||
constexpr auto op = MetaCode::MakeOperation<OperationKind::Unpack, Low, High, Src>();
|
||||
this->meta_code.AddOperation(op);
|
||||
m_meta_code.AddOperation(op);
|
||||
}
|
||||
|
||||
template<size_t Dst, size_t Offset>
|
||||
constexpr void LoadStackAddress() {
|
||||
constexpr auto op = MetaCode::MakeOperation<OperationKind::LoadStackAddress, Dst, Offset>();
|
||||
this->meta_code.AddOperation(op);
|
||||
m_meta_code.AddOperation(op);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -28,40 +28,40 @@ namespace ams::svc::codegen::impl {
|
|||
private:
|
||||
static constexpr size_t InvalidIndex = std::numeric_limits<size_t>::max();
|
||||
public:
|
||||
Storage storage;
|
||||
size_t index;
|
||||
Storage m_storage;
|
||||
size_t m_index;
|
||||
public:
|
||||
constexpr explicit Location() : storage(Storage::Invalid), index(InvalidIndex) { /* ... */ }
|
||||
constexpr explicit Location(Storage s, size_t i) : storage(s), index(i) { /* ... */ }
|
||||
constexpr explicit Location() : m_storage(Storage::Invalid), m_index(InvalidIndex) { /* ... */ }
|
||||
constexpr explicit Location(Storage s, size_t i) : m_storage(s), m_index(i) { /* ... */ }
|
||||
|
||||
constexpr size_t GetIndex() const { return this->index; }
|
||||
constexpr Storage GetStorage() const { return this->storage; }
|
||||
constexpr size_t GetIndex() const { return m_index; }
|
||||
constexpr Storage GetStorage() const { return m_storage; }
|
||||
|
||||
constexpr bool IsValid() const {
|
||||
return this->index != InvalidIndex && this->storage != Storage::Invalid;
|
||||
return m_index != InvalidIndex && m_storage != Storage::Invalid;
|
||||
}
|
||||
|
||||
constexpr bool operator==(const Location &rhs) const {
|
||||
return this->index == rhs.index && this->storage == rhs.storage;
|
||||
return m_index == rhs.m_index && m_storage == rhs.m_storage;
|
||||
}
|
||||
|
||||
constexpr bool operator<(const Location &rhs) const {
|
||||
if (this->storage < rhs.storage) {
|
||||
if (m_storage < rhs.m_storage) {
|
||||
return true;
|
||||
} else if (this->storage > rhs.storage) {
|
||||
} else if (m_storage > rhs.m_storage) {
|
||||
return false;
|
||||
} else {
|
||||
return this->index < rhs.index;
|
||||
return m_index < rhs.m_index;
|
||||
}
|
||||
}
|
||||
|
||||
constexpr bool operator>(const Location &rhs) const {
|
||||
if (this->storage > rhs.storage) {
|
||||
if (m_storage > rhs.m_storage) {
|
||||
return true;
|
||||
} else if (this->storage < rhs.storage) {
|
||||
} else if (m_storage < rhs.m_storage) {
|
||||
return false;
|
||||
} else {
|
||||
return this->index > rhs.index;
|
||||
return m_index > rhs.m_index;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -76,23 +76,23 @@ namespace ams::svc::codegen::impl {
|
|||
static constexpr size_t IdentifierLengthMax = 0x40;
|
||||
class Identifier {
|
||||
public:
|
||||
char name[IdentifierLengthMax];
|
||||
size_t index;
|
||||
char m_name[IdentifierLengthMax];
|
||||
size_t m_index;
|
||||
public:
|
||||
constexpr explicit Identifier() : name(), index() { /* ... */ }
|
||||
constexpr explicit Identifier(const char *nm, size_t idx = 0) : name(), index(idx) {
|
||||
constexpr explicit Identifier() : m_name(), m_index() { /* ... */ }
|
||||
constexpr explicit Identifier(const char *nm, size_t idx = 0) : m_name(), m_index(idx) {
|
||||
for (size_t i = 0; i < IdentifierLengthMax && nm[i]; i++) {
|
||||
this->name[i] = nm[i];
|
||||
m_name[i] = nm[i];
|
||||
}
|
||||
}
|
||||
|
||||
constexpr bool operator==(const Identifier &rhs) const {
|
||||
for (size_t i = 0; i < IdentifierLengthMax; i++) {
|
||||
if (this->name[i] != rhs.name[i]) {
|
||||
if (m_name[i] != rhs.m_name[i]) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return this->index == rhs.index;
|
||||
return m_index == rhs.m_index;
|
||||
}
|
||||
|
||||
constexpr bool operator!=(const Identifier &rhs) const {
|
||||
|
|
@ -100,68 +100,68 @@ namespace ams::svc::codegen::impl {
|
|||
}
|
||||
};
|
||||
public:
|
||||
Identifier identifier;
|
||||
ArgumentType type;
|
||||
size_t type_size;
|
||||
size_t passed_size;
|
||||
bool passed_by_pointer;
|
||||
bool is_boolean;
|
||||
size_t num_locations;
|
||||
Location locations[MaxLocations];
|
||||
Identifier m_identifier;
|
||||
ArgumentType m_type;
|
||||
size_t m_type_size;
|
||||
size_t m_passed_size;
|
||||
bool m_passed_by_pointer;
|
||||
bool m_is_boolean;
|
||||
size_t m_num_locations;
|
||||
Location m_locations[MaxLocations];
|
||||
public:
|
||||
constexpr explicit Parameter()
|
||||
: identifier(), type(ArgumentType::Invalid), type_size(0), passed_size(0), passed_by_pointer(0), is_boolean(0), num_locations(0), locations()
|
||||
: m_identifier(), m_type(ArgumentType::Invalid), m_type_size(0), m_passed_size(0), m_passed_by_pointer(0), m_is_boolean(0), m_num_locations(0), m_locations()
|
||||
{ /* ... */ }
|
||||
|
||||
constexpr explicit Parameter(Identifier id, ArgumentType t, size_t ts, size_t ps, bool p, bool b, Location l)
|
||||
: identifier(id), type(t), type_size(ts), passed_size(ps), passed_by_pointer(p), is_boolean(b), num_locations(1), locations()
|
||||
: m_identifier(id), m_type(t), m_type_size(ts), m_passed_size(ps), m_passed_by_pointer(p), m_is_boolean(b), m_num_locations(1), m_locations()
|
||||
{
|
||||
this->locations[0] = l;
|
||||
m_locations[0] = l;
|
||||
}
|
||||
|
||||
constexpr Identifier GetIdentifier() const {
|
||||
return this->identifier;
|
||||
return m_identifier;
|
||||
}
|
||||
|
||||
constexpr bool Is(Identifier rhs) const {
|
||||
return this->identifier == rhs;
|
||||
return m_identifier == rhs;
|
||||
}
|
||||
|
||||
constexpr ArgumentType GetArgumentType() const {
|
||||
return this->type;
|
||||
return m_type;
|
||||
}
|
||||
|
||||
constexpr size_t GetTypeSize() const {
|
||||
return this->type_size;
|
||||
return m_type_size;
|
||||
}
|
||||
|
||||
constexpr size_t GetPassedSize() const {
|
||||
return this->passed_size;
|
||||
return m_passed_size;
|
||||
}
|
||||
|
||||
constexpr bool IsPassedByPointer() const {
|
||||
return this->passed_by_pointer;
|
||||
return m_passed_by_pointer;
|
||||
}
|
||||
|
||||
constexpr bool IsBoolean() const {
|
||||
return this->is_boolean;
|
||||
return m_is_boolean;
|
||||
}
|
||||
|
||||
constexpr size_t GetNumLocations() const {
|
||||
return this->num_locations;
|
||||
return m_num_locations;
|
||||
}
|
||||
|
||||
constexpr Location GetLocation(size_t i) const {
|
||||
return this->locations[i];
|
||||
return m_locations[i];
|
||||
}
|
||||
|
||||
constexpr void AddLocation(Location l) {
|
||||
this->locations[this->num_locations++] = l;
|
||||
m_locations[m_num_locations++] = l;
|
||||
}
|
||||
|
||||
constexpr bool UsesLocation(Location l) const {
|
||||
for (size_t i = 0; i < this->num_locations; i++) {
|
||||
if (this->locations[i] == l) {
|
||||
for (size_t i = 0; i < m_num_locations; i++) {
|
||||
if (m_locations[i] == l) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
@ -169,19 +169,19 @@ namespace ams::svc::codegen::impl {
|
|||
}
|
||||
|
||||
constexpr bool operator==(const Parameter &rhs) const {
|
||||
if (!(this->identifier == rhs.identifier &&
|
||||
this->type == rhs.type &&
|
||||
this->type_size == rhs.type_size &&
|
||||
this->passed_size == rhs.passed_size &&
|
||||
this->passed_by_pointer == rhs.passed_by_pointer &&
|
||||
this->is_boolean == rhs.is_boolean &&
|
||||
this->num_locations == rhs.num_locations))
|
||||
if (!(m_identifier == rhs.m_identifier &&
|
||||
m_type == rhs.m_type &&
|
||||
m_type_size == rhs.m_type_size &&
|
||||
m_passed_size == rhs.m_passed_size &&
|
||||
m_passed_by_pointer == rhs.m_passed_by_pointer &&
|
||||
m_is_boolean == rhs.m_is_boolean &&
|
||||
m_num_locations == rhs.m_num_locations))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < this->num_locations; i++) {
|
||||
if (!(this->locations[i] == rhs.locations[i])) {
|
||||
for (size_t i = 0; i < m_num_locations; i++) {
|
||||
if (!(m_locations[i] == rhs.m_locations[i])) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue