mirrors/Atmosphere
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere.git synced 2025-06-02 23:59:49 -04:00
Code Issues Projects Releases Packages Wiki Activity

exo/vapours: refactor member variables to m_ over this->

Browse source
This commit is contained in:
Michael Scire 2021-10-09 15:40:06 -07:00
parent 5a38311ebf
commit 67a45c97ef
55 changed files with 846 additions and 847 deletions
Download patch file Download diff file Expand all files Collapse all files

32
exosphere/loader_stub/source/secmon_loader_uncompress.cpp
View file

@ -22,14 +22,14 @@ namespace ams::secmon::loader {
class Lz4Uncompressor {
private:
const u8 *src;
size_t src_size;
size_t src_offset;
u8 *dst;
size_t dst_size;
size_t dst_offset;
const u8 *m_src;
size_t m_src_size;
size_t m_src_offset;
u8 *m_dst;
size_t m_dst_size;
size_t m_dst_offset;
public:
Lz4Uncompressor(void *dst, size_t dst_size, const void *src, size_t src_size) : src(static_cast<const u8 *>(src)), src_size(src_size), src_offset(0), dst(static_cast<u8 *>(dst)), dst_size(dst_size), dst_offset(0) {
Lz4Uncompressor(void *dst, size_t dst_size, const void *src, size_t src_size) : m_src(static_cast<const u8 *>(src)), m_src_size(src_size), m_src_offset(0), m_dst(static_cast<u8 *>(dst)), m_dst_size(dst_size), m_dst_offset(0) {
/* ... */
}
@ -42,7 +42,7 @@ namespace ams::secmon::loader {
this->Copy(this->GetCopySize(control >> 4));
/* If we've exceeded size, we're done. */
if (this->src_offset >= this->src_size) {
if (m_src_offset >= m_src_size) {
break;
}
@ -55,21 +55,21 @@ namespace ams::secmon::loader {
const size_t wide_copy_size = this->GetCopySize(control & 0xF);
/* Copy bytes. */
const size_t end_offset = this->dst_offset + wide_copy_size + 4;
for (size_t cur_offset = this->dst_offset; cur_offset < end_offset; this->dst_offset = (++cur_offset)) {
const size_t end_offset = m_dst_offset + wide_copy_size + 4;
for (size_t cur_offset = m_dst_offset; cur_offset < end_offset; m_dst_offset = (++cur_offset)) {
AMS_ABORT_UNLESS(wide_offset <= cur_offset);
this->dst[cur_offset] = this->dst[cur_offset - wide_offset];
m_dst[cur_offset] = m_dst[cur_offset - wide_offset];
}
}
}
private:
u8 ReadByte() {
return this->src[this->src_offset++];
return m_src[m_src_offset++];
}
bool CanRead() const {
return this->src_offset < this->src_size;
return m_src_offset < m_src_size;
}
size_t GetCopySize(u8 control) {
@ -87,9 +87,9 @@ namespace ams::secmon::loader {
}
void Copy(size_t size) {
__builtin_memcpy(this->dst + this->dst_offset, this->src + this->src_offset, size);
this->dst_offset += size;
this->src_offset += size;
__builtin_memcpy(m_dst + m_dst_offset, m_src + m_src_offset, size);
m_dst_offset += size;
m_src_offset += size;
}
};

8
exosphere/mariko_fatal/source/fatal_device_page_table.cpp
View file

@ -76,10 +76,10 @@ namespace ams::secmon::fatal {
Bit_Readable = 31,
};
private:
u32 value;
u32 m_value;
protected:
constexpr ALWAYS_INLINE u32 SelectBit(Bit n) const {
return (this->value & (1u << n));
return (m_value & (1u << n));
}
constexpr ALWAYS_INLINE bool GetBit(Bit n) const {
@ -97,7 +97,7 @@ namespace ams::secmon::fatal {
ALWAYS_INLINE void SetValue(u32 v) {
/* Prevent re-ordering around entry modifications. */
__asm__ __volatile__("" ::: "memory");
this->value = v;
m_value = v;
__asm__ __volatile__("" ::: "memory");
}
public:
@ -112,7 +112,7 @@ namespace ams::secmon::fatal {
constexpr ALWAYS_INLINE u32 GetAttributes() const { return this->SelectBit(Bit_NonSecure) | this->SelectBit(Bit_Writeable) | this->SelectBit(Bit_Readable); }
constexpr ALWAYS_INLINE dd::PhysicalAddress GetPhysicalAddress() const { return (static_cast<u64>(this->value) << DevicePageBits) & PhysicalAddressMask; }
constexpr ALWAYS_INLINE dd::PhysicalAddress GetPhysicalAddress() const { return (static_cast<u64>(m_value) << DevicePageBits) & PhysicalAddressMask; }
ALWAYS_INLINE void Invalidate() { this->SetValue(0); }
};

10
exosphere/mariko_fatal/source/fs/fatal_fs_api.hpp
View file

@ -28,7 +28,7 @@ namespace ams::fs {
};
struct ReadOption {
u32 value;
u32 _value;
static const ReadOption None;
};
@ -36,7 +36,7 @@ namespace ams::fs {
inline constexpr const ReadOption ReadOption::None = {0};
inline constexpr bool operator==(const ReadOption &lhs, const ReadOption &rhs) {
return lhs.value == rhs.value;
return lhs._value == rhs._value;
}
inline constexpr bool operator!=(const ReadOption &lhs, const ReadOption &rhs) {
@ -46,10 +46,10 @@ namespace ams::fs {
static_assert(util::is_pod<ReadOption>::value && sizeof(ReadOption) == sizeof(u32));
struct WriteOption {
u32 value;
u32 _value;
constexpr inline bool HasFlushFlag() const {
return this->value & 1;
return _value & 1;
}
static const WriteOption None;
@ -60,7 +60,7 @@ namespace ams::fs {
inline constexpr const WriteOption WriteOption::Flush = {1};
inline constexpr bool operator==(const WriteOption &lhs, const WriteOption &rhs) {
return lhs.value == rhs.value;
return lhs._value == rhs._value;
}
inline constexpr bool operator!=(const WriteOption &lhs, const WriteOption &rhs) {

6
exosphere/program/source/secmon_page_mapper.cpp
View file

@ -23,16 +23,16 @@ namespace ams::secmon {
void *PageMapperImpl::GetPointerTo(uintptr_t phys, size_t size) const {
/* Ensure we stay within the page. */
if (util::AlignDown(phys, 4_KB) != this->physical_address) {
if (util::AlignDown(phys, 4_KB) != m_physical_address) {
return nullptr;
}
if (size != 0) {
if (util::AlignDown(phys + size - 1, 4_KB) != this->physical_address) {
if (util::AlignDown(phys + size - 1, 4_KB) != m_physical_address) {
return nullptr;
}
}
return reinterpret_cast<void *>(phys + (this->virtual_address - this->physical_address));
return reinterpret_cast<void *>(phys + (m_virtual_address - m_physical_address));
}
bool PageMapperImpl::CopyToMapping(uintptr_t dst_phys, const void *src, size_t size) const {

12
exosphere/program/source/secmon_page_mapper.hpp
View file

@ -22,10 +22,10 @@ namespace ams::secmon {
class PageMapperImpl {
private:
uintptr_t physical_address;
uintptr_t virtual_address;
uintptr_t m_physical_address;
uintptr_t m_virtual_address;
public:
constexpr PageMapperImpl(uintptr_t phys) : physical_address(util::AlignDown(phys, 4_KB)), virtual_address() { /* ... */ }
constexpr PageMapperImpl(uintptr_t phys) : m_physical_address(util::AlignDown(phys, 4_KB)), m_virtual_address() { /* ... */ }
void *GetPointerTo(uintptr_t phys, size_t size) const;
@ -37,14 +37,14 @@ namespace ams::secmon {
template<auto F>
bool MapImpl() {
this->virtual_address = F(this->physical_address);
return this->virtual_address != 0;
m_virtual_address = F(m_physical_address);
return m_virtual_address != 0;
}
template<auto F>
void UnmapImpl() {
F();
this->virtual_address = 0;
m_virtual_address = 0;
}
};

24
exosphere/program/source/smc/secmon_smc_rsa.cpp
View file

@ -55,31 +55,31 @@ namespace ams::secmon::smc {
class PrepareEsDeviceUniqueKeyAsyncArguments {
private:
int generation;
EsCommonKeyType type;
u8 label_digest[crypto::Sha256Generator::HashSize];
int m_generation;
EsCommonKeyType m_type;
u8 m_label_digest[crypto::Sha256Generator::HashSize];
public:
void Set(int gen, EsCommonKeyType t, const u8 ld[crypto::Sha256Generator::HashSize]) {
this->generation = gen;
this->type = t;
std::memcpy(this->label_digest, ld, sizeof(this->label_digest));
m_generation = gen;
m_type = t;
std::memcpy(m_label_digest, ld, sizeof(m_label_digest));
}
int GetKeyGeneration() const { return this->generation; }
EsCommonKeyType GetCommonKeyType() const { return this->type; }
void GetLabelDigest(u8 dst[crypto::Sha256Generator::HashSize]) const { std::memcpy(dst, this->label_digest, sizeof(this->label_digest)); }
int GetKeyGeneration() const { return m_generation; }
EsCommonKeyType GetCommonKeyType() const { return m_type; }
void GetLabelDigest(u8 dst[crypto::Sha256Generator::HashSize]) const { std::memcpy(dst, m_label_digest, sizeof(m_label_digest)); }
};
class ModularExponentiateByStorageKeyAsyncArguments {
private:
u8 msg[se::RsaSize];
u8 m_msg[se::RsaSize];
public:
void Set(const void *m, size_t m_size) {
AMS_UNUSED(m_size);
std::memcpy(this->msg, m, sizeof(this->msg));
std::memcpy(m_msg, m, sizeof(m_msg));
}
const u8 *GetMessage() const { return this->msg; }
const u8 *GetMessage() const { return m_msg; }
};
constinit SmcResult g_exp_mod_result = SmcResult::Success;