N-archive/citra
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

code: Use std::span where appropriate (#6658)

Browse source 
* code: Use std::span when possible

* code: Prefix memcpy and memcmp with std::
This commit is contained in:
GPUCode 2023-07-07 01:52:40 +03:00 committed by GitHub
parent 4ccd9f24fb
commit cf9bb90ae3
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
106 changed files with 362 additions and 329 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/android/app/src/main/jni/game_info.cpp
View file

@ -67,7 +67,7 @@ JNIEXPORT jlong JNICALL Java_org_citra_citra_1emu_model_GameInfo_initialize(JNIE
Loader::SMDH* smdh = nullptr;
if (Loader::IsValidSMDH(smdh_data)) {
smdh = new Loader::SMDH;
memcpy(smdh, smdh_data.data(), sizeof(Loader::SMDH));
std::memcpy(smdh, smdh_data.data(), sizeof(Loader::SMDH));
}
return reinterpret_cast<jlong>(smdh);
}

6
src/audio_core/dsp_interface.h
View file

@ -5,7 +5,7 @@
#pragma once
#include <memory>
#include <vector>
#include <span>
#include <boost/serialization/access.hpp>
#include "audio_core/audio_types.h"
#include "audio_core/time_stretch.h"
@ -80,7 +80,7 @@ public:
* @param pipe_number The Pipe ID
* @param buffer The data to write to the pipe.
*/
virtual void PipeWrite(DspPipe pipe_number, const std::vector<u8>& buffer) = 0;
virtual void PipeWrite(DspPipe pipe_number, std::span<const u8> buffer) = 0;
/// Returns a reference to the array backing DSP memory
virtual std::array<u8, Memory::DSP_RAM_SIZE>& GetDspMemory() = 0;
@ -89,7 +89,7 @@ public:
virtual void SetServiceToInterrupt(std::weak_ptr<Service::DSP::DSP_DSP> dsp) = 0;
/// Loads the DSP program
virtual void LoadComponent(const std::vector<u8>& buffer) = 0;
virtual void LoadComponent(std::span<const u8> buffer) = 0;
/// Unloads the DSP program
virtual void UnloadComponent() = 0;

8
src/audio_core/hle/hle.cpp
View file

@ -66,7 +66,7 @@ public:
bool RecvDataIsReady(u32 register_number) const;
std::vector<u8> PipeRead(DspPipe pipe_number, std::size_t length);
std::size_t GetPipeReadableSize(DspPipe pipe_number) const;
void PipeWrite(DspPipe pipe_number, const std::vector<u8>& buffer);
void PipeWrite(DspPipe pipe_number, std::span<const u8> buffer);
std::array<u8, Memory::DSP_RAM_SIZE>& GetDspMemory();
@ -244,7 +244,7 @@ size_t DspHle::Impl::GetPipeReadableSize(DspPipe pipe_number) const {
return pipe_data[pipe_index].size();
}
void DspHle::Impl::PipeWrite(DspPipe pipe_number, const std::vector<u8>& buffer) {
void DspHle::Impl::PipeWrite(DspPipe pipe_number, std::span<const u8> buffer) {
switch (pipe_number) {
case DspPipe::Audio: {
if (buffer.size() != 4) {
@ -494,7 +494,7 @@ size_t DspHle::GetPipeReadableSize(DspPipe pipe_number) const {
return impl->GetPipeReadableSize(pipe_number);
}
void DspHle::PipeWrite(DspPipe pipe_number, const std::vector<u8>& buffer) {
void DspHle::PipeWrite(DspPipe pipe_number, std::span<const u8> buffer) {
impl->PipeWrite(pipe_number, buffer);
}
@ -506,7 +506,7 @@ void DspHle::SetServiceToInterrupt(std::weak_ptr<DSP_DSP> dsp) {
impl->SetServiceToInterrupt(std::move(dsp));
}
void DspHle::LoadComponent(const std::vector<u8>& component_data) {
void DspHle::LoadComponent(std::span<const u8> component_data) {
// HLE doesn't need DSP program. Only log some info here
LOG_INFO(Service_DSP, "Firmware hash: {:#018x}",
Common::ComputeHash64(component_data.data(), component_data.size()));

4
src/audio_core/hle/hle.h
View file

@ -30,13 +30,13 @@ public:
void SetSemaphore(u16 semaphore_value) override;
std::vector<u8> PipeRead(DspPipe pipe_number, std::size_t length) override;
std::size_t GetPipeReadableSize(DspPipe pipe_number) const override;
void PipeWrite(DspPipe pipe_number, const std::vector<u8>& buffer) override;
void PipeWrite(DspPipe pipe_number, std::span<const u8> buffer) override;
std::array<u8, Memory::DSP_RAM_SIZE>& GetDspMemory() override;
void SetServiceToInterrupt(std::weak_ptr<Service::DSP::DSP_DSP> dsp) override;
void LoadComponent(const std::vector<u8>& buffer) override;
void LoadComponent(std::span<const u8> buffer) override;
void UnloadComponent() override;
private:

12
src/audio_core/lle/lle.cpp
View file

@ -26,7 +26,7 @@ enum class SegmentType : u8 {
class Dsp1 {
public:
explicit Dsp1(const std::vector<u8>& raw);
explicit Dsp1(std::span<const u8> raw);
struct Header {
std::array<u8, 0x100> signature;
@ -65,7 +65,7 @@ public:
bool recv_data_on_start;
};
Dsp1::Dsp1(const std::vector<u8>& raw) {
Dsp1::Dsp1(std::span<const u8> raw) {
Header header;
std::memcpy(&header, raw.data(), sizeof(header));
recv_data_on_start = header.recv_data_on_start != 0;
@ -220,7 +220,7 @@ struct DspLle::Impl final {
}
}
void WritePipe(u8 pipe_index, const std::vector<u8>& data) {
void WritePipe(u8 pipe_index, std::span<const u8> data) {
PipeStatus pipe_status = GetPipeStatus(pipe_index, PipeDirection::CPUtoDSP);
bool need_update = false;
const u8* buffer_ptr = data.data();
@ -304,7 +304,7 @@ struct DspLle::Impl final {
return size & PipeStatus::PtrMask;
}
void LoadComponent(const std::vector<u8>& buffer) {
void LoadComponent(std::span<const u8> buffer) {
if (loaded) {
LOG_ERROR(Audio_DSP, "Component already loaded!");
return;
@ -400,7 +400,7 @@ std::size_t DspLle::GetPipeReadableSize(DspPipe pipe_number) const {
return impl->GetPipeReadableSize(static_cast<u8>(pipe_number));
}
void DspLle::PipeWrite(DspPipe pipe_number, const std::vector<u8>& buffer) {
void DspLle::PipeWrite(DspPipe pipe_number, std::span<const u8> buffer) {
impl->WritePipe(static_cast<u8>(pipe_number), buffer);
}
@ -476,7 +476,7 @@ void DspLle::SetRecvDataHandler(u8 index, std::function<void()> handler) {
impl->teakra.SetRecvDataHandler(index, handler);
}
void DspLle::LoadComponent(const std::vector<u8>& buffer) {
void DspLle::LoadComponent(std::span<const u8> buffer) {
impl->LoadComponent(buffer);
}

5
src/audio_core/lle/lle.h
View file

@ -4,6 +4,7 @@
#pragma once
#include <span>
#include "audio_core/dsp_interface.h"
namespace Core {
@ -22,7 +23,7 @@ public:
void SetSemaphore(u16 semaphore_value) override;
std::vector<u8> PipeRead(DspPipe pipe_number, std::size_t length) override;
std::size_t GetPipeReadableSize(DspPipe pipe_number) const override;
void PipeWrite(DspPipe pipe_number, const std::vector<u8>& buffer) override;
void PipeWrite(DspPipe pipe_number, std::span<const u8> buffer) override;
std::array<u8, Memory::DSP_RAM_SIZE>& GetDspMemory() override;
@ -31,7 +32,7 @@ public:
void SetSemaphoreHandler(std::function<void()> handler);
void SetRecvDataHandler(u8 index, std::function<void()> handler);
void LoadComponent(const std::vector<u8>& buffer) override;
void LoadComponent(const std::span<const u8> buffer) override;
void UnloadComponent() override;
private:

2
src/citra_qt/configuration/configure_per_game.cpp
View file

@ -129,7 +129,7 @@ void ConfigurePerGame::HandleApplyButtonClicked() {
static QPixmap GetQPixmapFromSMDH(std::vector<u8>& smdh_data) {
Loader::SMDH smdh;
memcpy(&smdh, smdh_data.data(), sizeof(Loader::SMDH));
std::memcpy(&smdh, smdh_data.data(), sizeof(Loader::SMDH));
bool large = true;
std::vector<u16> icon_data = smdh.GetIcon(large);

2
src/citra_qt/debugger/graphics/graphics_vertex_shader.cpp
View file

@ -487,7 +487,7 @@ void GraphicsVertexShaderWidget::Reload(bool replace_vertex_data, void* vertex_d
if (replace_vertex_data) {
if (vertex_data) {
memcpy(&input_vertex, vertex_data, sizeof(input_vertex));
std::memcpy(&input_vertex, vertex_data, sizeof(input_vertex));
for (unsigned attr = 0; attr < 16; ++attr) {
for (unsigned comp = 0; comp < 4; ++comp) {
input_data[4 * attr + comp]->setText(

2
src/citra_qt/debugger/ipc/record_dialog.cpp
View file

@ -18,7 +18,7 @@ QString RecordDialog::FormatObject(const IPCDebugger::ObjectInfo& object) const
.arg(object.id, 8, 16, QLatin1Char('0'));
}
QString RecordDialog::FormatCmdbuf(const std::vector<u32>& cmdbuf) const {
QString RecordDialog::FormatCmdbuf(std::span<const u32> cmdbuf) const {
QString result;
for (std::size_t i = 0; i < cmdbuf.size(); ++i) {
result.append(

3
src/citra_qt/debugger/ipc/record_dialog.h
View file

@ -4,6 +4,7 @@
#include <array>
#include <memory>
#include <span>
#include <string>
#include <vector>
#include <QDialog>
@ -28,7 +29,7 @@ public:
private:
QString FormatObject(const IPCDebugger::ObjectInfo& object) const;
QString FormatCmdbuf(const std::vector<u32>& cmdbuf) const;
QString FormatCmdbuf(std::span<const u32> cmdbuf) const;
void UpdateCmdbufDisplay();
std::unique_ptr<Ui::RecordDialog> ui;

2
src/citra_qt/debugger/wait_tree.cpp
View file

@ -64,7 +64,7 @@ WaitTreeItem* WaitTreeItem::Parent() const {
return parent;
}
const std::vector<std::unique_ptr<WaitTreeItem>>& WaitTreeItem::Children() const {
std::span<const std::unique_ptr<WaitTreeItem>> WaitTreeItem::Children() const {
return children;
}

3
src/citra_qt/debugger/wait_tree.h
View file

@ -4,6 +4,7 @@
#pragma once
#include <span>
#include <QAbstractItemModel>
#include <QDockWidget>
#include <QTreeView>
@ -36,7 +37,7 @@ public:
void Expand();
WaitTreeItem* Parent() const;
const std::vector<std::unique_ptr<WaitTreeItem>>& Children() const;
std::span<const std::unique_ptr<WaitTreeItem>> Children() const;
std::size_t Row() const;
static std::vector<std::unique_ptr<WaitTreeThread>> MakeThreadItemList();

1
src/citra_qt/dumping/dumping_dialog.h
View file

@ -3,6 +3,7 @@
// Refer to the license.txt file included.
#include <memory>
#include <vector>
#include <QDialog>
#include "core/dumping/ffmpeg_backend.h"

10
src/citra_qt/game_list_p.h
View file

@ -6,8 +6,10 @@
#include <algorithm>
#include <map>
#include <span>
#include <unordered_map>
#include <utility>
#include <vector>
#include <QCoreApplication>
#include <QFileInfo>
#include <QImage>
@ -153,7 +155,7 @@ public:
static constexpr int LongTitleRole = SortRole + 5;
GameListItemPath() = default;
GameListItemPath(const QString& game_path, const std::vector<u8>& smdh_data, u64 program_id,
GameListItemPath(const QString& game_path, std::span<const u8> smdh_data, u64 program_id,
u64 extdata_id) {
setData(type(), TypeRole);
setData(game_path, FullPathRole);
@ -178,7 +180,7 @@ public:
}
Loader::SMDH smdh;
memcpy(&smdh, smdh_data.data(), sizeof(Loader::SMDH));
std::memcpy(&smdh, smdh_data.data(), sizeof(Loader::SMDH));
// Get icon from SMDH
if (UISettings::values.game_list_icon_size.GetValue() !=
@ -286,7 +288,7 @@ public:
class GameListItemRegion : public GameListItem {
public:
GameListItemRegion() = default;
explicit GameListItemRegion(const std::vector<u8>& smdh_data) {
explicit GameListItemRegion(std::span<const u8> smdh_data) {
setData(type(), TypeRole);
if (!Loader::IsValidSMDH(smdh_data)) {
@ -295,7 +297,7 @@ public:
}
Loader::SMDH smdh;
memcpy(&smdh, smdh_data.data(), sizeof(Loader::SMDH));
std::memcpy(&smdh, smdh_data.data(), sizeof(Loader::SMDH));
setText(GetRegionFromSMDH(smdh));
setData(GetRegionFromSMDH(smdh), SortRole);

2
src/citra_qt/loading_screen.cpp
View file

@ -80,7 +80,7 @@ const static std::unordered_map<VideoCore::LoadCallbackStage, const char*> progr
static QPixmap GetQPixmapFromSMDH(std::vector<u8>& smdh_data) {
Loader::SMDH smdh;
memcpy(&smdh, smdh_data.data(), sizeof(Loader::SMDH));
std::memcpy(&smdh, smdh_data.data(), sizeof(Loader::SMDH));
bool large = true;
std::vector<u16> icon_data = smdh.GetIcon(large);

2
src/common/file_util.cpp
View file

@ -855,7 +855,7 @@ const std::string& GetDefaultUserPath(UserPath path) {
return g_default_paths[path];
}
const void UpdateUserPath(UserPath path, const std::string& filename) {
void UpdateUserPath(UserPath path, const std::string& filename) {
if (filename.empty()) {
return;
}

2
src/common/file_util.h
View file

@ -191,7 +191,7 @@ void SetCurrentRomPath(const std::string& path);
[[nodiscard]] const std::string& GetDefaultUserPath(UserPath path);
// Update the Global Path with the new value
const void UpdateUserPath(UserPath path, const std::string& filename);
void UpdateUserPath(UserPath path, const std::string& filename);
// Returns the path to where the sys file are
[[nodiscard]] std::string GetSysDirectory();

2
src/common/linear_disk_cache.h
View file

@ -154,7 +154,7 @@ private:
struct Header {
Header() : id(*(u32*)"DCAC"), key_t_size(sizeof(K)), value_t_size(sizeof(V)) {
memcpy(ver, scm_rev_git_str, 40);
std::memcpy(ver, scm_rev_git_str, 40);
}
const u32 id;

3
src/common/ring_buffer.h
View file

@ -11,6 +11,7 @@
#include <cstring>
#include <limits>
#include <new>
#include <span>
#include <type_traits>
#include <vector>
#include "common/common_types.h"
@ -57,7 +58,7 @@ public:
return push_count;
}
std::size_t Push(const std::vector<T>& input) {
std::size_t Push(std::span<const T> input) {
return Push(input.data(), input.size() / granularity);
}

2
src/common/x64/cpu_detect.cpp
View file

@ -56,7 +56,7 @@ static CPUCaps Detect() {
// Citra at all anyway
int cpu_id[4];
memset(caps.brand_string, 0, sizeof(caps.brand_string));
std::memset(caps.brand_string, 0, sizeof(caps.brand_string));
// Detect CPU's CPUID capabilities and grab CPU string
__cpuid(cpu_id, 0x00000000);

15
src/common/zstd_compression.cpp
View file

@ -5,19 +5,18 @@
#include <algorithm>
#include <zstd.h>
#include "common/assert.h"
#include "common/zstd_compression.h"
namespace Common::Compression {
std::vector<u8> CompressDataZSTD(const u8* source, std::size_t source_size, s32 compression_level) {
std::vector<u8> CompressDataZSTD(std::span<const u8> source, s32 compression_level) {
compression_level = std::clamp(compression_level, ZSTD_minCLevel(), ZSTD_maxCLevel());
const std::size_t max_compressed_size = ZSTD_compressBound(source_size);
const std::size_t max_compressed_size = ZSTD_compressBound(source.size());
std::vector<u8> compressed(max_compressed_size);
const std::size_t compressed_size =
ZSTD_compress(compressed.data(), compressed.size(), source, source_size, compression_level);
const std::size_t compressed_size = ZSTD_compress(
compressed.data(), compressed.size(), source.data(), source.size(), compression_level);
if (ZSTD_isError(compressed_size)) {
// Compression failed
@ -29,11 +28,11 @@ std::vector<u8> CompressDataZSTD(const u8* source, std::size_t source_size, s32
return compressed;
}
std::vector<u8> CompressDataZSTDDefault(const u8* source, std::size_t source_size) {
return CompressDataZSTD(source, source_size, ZSTD_CLEVEL_DEFAULT);
std::vector<u8> CompressDataZSTDDefault(std::span<const u8> source) {
return CompressDataZSTD(source, ZSTD_CLEVEL_DEFAULT);
}
std::vector<u8> DecompressDataZSTD(const std::vector<u8>& compressed) {
std::vector<u8> DecompressDataZSTD(std::span<const u8> compressed) {
const std::size_t decompressed_size =
ZSTD_getFrameContentSize(compressed.data(), compressed.size());
std::vector<u8> decompressed(decompressed_size);

10
src/common/zstd_compression.h
View file

@ -4,6 +4,7 @@
#pragma once
#include <span>
#include <vector>
#include "common/common_types.h"
@ -14,24 +15,21 @@ namespace Common::Compression {
* Compresses a source memory region with Zstandard and returns the compressed data in a vector.
*
* @param source the uncompressed source memory region.
* @param source_size the size in bytes of the uncompressed source memory region.
* @param compression_level the used compression level. Should be between 1 and 22.
*
* @return the compressed data.
*/
[[nodiscard]] std::vector<u8> CompressDataZSTD(const u8* source, std::size_t source_size,
s32 compression_level);
[[nodiscard]] std::vector<u8> CompressDataZSTD(std::span<const u8> source, s32 compression_level);
/**
* Compresses a source memory region with Zstandard with the default compression level and returns
* the compressed data in a vector.
*
* @param source the uncompressed source memory region.
* @param source_size the size in bytes of the uncompressed source memory region.
*
* @return the compressed data.
*/
[[nodiscard]] std::vector<u8> CompressDataZSTDDefault(const u8* source, std::size_t source_size);
[[nodiscard]] std::vector<u8> CompressDataZSTDDefault(std::span<const u8> source);
/**
* Decompresses a source memory region with Zstandard and returns the uncompressed data in a vector.
@ -40,6 +38,6 @@ namespace Common::Compression {
*
* @return the decompressed data.
*/
[[nodiscard]] std::vector<u8> DecompressDataZSTD(const std::vector<u8>& compressed);
[[nodiscard]] std::vector<u8> DecompressDataZSTD(std::span<const u8> compressed);
} // namespace Common::Compression

3
src/core/cheats/gateway_cheat.cpp
View file

@ -6,6 +6,7 @@
#include <cmath>
#include <fstream>
#include <functional>
#include <span>
#include <string>
#include <vector>
#include <boost/iostreams/device/file_descriptor.hpp>
@ -144,7 +145,7 @@ static inline void JokerOp(const GatewayCheat::CheatLine& line, State& state,
}
static inline void PatchOp(const GatewayCheat::CheatLine& line, State& state, Core::System& system,
const std::vector<GatewayCheat::CheatLine>& cheat_lines) {
std::span<const GatewayCheat::CheatLine> cheat_lines) {
if (state.if_flag > 0) {
// Skip over the additional patch lines
state.current_line_nr += static_cast<int>(std::ceil(line.value / 8.0));

3
src/core/dumping/ffmpeg_backend.cpp
View file

@ -2,6 +2,7 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include <span>
#include <unordered_map>
#include "common/assert.h"
#include "common/file_util.h"
@ -892,7 +893,7 @@ std::string FormatDuration(s64 duration) {
}
std::string FormatDefaultValue(const AVOption* option,
const std::vector<OptionInfo::NamedConstant>& named_constants) {
std::span<const OptionInfo::NamedConstant> named_constants) {
// The following is taken and modified from libavutil code (opt.c)
switch (option->type) {
case AV_OPT_TYPE_BOOL: {

5
src/core/file_sys/archive_extsavedata.cpp
View file

@ -296,11 +296,10 @@ ResultVal<ArchiveFormatInfo> ArchiveFactory_ExtSaveData::GetFormatInfo(const Pat
return info;
}
void ArchiveFactory_ExtSaveData::WriteIcon(const Path& path, const u8* icon_data,
std::size_t icon_size) {
void ArchiveFactory_ExtSaveData::WriteIcon(const Path& path, std::span<const u8> icon) {
std::string game_path = FileSys::GetExtSaveDataPath(GetMountPoint(), path);
FileUtil::IOFile icon_file(game_path + "icon", "wb");
icon_file.WriteBytes(icon_data, icon_size);
icon_file.WriteBytes(icon.data(), icon.size());
}
} // namespace FileSys

3
src/core/file_sys/archive_extsavedata.h
View file

@ -5,6 +5,7 @@
#pragma once
#include <memory>
#include <span>
#include <string>
#include <boost/serialization/export.hpp>
#include <boost/serialization/string.hpp>
@ -38,7 +39,7 @@ public:
* @param icon_data Binary data of the icon
* @param icon_size Size of the icon data
*/
void WriteIcon(const Path& path, const u8* icon_data, std::size_t icon_size);
void WriteIcon(const Path& path, std::span<const u8> icon);
private:
bool shared; ///< Whether this archive represents an ExtSaveData archive or a SharedExtSaveData

2
src/core/file_sys/archive_ncch.cpp
View file

@ -249,7 +249,7 @@ ResultVal<std::size_t> NCCHFile::Read(const u64 offset, const std::size_t length
std::size_t available_size = static_cast<std::size_t>(file_buffer.size() - offset);
std::size_t copy_size = std::min(length, available_size);
memcpy(buffer, file_buffer.data() + offset, copy_size);
std::memcpy(buffer, file_buffer.data() + offset, copy_size);
return copy_size;
}

19
src/core/file_sys/cia_container.cpp
View file

@ -108,7 +108,7 @@ Loader::ResultStatus CIAContainer::Load(const std::string& filepath) {
return Loader::ResultStatus::Success;
}
Loader::ResultStatus CIAContainer::Load(const std::vector<u8>& file_data) {
Loader::ResultStatus CIAContainer::Load(std::span<const u8> file_data) {
Loader::ResultStatus result = LoadHeader(file_data);
if (result != Loader::ResultStatus::Success)
return result;
@ -133,30 +133,29 @@ Loader::ResultStatus CIAContainer::Load(const std::vector<u8>& file_data) {
return Loader::ResultStatus::Success;
}
Loader::ResultStatus CIAContainer::LoadHeader(const std::vector<u8>& header_data,
std::size_t offset) {
if (header_data.size() - offset < sizeof(Header))
Loader::ResultStatus CIAContainer::LoadHeader(std::span<const u8> header_data, std::size_t offset) {
if (header_data.size() - offset < sizeof(Header)) {
return Loader::ResultStatus::Error;
}
std::memcpy(&cia_header, header_data.data(), sizeof(Header));
return Loader::ResultStatus::Success;
}
Loader::ResultStatus CIAContainer::LoadTicket(const std::vector<u8>& ticket_data,
std::size_t offset) {
Loader::ResultStatus CIAContainer::LoadTicket(std::span<const u8> ticket_data, std::size_t offset) {
return cia_ticket.Load(ticket_data, offset);
}
Loader::ResultStatus CIAContainer::LoadTitleMetadata(const std::vector<u8>& tmd_data,
Loader::ResultStatus CIAContainer::LoadTitleMetadata(std::span<const u8> tmd_data,
std::size_t offset) {
return cia_tmd.Load(tmd_data, offset);
}
Loader::ResultStatus CIAContainer::LoadMetadata(const std::vector<u8>& meta_data,
std::size_t offset) {
if (meta_data.size() - offset < sizeof(Metadata))
Loader::ResultStatus CIAContainer::LoadMetadata(std::span<const u8> meta_data, std::size_t offset) {
if (meta_data.size() - offset < sizeof(Metadata)) {
return Loader::ResultStatus::Error;
}
std::memcpy(&cia_metadata, meta_data.data(), sizeof(Metadata));

12
src/core/file_sys/cia_container.h
View file

@ -6,8 +6,8 @@
#include <array>
#include <memory>
#include <span>
#include <string>
#include <vector>
#include "common/common_types.h"
#include "common/swap.h"
#include "core/file_sys/ticket.h"
@ -39,13 +39,13 @@ public:
// Load whole CIAs outright
Loader::ResultStatus Load(const FileBackend& backend);
Loader::ResultStatus Load(const std::string& filepath);
Loader::ResultStatus Load(const std::vector<u8>& header_data);
Loader::ResultStatus Load(std::span<const u8> header_data);
// Load parts of CIAs (for CIAs streamed in)
Loader::ResultStatus LoadHeader(const std::vector<u8>& header_data, std::size_t offset = 0);
Loader::ResultStatus LoadTicket(const std::vector<u8>& ticket_data, std::size_t offset = 0);
Loader::ResultStatus LoadTitleMetadata(const std::vector<u8>& tmd_data, std::size_t offset = 0);
Loader::ResultStatus LoadMetadata(const std::vector<u8>& meta_data, std::size_t offset = 0);
Loader::ResultStatus LoadHeader(std::span<const u8> header_data, std::size_t offset = 0);
Loader::ResultStatus LoadTicket(std::span<const u8> ticket_data, std::size_t offset = 0);
Loader::ResultStatus LoadTitleMetadata(std::span<const u8> tmd_data, std::size_t offset = 0);
Loader::ResultStatus LoadMetadata(std::span<const u8> meta_data, std::size_t offset = 0);
const Ticket& GetTicket() const;
const TitleMetadata& GetTitleMetadata() const;

42
src/core/file_sys/ncch_container.cpp
View file

@ -4,6 +4,7 @@
#include <cstring>
#include <memory>
#include <span>
#include <cryptopp/aes.h>
#include <cryptopp/modes.h>
#include <cryptopp/sha.h>
@ -36,10 +37,10 @@ u64 GetModId(u64 program_id) {
* @param size Size of compressed buffer
* @return Size of decompressed buffer
*/
static u32 LZSS_GetDecompressedSize(const u8* buffer, u32 size) {
static std::size_t LZSS_GetDecompressedSize(std::span<const u8> buffer) {
u32 offset_size;
std::memcpy(&offset_size, buffer + size - sizeof(u32), sizeof(u32));
return offset_size + size;
std::memcpy(&offset_size, buffer.data() + buffer.size() - sizeof(u32), sizeof(u32));
return offset_size + buffer.size();
}
/**
@ -50,19 +51,18 @@ static u32 LZSS_GetDecompressedSize(const u8* buffer, u32 size) {
* @param decompressed_size Size of decompressed buffer
* @return True on success, otherwise false
*/
static bool LZSS_Decompress(const u8* compressed, u32 compressed_size, u8* decompressed,
u32 decompressed_size) {
const u8* footer = compressed + compressed_size - 8;
static bool LZSS_Decompress(std::span<const u8> compressed, std::span<u8> decompressed) {
const u8* footer = compressed.data() + compressed.size() - 8;
u32 buffer_top_and_bottom;
std::memcpy(&buffer_top_and_bottom, footer, sizeof(u32));
u32 out = decompressed_size;
u32 index = compressed_size - ((buffer_top_and_bottom >> 24) & 0xFF);
u32 stop_index = compressed_size - (buffer_top_and_bottom & 0xFFFFFF);
size_t out = decompressed.size();
size_t index = compressed.size() - ((buffer_top_and_bottom >> 24) & 0xFF);
size_t stop_index = compressed.size() - (buffer_top_and_bottom & 0xFFFFFF);
memset(decompressed, 0, decompressed_size);
memcpy(decompressed, compressed, compressed_size);
std::memset(decompressed.data(), 0, decompressed.size());
std::memcpy(decompressed.data(), compressed.data(), compressed.size());
while (index > stop_index) {
u8 control = compressed[--index];
@ -92,7 +92,7 @@ static bool LZSS_Decompress(const u8* compressed, u32 compressed_size, u8* decom
for (unsigned j = 0; j < segment_size; j++) {
// Check if compression is out of bounds
if (out + segment_offset >= decompressed_size)
if (out + segment_offset >= decompressed.size())
return false;
u8 data = decompressed[out + segment_offset];
@ -538,14 +538,9 @@ Loader::ResultStatus NCCHContainer::LoadSectionExeFS(const char* name, std::vect
if (strcmp(section.name, ".code") == 0 && is_compressed) {
// Section is compressed, read compressed .code section...
std::unique_ptr<u8[]> temp_buffer;
try {
temp_buffer.reset(new u8[section.size]);
} catch (std::bad_alloc&) {
return Loader::ResultStatus::ErrorMemoryAllocationFailed;
}
if (exefs_file.ReadBytes(&temp_buffer[0], section.size) != section.size)
std::vector<u8> temp_buffer(section.size);
if (exefs_file.ReadBytes(temp_buffer.data(), temp_buffer.size()) !=
temp_buffer.size())
return Loader::ResultStatus::Error;
if (is_encrypted) {
@ -553,11 +548,10 @@ Loader::ResultStatus NCCHContainer::LoadSectionExeFS(const char* name, std::vect
}
// Decompress .code section...
u32 decompressed_size = LZSS_GetDecompressedSize(&temp_buffer[0], section.size);
buffer.resize(decompressed_size);
if (!LZSS_Decompress(&temp_buffer[0], section.size, buffer.data(),
decompressed_size))
buffer.resize(LZSS_GetDecompressedSize(temp_buffer));
if (!LZSS_Decompress(temp_buffer, buffer)) {
return Loader::ResultStatus::ErrorInvalidFormat;
}
} else {
// Section is uncompressed...
buffer.resize(section.size);

14
src/core/file_sys/plugin_3gx.cpp
View file

@ -142,8 +142,8 @@ Loader::ResultStatus FileSys::Plugin3GXLoader::Load(
}
exe_load_func.push_back(instruction);
}
memcpy(exe_load_args, header.infos.builtin_load_exe_args,
sizeof(_3gx_Infos::builtin_load_exe_args));
std::memcpy(exe_load_args, header.infos.builtin_load_exe_args,
sizeof(_3gx_Infos::builtin_load_exe_args));
}
// Load code sections
@ -245,8 +245,8 @@ Loader::ResultStatus FileSys::Plugin3GXLoader::Map(
plugin_header.plgldr_reply = plg_context.plg_reply;
plugin_header.is_default_plugin = plg_context.is_default_path;
if (plg_context.use_user_load_parameters) {
memcpy(plugin_header.config, plg_context.user_load_parameters.config,
sizeof(PluginHeader::config));
std::memcpy(plugin_header.config, plg_context.user_load_parameters.config,
sizeof(PluginHeader::config));
}
kernel.memory.WriteBlock(process, _3GX_exe_load_addr, &plugin_header, sizeof(PluginHeader));
@ -286,8 +286,7 @@ Loader::ResultStatus FileSys::Plugin3GXLoader::Map(
}
void FileSys::Plugin3GXLoader::MapBootloader(Kernel::Process& process, Kernel::KernelSystem& kernel,
u32 memory_offset,
const std::vector<u32>& exe_load_func,
u32 memory_offset, std::span<const u32> exe_load_func,
const u32_le* exe_load_args, u32 checksum_size,
u32 exe_checksum, bool no_flash) {
@ -296,7 +295,8 @@ void FileSys::Plugin3GXLoader::MapBootloader(Kernel::Process& process, Kernel::K
sizeof(u32) * 2);
std::array<u32_le, g_plugin_loader_bootloader.size() / sizeof(u32)> bootloader;
memcpy(bootloader.data(), g_plugin_loader_bootloader.data(), g_plugin_loader_bootloader.size());
std::memcpy(bootloader.data(), g_plugin_loader_bootloader.data(),
g_plugin_loader_bootloader.size());
for (auto it = bootloader.begin(); it < bootloader.end(); it++) {
switch (static_cast<u32>(*it)) {

5
src/core/file_sys/plugin_3gx.h
View file

@ -21,9 +21,10 @@
#pragma once
#include <core/file_sys/archive_backend.h>
#include <span>
#include "common/common_types.h"
#include "common/swap.h"
#include "core/file_sys/archive_backend.h"
#include "core/hle/kernel/process.h"
#include "core/hle/service/plgldr/plgldr.h"
@ -71,7 +72,7 @@ private:
static constexpr size_t bootloader_memory_size = 0x1000;
static void MapBootloader(Kernel::Process& process, Kernel::KernelSystem& kernel,
u32 memory_offset, const std::vector<u32>& exe_load_func,
u32 memory_offset, std::span<const u32> exe_load_func,
const u32_le* exe_load_args, u32 checksum_size, u32 exe_checksum,
bool no_flash);

6
src/core/file_sys/ticket.cpp
View file

@ -13,7 +13,7 @@
namespace FileSys {
Loader::ResultStatus Ticket::Load(const std::vector<u8> file_data, std::size_t offset) {
Loader::ResultStatus Ticket::Load(std::span<const u8> file_data, std::size_t offset) {
std::size_t total_size = static_cast<std::size_t>(file_data.size() - offset);
if (total_size < sizeof(u32))
return Loader::ResultStatus::Error;
@ -35,8 +35,8 @@ Loader::ResultStatus Ticket::Load(const std::vector<u8> file_data, std::size_t o
// Read signature + ticket body
ticket_signature.resize(signature_size);
memcpy(ticket_signature.data(), &file_data[offset + sizeof(u32)], signature_size);
memcpy(&ticket_body, &file_data[offset + body_start], sizeof(Body));
std::memcpy(ticket_signature.data(), &file_data[offset + sizeof(u32)], signature_size);
std::memcpy(&ticket_body, &file_data[offset + body_start], sizeof(Body));
return Loader::ResultStatus::Success;
}

3
src/core/file_sys/ticket.h
View file

@ -6,6 +6,7 @@
#include <array>
#include <optional>
#include <span>
#include <string>
#include <vector>
#include "common/common_funcs.h"
@ -47,7 +48,7 @@ public:
static_assert(sizeof(Body) == 0x210, "Ticket body structure size is wrong");
#pragma pack(pop)
Loader::ResultStatus Load(const std::vector<u8> file_data, std::size_t offset = 0);
Loader::ResultStatus Load(std::span<const u8> file_data, std::size_t offset = 0);
std::optional<std::array<u8, 16>> GetTitleKey() const;
private:

18
src/core/file_sys/title_metadata.cpp
View file

@ -29,12 +29,13 @@ Loader::ResultStatus TitleMetadata::Load(const std::string& file_path) {
return result;
}
Loader::ResultStatus TitleMetadata::Load(const std::vector<u8>& file_data, std::size_t offset) {
Loader::ResultStatus TitleMetadata::Load(std::span<const u8> file_data, std::size_t offset) {
std::size_t total_size = static_cast<std::size_t>(file_data.size() - offset);
if (total_size < sizeof(u32_be))
if (total_size < sizeof(u32_be)) {
return Loader::ResultStatus::Error;
}
memcpy(&signature_type, &file_data[offset], sizeof(u32_be));
std::memcpy(&signature_type, &file_data[offset], sizeof(u32_be));
// Signature lengths are variable, and the body follows the signature
u32 signature_size = GetSignatureSize(signature_type);
@ -46,13 +47,14 @@ Loader::ResultStatus TitleMetadata::Load(const std::vector<u8>& file_data, std::
std::size_t body_start = Common::AlignUp(signature_size + sizeof(u32), 0x40);
std::size_t body_end = body_start + sizeof(Body);
if (total_size < body_end)
if (total_size < body_end) {
return Loader::ResultStatus::Error;
}
// Read signature + TMD body, then load the amount of ContentChunks specified
tmd_signature.resize(signature_size);
memcpy(tmd_signature.data(), &file_data[offset + sizeof(u32_be)], signature_size);
memcpy(&tmd_body, &file_data[offset + body_start], sizeof(TitleMetadata::Body));
std::memcpy(tmd_signature.data(), &file_data[offset + sizeof(u32_be)], signature_size);
std::memcpy(&tmd_body, &file_data[offset + body_start], sizeof(TitleMetadata::Body));
std::size_t expected_size =
body_start + sizeof(Body) + static_cast<u16>(tmd_body.content_count) * sizeof(ContentChunk);
@ -65,8 +67,8 @@ Loader::ResultStatus TitleMetadata::Load(const std::vector<u8>& file_data, std::
for (u16 i = 0; i < tmd_body.content_count; i++) {
ContentChunk chunk;
memcpy(&chunk, &file_data[offset + body_end + (i * sizeof(ContentChunk))],
sizeof(ContentChunk));
std::memcpy(&chunk, &file_data[offset + body_end + (i * sizeof(ContentChunk))],
sizeof(ContentChunk));
tmd_chunks.push_back(chunk);
}

3
src/core/file_sys/title_metadata.h
View file

@ -5,6 +5,7 @@
#pragma once
#include <array>
#include <span>
#include <string>
#include <vector>
#include "common/common_types.h"
@ -82,7 +83,7 @@ public:
#pragma pack(pop)
Loader::ResultStatus Load(const std::string& file_path);
Loader::ResultStatus Load(const std::vector<u8>& file_data, std::size_t offset = 0);
Loader::ResultStatus Load(std::span<const u8> file_data, std::size_t offset = 0);
Loader::ResultStatus Save(const std::string& file_path);
u64 GetTitleID() const;

10
src/core/gdbstub/gdbstub.cpp
View file

@ -491,7 +491,7 @@ void SendReply(const char* reply) {
return;
}
memset(command_buffer, 0, sizeof(command_buffer));
std::memset(command_buffer, 0, sizeof(command_buffer));
command_length = static_cast<u32>(strlen(reply));
if (command_length + 4 > sizeof(command_buffer)) {
@ -499,7 +499,7 @@ void SendReply(const char* reply) {
return;
}
memcpy(command_buffer + 1, reply, command_length);
std::memcpy(command_buffer + 1, reply, command_length);
u8 checksum = CalculateChecksum(command_buffer, command_length + 1);
command_buffer[0] = GDB_STUB_START;
@ -639,7 +639,7 @@ static void SendSignal(Kernel::Thread* thread, u32 signal, bool full = true) {
/// Read command from gdb client.
static void ReadCommand() {
command_length = 0;
memset(command_buffer, 0, sizeof(command_buffer));
std::memset(command_buffer, 0, sizeof(command_buffer));
u8 c = ReadByte();
if (c == GDB_STUB_ACK) {
@ -711,7 +711,7 @@ static bool IsDataAvailable() {
/// Send requested register to gdb client.
static void ReadRegister() {
static u8 reply[64];
memset(reply, 0, sizeof(reply));
std::memset(reply, 0, sizeof(reply));
u32 id = HexCharToValue(command_buffer[1]);
if (command_buffer[2] != '\0') {
@ -737,7 +737,7 @@ static void ReadRegister() {
/// Send all registers to the gdb client.
static void ReadRegisters() {
static u8 buffer[GDB_BUFFER_SIZE - 4];
memset(buffer, 0, sizeof(buffer));
std::memset(buffer, 0, sizeof(buffer));
u8* bufptr = buffer;

1
src/core/gdbstub/gdbstub.h
View file

@ -6,6 +6,7 @@
#pragma once
#include <span>
#include "common/common_types.h"
#include "core/hle/kernel/thread.h"

2
src/core/gdbstub/hio.cpp
View file

@ -115,7 +115,7 @@ void HandleHioReply(const u8* const command_buffer, const u32 command_length) {
}
// Skip 'F' header
auto* command_pos = command_buffer + 1;
const u8* command_pos = command_buffer + 1;
if (*command_pos == 0 || *command_pos == ',') {
LOG_WARNING(Debug_GDBStub, "bad HIO packet format position 0: {}", *command_pos);

2
src/core/hle/applets/erreula.cpp
View file

@ -23,7 +23,7 @@ ResultCode ErrEula::ReceiveParameterImpl(const Service::APT::MessageParameter& p
Service::APT::CaptureBufferInfo capture_info;
ASSERT(sizeof(capture_info) == parameter.buffer.size());
memcpy(&capture_info, parameter.buffer.data(), sizeof(capture_info));
std::memcpy(&capture_info, parameter.buffer.data(), sizeof(capture_info));
// TODO: allocated memory never released
using Kernel::MemoryPermission;

4
src/core/hle/applets/mii_selector.cpp
View file

@ -31,7 +31,7 @@ ResultCode MiiSelector::ReceiveParameterImpl(const Service::APT::MessageParamete
Service::APT::CaptureBufferInfo capture_info;
ASSERT(sizeof(capture_info) == parameter.buffer.size());
memcpy(&capture_info, parameter.buffer.data(), sizeof(capture_info));
std::memcpy(&capture_info, parameter.buffer.data(), sizeof(capture_info));
using Kernel::MemoryPermission;
// Create a SharedMemory that directly points to this heap block.
@ -54,7 +54,7 @@ ResultCode MiiSelector::Start(const Service::APT::MessageParameter& parameter) {
ASSERT_MSG(parameter.buffer.size() == sizeof(config),
"The size of the parameter (MiiConfig) is wrong");
memcpy(&config, parameter.buffer.data(), parameter.buffer.size());
std::memcpy(&config, parameter.buffer.data(), parameter.buffer.size());
using namespace Frontend;
frontend_applet = Core::System::GetInstance().GetMiiSelector();

2
src/core/hle/applets/mint.cpp
View file

@ -23,7 +23,7 @@ ResultCode Mint::ReceiveParameterImpl(const Service::APT::MessageParameter& para
Service::APT::CaptureBufferInfo capture_info;
ASSERT(sizeof(capture_info) == parameter.buffer.size());
memcpy(&capture_info, parameter.buffer.data(), sizeof(capture_info));
std::memcpy(&capture_info, parameter.buffer.data(), sizeof(capture_info));
// TODO: allocated memory never released
using Kernel::MemoryPermission;

4
src/core/hle/applets/swkbd.cpp
View file

@ -93,7 +93,7 @@ ResultCode SoftwareKeyboard::Start(Service::APT::MessageParameter const& paramet
ASSERT_MSG(parameter.buffer.size() == sizeof(config),
"The size of the parameter (SoftwareKeyboardConfig) is wrong");
memcpy(&config, parameter.buffer.data(), parameter.buffer.size());
std::memcpy(&config, parameter.buffer.data(), parameter.buffer.size());
text_memory = std::static_pointer_cast<Kernel::SharedMemory, Kernel::Object>(parameter.object);
DrawScreenKeyboard();
@ -115,7 +115,7 @@ void SoftwareKeyboard::Update() {
const KeyboardData& data = frontend_applet->ReceiveData();
std::u16string text = Common::UTF8ToUTF16(data.text);
// Include a null terminator
memcpy(text_memory->GetPointer(), text.c_str(), (text.length() + 1) * sizeof(char16_t));
std::memcpy(text_memory->GetPointer(), text.c_str(), (text.length() + 1) * sizeof(char16_t));
switch (config.num_buttons_m1) {
case SoftwareKeyboardButtonConfig::SingleButton:
config.return_code = SoftwareKeyboardResult::D0Click;

2
src/core/hle/ipc_helpers.h
View file

@ -38,7 +38,7 @@ public:
void Skip(unsigned size_in_words, bool set_to_null) {
if (set_to_null)
memset(cmdbuf + index, 0, size_in_words * sizeof(u32));
std::memset(cmdbuf + index, 0, size_in_words * sizeof(u32));
index += size_in_words;
}
};

3
src/core/hle/kernel/kernel.h
View file

@ -8,6 +8,7 @@
#include <atomic>
#include <functional>
#include <memory>
#include <span>
#include <string>
#include <unordered_map>
#include <vector>
@ -230,7 +231,7 @@ public:
/// Retrieves a process from the current list of processes.
std::shared_ptr<Process> GetProcessById(u32 process_id) const;
const std::vector<std::shared_ptr<Process>>& GetProcessList() const {
std::span<const std::shared_ptr<Process>> GetProcessList() const {
return process_list;
}

12
src/core/hle/kernel/svc.cpp
View file

@ -543,13 +543,15 @@ void SVC::ExitProcess() {
current_process->status = ProcessStatus::Exited;
// Stop all the process threads that are currently waiting for objects.
auto& thread_list = kernel.GetCurrentThreadManager().GetThreadList();
const auto thread_list = kernel.GetCurrentThreadManager().GetThreadList();
for (auto& thread : thread_list) {
if (thread->owner_process.lock() != current_process)
if (thread->owner_process.lock() != current_process) {
continue;
}
if (thread.get() == kernel.GetCurrentThreadManager().GetCurrentThread())
if (thread.get() == kernel.GetCurrentThreadManager().GetCurrentThread()) {
continue;
}
// TODO(Subv): When are the other running/ready threads terminated?
ASSERT_MSG(thread->status == ThreadStatus::WaitSynchAny ||
@ -695,7 +697,7 @@ ResultCode SVC::OpenThread(Handle* out_handle, Handle process_handle, u32 thread
}
for (u32 core_id = 0; core_id < system.GetNumCores(); core_id++) {
auto& thread_list = kernel.GetThreadManager(core_id).GetThreadList();
const auto thread_list = kernel.GetThreadManager(core_id).GetThreadList();
for (auto& thread : thread_list) {
if (thread->owner_process.lock() == process && thread.get()->thread_id == thread_id) {
auto result_handle = kernel.GetCurrentProcess()->handle_table.Create(thread);
@ -2092,7 +2094,7 @@ ResultCode SVC::ControlProcess(Handle process_handle, u32 process_OP, u32 varg2,
}
case ControlProcessOP::PROCESSOP_SCHEDULE_THREADS_WITHOUT_TLS_MAGIC: {
for (u32 core_id = 0; core_id < system.GetNumCores(); core_id++) {
auto& thread_list = kernel.GetThreadManager(core_id).GetThreadList();
const auto thread_list = kernel.GetThreadManager(core_id).GetThreadList();
for (auto& thread : thread_list) {
if (thread->owner_process.lock() != process) {
continue;

4
src/core/hle/kernel/thread.cpp
View file

@ -304,7 +304,7 @@ void ThreadManager::DebugThreadQueue() {
* alloc_needed: Whether there's a need to allocate a new TLS page (All pages are full).
*/
static std::tuple<std::size_t, std::size_t, bool> GetFreeThreadLocalSlot(
const std::vector<std::bitset<8>>& tls_slots) {
std::span<const std::bitset<8>> tls_slots) {
// Iterate over all the allocated pages, and try to find one where not all slots are used.
for (std::size_t page = 0; page < tls_slots.size(); ++page) {
const auto& page_tls_slots = tls_slots[page];
@ -527,7 +527,7 @@ ThreadManager::~ThreadManager() {
}
}
const std::vector<std::shared_ptr<Thread>>& ThreadManager::GetThreadList() {
std::span<const std::shared_ptr<Thread>> ThreadManager::GetThreadList() {
return thread_list;
}

3
src/core/hle/kernel/thread.h
View file

@ -5,6 +5,7 @@
#pragma once
#include <memory>
#include <span>
#include <string>
#include <unordered_map>
#include <vector>
@ -113,7 +114,7 @@ public:
/**
* Get a const reference to the thread list for debug use
*/
const std::vector<std::shared_ptr<Thread>>& GetThreadList();
std::span<const std::shared_ptr<Thread>> GetThreadList();
void SetCPU(ARM_Interface& cpu_) {
cpu = &cpu_;

2
src/core/hle/lock.cpp
View file

@ -2,7 +2,7 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include <core/hle/lock.h>
#include "core/hle/lock.h"
namespace HLE {
std::recursive_mutex g_hle_lock;

6
src/core/hle/service/am/am.cpp
View file

@ -223,7 +223,7 @@ ResultVal<std::size_t> CIAFile::Write(u64 offset, std::size_t length, bool flush
std::size_t buf_max_size =
std::min(static_cast<std::size_t>(offset + length), FileSys::CIA_HEADER_SIZE);
data.resize(buf_max_size);
memcpy(data.data() + offset, buffer, buf_copy_size);
std::memcpy(data.data() + offset, buffer, buf_copy_size);
// We have enough data to load a CIA header and parse it.
if (written >= FileSys::CIA_HEADER_SIZE) {
@ -248,7 +248,7 @@ ResultVal<std::size_t> CIAFile::Write(u64 offset, std::size_t length, bool flush
buf_offset;
std::size_t buf_max_size = std::min(offset + length, container.GetContentOffset());
data.resize(buf_max_size);
memcpy(data.data() + copy_offset, buffer + buf_offset, buf_copy_size);
std::memcpy(data.data() + copy_offset, buffer + buf_offset, buf_copy_size);
}
// TODO(shinyquagsire23): Write out .tik files to nand?
@ -850,7 +850,7 @@ void Module::Interface::GetProgramList(Kernel::HLERequestContext& ctx) {
rb.PushMappedBuffer(title_ids_output);
}
ResultCode GetTitleInfoFromList(const std::vector<u64>& title_id_list,
ResultCode GetTitleInfoFromList(std::span<const u64> title_id_list,
Service::FS::MediaType media_type,
Kernel::MappedBuffer& title_info_out) {
std::size_t write_offset = 0;

2
src/core/hle/service/apt/apt.cpp
View file

@ -134,7 +134,7 @@ void Module::APTInterface::Initialize(Kernel::HLERequestContext& ctx) {
static u32 DecompressLZ11(const u8* in, u8* out) {
u32_le decompressed_size;
memcpy(&decompressed_size, in, sizeof(u32));
std::memcpy(&decompressed_size, in, sizeof(u32));
in += 4;
u8 type = decompressed_size & 0xFF;

40
src/core/hle/service/apt/bcfnt/bcfnt.cpp
View file

@ -12,7 +12,7 @@ void RelocateSharedFont(std::shared_ptr<Kernel::SharedMemory> shared_font, VAddr
const u8* cfnt_ptr = shared_font->GetPointer(SharedFontStartOffset);
CFNT cfnt;
memcpy(&cfnt, cfnt_ptr, sizeof(cfnt));
std::memcpy(&cfnt, cfnt_ptr, sizeof(cfnt));
u32 assumed_cmap_offset = 0;
u32 assumed_cwdh_offset = 0;
@ -27,17 +27,17 @@ void RelocateSharedFont(std::shared_ptr<Kernel::SharedMemory> shared_font, VAddr
const u8* data = shared_font->GetPointer(current_offset);
SectionHeader section_header;
memcpy(&section_header, data, sizeof(section_header));
std::memcpy(&section_header, data, sizeof(section_header));
if (first_cmap_offset == 0 && memcmp(section_header.magic, "CMAP", 4) == 0) {
if (first_cmap_offset == 0 && std::memcmp(section_header.magic, "CMAP", 4) == 0) {
first_cmap_offset = current_offset;
} else if (first_cwdh_offset == 0 && memcmp(section_header.magic, "CWDH", 4) == 0) {
} else if (first_cwdh_offset == 0 && std::memcmp(section_header.magic, "CWDH", 4) == 0) {
first_cwdh_offset = current_offset;
} else if (first_tglp_offset == 0 && memcmp(section_header.magic, "TGLP", 4) == 0) {
} else if (first_tglp_offset == 0 && std::memcmp(section_header.magic, "TGLP", 4) == 0) {
first_tglp_offset = current_offset;
} else if (memcmp(section_header.magic, "FINF", 4) == 0) {
} else if (std::memcmp(section_header.magic, "FINF", 4) == 0) {
BCFNT::FINF finf;
memcpy(&finf, data, sizeof(finf));
std::memcpy(&finf, data, sizeof(finf));
assumed_cmap_offset = finf.cmap_offset - sizeof(SectionHeader);
assumed_cwdh_offset = finf.cwdh_offset - sizeof(SectionHeader);
@ -59,44 +59,44 @@ void RelocateSharedFont(std::shared_ptr<Kernel::SharedMemory> shared_font, VAddr
u8* data = shared_font->GetPointer(current_offset);
SectionHeader section_header;
memcpy(&section_header, data, sizeof(section_header));
std::memcpy(&section_header, data, sizeof(section_header));
if (memcmp(section_header.magic, "FINF", 4) == 0) {
if (std::memcmp(section_header.magic, "FINF", 4) == 0) {
BCFNT::FINF finf;
memcpy(&finf, data, sizeof(finf));
std::memcpy(&finf, data, sizeof(finf));
// Relocate the offsets in the FINF section
finf.cmap_offset += offset;
finf.cwdh_offset += offset;
finf.tglp_offset += offset;
memcpy(data, &finf, sizeof(finf));
} else if (memcmp(section_header.magic, "CMAP", 4) == 0) {
std::memcpy(data, &finf, sizeof(finf));
} else if (std::memcmp(section_header.magic, "CMAP", 4) == 0) {
BCFNT::CMAP cmap;
memcpy(&cmap, data, sizeof(cmap));
std::memcpy(&cmap, data, sizeof(cmap));
// Relocate the offsets in the CMAP section
if (cmap.next_cmap_offset != 0)
cmap.next_cmap_offset += offset;
memcpy(data, &cmap, sizeof(cmap));
} else if (memcmp(section_header.magic, "CWDH", 4) == 0) {
std::memcpy(data, &cmap, sizeof(cmap));
} else if (std::memcmp(section_header.magic, "CWDH", 4) == 0) {
BCFNT::CWDH cwdh;
memcpy(&cwdh, data, sizeof(cwdh));
std::memcpy(&cwdh, data, sizeof(cwdh));
// Relocate the offsets in the CWDH section
if (cwdh.next_cwdh_offset != 0)
cwdh.next_cwdh_offset += offset;
memcpy(data, &cwdh, sizeof(cwdh));
} else if (memcmp(section_header.magic, "TGLP", 4) == 0) {
std::memcpy(data, &cwdh, sizeof(cwdh));
} else if (std::memcmp(section_header.magic, "TGLP", 4) == 0) {
BCFNT::TGLP tglp;
memcpy(&tglp, data, sizeof(tglp));
std::memcpy(&tglp, data, sizeof(tglp));
// Relocate the offsets in the TGLP section
tglp.sheet_data_offset += offset;
memcpy(data, &tglp, sizeof(tglp));
std::memcpy(data, &tglp, sizeof(tglp));
}
current_offset += section_header.section_size;

4
src/core/hle/service/cecd/cecd.cpp
View file

@ -834,7 +834,7 @@ void Module::Interface::OpenAndRead(Kernel::HLERequestContext& ctx) {
open_mode.check);
}
std::string Module::EncodeBase64(const std::vector<u8>& in) const {
std::string Module::EncodeBase64(std::span<const u8> in) const {
using namespace CryptoPP;
using Name::EncodingLookupArray;
using Name::InsertLineBreaks;
@ -855,7 +855,7 @@ std::string Module::EncodeBase64(const std::vector<u8>& in) const {
}
std::string Module::GetCecDataPathTypeAsString(const CecDataPathType type, const u32 program_id,
const std::vector<u8>& msg_id) const {
std::span<const u8> msg_id) const {
switch (type) {
case CecDataPathType::MboxList:
return "/CEC/MBoxList____";

8
src/core/hle/service/cecd/cecd.h
View file

@ -5,6 +5,7 @@
#pragma once
#include <memory>
#include <span>
#include "common/bit_field.h"
#include "common/common_funcs.h"
#include "core/hle/kernel/event.h"
@ -610,10 +611,11 @@ private:
0x26, 0x00, 0x01, 0x00};
/// Encoding function used for the message id
std::string EncodeBase64(const std::vector<u8>& in) const;
std::string EncodeBase64(std::span<const u8> in) const;
std::string GetCecDataPathTypeAsString(const CecDataPathType type, const u32 program_id,
const std::vector<u8>& msg_id = std::vector<u8>()) const;
std::string GetCecDataPathTypeAsString(
const CecDataPathType type, const u32 program_id,
std::span<const u8> msg_id = std::span<const u8>{}) const;
std::string GetCecCommandAsString(const CecCommand command) const;

21
src/core/hle/service/cfg/cfg.cpp
View file

@ -285,8 +285,8 @@ void Module::Interface::GenHashConsoleUnique(Kernel::HLERequestContext& ctx) {
std::array<u8, CryptoPP::SHA256::DIGESTSIZE> hash;
CryptoPP::SHA256().CalculateDigest(hash.data(), buffer.data(), sizeof(buffer));
u32 low, high;
memcpy(&low, &hash[hash.size() - 8], sizeof(u32));
memcpy(&high, &hash[hash.size() - 4], sizeof(u32));
std::memcpy(&low, &hash[hash.size() - 8], sizeof(u32));
std::memcpy(&high, &hash[hash.size() - 4], sizeof(u32));
rb.Push(low);
rb.Push(high);
} else {
@ -439,7 +439,7 @@ ResultVal<void*> Module::GetConfigInfoBlockPointer(u32 block_id, u32 size, u32 f
ResultCode Module::GetConfigInfoBlock(u32 block_id, u32 size, u32 flag, void* output) {
void* pointer = nullptr;
CASCADE_RESULT(pointer, GetConfigInfoBlockPointer(block_id, size, flag));
memcpy(output, pointer, size);
std::memcpy(output, pointer, size);
return RESULT_SUCCESS;
}
@ -447,7 +447,7 @@ ResultCode Module::GetConfigInfoBlock(u32 block_id, u32 size, u32 flag, void* ou
ResultCode Module::SetConfigInfoBlock(u32 block_id, u32 size, u32 flag, const void* input) {
void* pointer = nullptr;
CASCADE_RESULT(pointer, GetConfigInfoBlockPointer(block_id, size, flag));
memcpy(pointer, input, size);
std::memcpy(pointer, input, size);
return RESULT_SUCCESS;
}
@ -473,10 +473,10 @@ ResultCode Module::CreateConfigInfoBlk(u32 block_id, u16 size, u16 flags, const
config->block_entries[config->total_entries].offset_or_data = offset;
// Write the data at the new offset
memcpy(&cfg_config_file_buffer[offset], data, size);
std::memcpy(&cfg_config_file_buffer[offset], data, size);
} else {
// The offset_or_data field in the header contains the data itself if it's 4 bytes or less
memcpy(&config->block_entries[config->total_entries].offset_or_data, data, size);
std::memcpy(&config->block_entries[config->total_entries].offset_or_data, data, size);
}
++config->total_entries;
@ -721,7 +721,7 @@ Module::~Module() = default;
/// Checks if the language is available in the chosen region, and returns a proper one
static std::tuple<u32 /*region*/, SystemLanguage> AdjustLanguageInfoBlock(
const std::vector<u32>& region_code, SystemLanguage language) {
std::span<const u32> region_code, SystemLanguage language) {
static const std::array<std::vector<SystemLanguage>, 7> region_languages{{
// JPN
{LANGUAGE_JP},
@ -750,13 +750,14 @@ static std::tuple<u32 /*region*/, SystemLanguage> AdjustLanguageInfoBlock(
}
// The language is not available in any available region, so default to the first region and
// language
u32 default_region = region_code[0];
const u32 default_region = region_code[0];
return {default_region, region_languages[default_region][0]};
}
void Module::SetPreferredRegionCodes(const std::vector<u32>& region_codes) {
void Module::SetPreferredRegionCodes(std::span<const u32> region_codes) {
const SystemLanguage current_language = GetSystemLanguage();
auto [region, adjusted_language] = AdjustLanguageInfoBlock(region_codes, current_language);
const auto [region, adjusted_language] =
AdjustLanguageInfoBlock(region_codes, current_language);
preferred_region_code = region;
LOG_INFO(Service_CFG, "Preferred region code set to {}", preferred_region_code);

4
src/core/hle/service/cfg/cfg.h
View file

@ -6,9 +6,9 @@
#include <array>
#include <memory>
#include <span>
#include <string>
#include <utility>
#include <vector>
#include "common/common_types.h"
#include "core/hle/service/service.h"
@ -345,7 +345,7 @@ public:
* setting is auto.
* @param region_codes the preferred region codes to set
*/
void SetPreferredRegionCodes(const std::vector<u32>& region_codes);
void SetPreferredRegionCodes(std::span<const u32> region_codes);
// Utilities for frontend to set config data.
// Note: UpdateConfigNANDSavegame should be called after making changes to config data.

7
src/core/hle/service/fs/archive.cpp
View file

@ -230,7 +230,7 @@ ResultVal<FileSys::ArchiveFormatInfo> ArchiveManager::GetArchiveFormatInfo(
}
ResultCode ArchiveManager::CreateExtSaveData(MediaType media_type, u32 high, u32 low,
const std::vector<u8>& smdh_icon,
std::span<const u8> smdh_icon,
const FileSys::ArchiveFormatInfo& format_info,
u64 program_id) {
// Construct the binary path to the archive first
@ -247,10 +247,11 @@ ResultCode ArchiveManager::CreateExtSaveData(MediaType media_type, u32 high, u32
auto ext_savedata = static_cast<FileSys::ArchiveFactory_ExtSaveData*>(archive->second.get());
ResultCode result = ext_savedata->Format(path, format_info, program_id);
if (result.IsError())
if (result.IsError()) {
return result;
}
ext_savedata->WriteIcon(path, smdh_icon.data(), smdh_icon.size());
ext_savedata->WriteIcon(path, smdh_icon);
return RESULT_SUCCESS;
}

4
src/core/hle/service/fs/archive.h
View file

@ -5,9 +5,9 @@
#pragma once
#include <memory>
#include <span>
#include <string>
#include <unordered_map>
#include <vector>
#include <boost/serialization/unique_ptr.hpp>
#include <boost/serialization/unordered_map.hpp>
#include "common/common_types.h"
@ -219,7 +219,7 @@ public:
* @return ResultCode 0 on success or the corresponding code on error
*/
ResultCode CreateExtSaveData(MediaType media_type, u32 high, u32 low,
const std::vector<u8>& smdh_icon,
std::span<const u8> smdh_icon,
const FileSys::ArchiveFormatInfo& format_info, u64 program_id);
/**

7
src/core/hle/service/gsp/gsp_gpu.cpp
View file

@ -2,6 +2,7 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include <span>
#include <vector>
#include "common/archives.h"
#include "common/bit_field.h"
@ -142,7 +143,7 @@ static void WriteSingleHWReg(u32 base_address, u32 data) {
* @param data A vector containing the source data
* @return RESULT_SUCCESS if the parameters are valid, error code otherwise
*/
static ResultCode WriteHWRegs(u32 base_address, u32 size_in_bytes, const std::vector<u8>& data) {
static ResultCode WriteHWRegs(u32 base_address, u32 size_in_bytes, std::span<const u8> data) {
// This magic number is verified to be done by the gsp module
const u32 max_size_in_bytes = 0x80;
@ -185,8 +186,8 @@ static ResultCode WriteHWRegs(u32 base_address, u32 size_in_bytes, const std::ve
* @param masks A vector containing the masks
* @return RESULT_SUCCESS if the parameters are valid, error code otherwise
*/
static ResultCode WriteHWRegsWithMask(u32 base_address, u32 size_in_bytes,
const std::vector<u8>& data, const std::vector<u8>& masks) {
static ResultCode WriteHWRegsWithMask(u32 base_address, u32 size_in_bytes, std::span<const u8> data,
std::span<const u8> masks) {
// This magic number is verified to be done by the gsp module
const u32 max_size_in_bytes = 0x80;

6
src/core/hle/service/ir/extra_hid.cpp
View file

@ -164,7 +164,7 @@ void ExtraHID::OnDisconnect() {
timing.UnscheduleEvent(hid_polling_callback_id, 0);
}
void ExtraHID::HandleConfigureHIDPollingRequest(const std::vector<u8>& request) {
void ExtraHID::HandleConfigureHIDPollingRequest(std::span<const u8> request) {
if (request.size() != 3) {
LOG_ERROR(Service_IR, "Wrong request size ({}): {}", request.size(),
fmt::format("{:02x}", fmt::join(request, " ")));
@ -177,7 +177,7 @@ void ExtraHID::HandleConfigureHIDPollingRequest(const std::vector<u8>& request)
timing.ScheduleEvent(msToCycles(hid_period), hid_polling_callback_id);
}
void ExtraHID::HandleReadCalibrationDataRequest(const std::vector<u8>& request_buf) {
void ExtraHID::HandleReadCalibrationDataRequest(std::span<const u8> request_buf) {
struct ReadCalibrationDataRequest {
RequestID request_id;
u8 expected_response_time;
@ -213,7 +213,7 @@ void ExtraHID::HandleReadCalibrationDataRequest(const std::vector<u8>& request_b
Send(response);
}
void ExtraHID::OnReceive(const std::vector<u8>& data) {
void ExtraHID::OnReceive(std::span<const u8> data) {
switch (static_cast<RequestID>(data[0])) {
case RequestID::ConfigureHIDPolling:
HandleConfigureHIDPollingRequest(data);

7
src/core/hle/service/ir/extra_hid.h
View file

@ -6,6 +6,7 @@
#include <array>
#include <atomic>
#include <span>
#include <boost/serialization/array.hpp>
#include "common/bit_field.h"
#include "common/swap.h"
@ -47,15 +48,15 @@ public:
void OnConnect() override;
void OnDisconnect() override;
void OnReceive(const std::vector<u8>& data) override;
void OnReceive(std::span<const u8> data) override;
/// Requests input devices reload from current settings. Called when the input settings change.
void RequestInputDevicesReload();
private:
void SendHIDStatus();
void HandleConfigureHIDPollingRequest(const std::vector<u8>& request);
void HandleReadCalibrationDataRequest(const std::vector<u8>& request);
void HandleConfigureHIDPollingRequest(std::span<const u8> request);
void HandleReadCalibrationDataRequest(std::span<const u8> request);
void LoadInputDevices();
Core::Timing& timing;

20
src/core/hle/service/ir/ir_user.cpp
View file

@ -3,6 +3,7 @@
// Refer to the license.txt file included.
#include <memory>
#include <vector>
#include <boost/crc.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/shared_ptr.hpp>
@ -98,9 +99,10 @@ public:
* @params packet The data of the packet to put.
* @returns whether the operation is successful.
*/
bool Put(const std::vector<u8>& packet) {
if (info.packet_count == max_packet_count)
bool Put(std::span<const u8> packet) {
if (info.packet_count == max_packet_count) {
return false;
}
u32 write_offset;
@ -182,12 +184,12 @@ private:
}
void SetPacketInfo(u32 index, const PacketInfo& packet_info) {
memcpy(GetPacketInfoPointer(index), &packet_info, sizeof(PacketInfo));
std::memcpy(GetPacketInfoPointer(index), &packet_info, sizeof(PacketInfo));
}
PacketInfo GetPacketInfo(u32 index) {
PacketInfo packet_info;
memcpy(&packet_info, GetPacketInfoPointer(index), sizeof(PacketInfo));
std::memcpy(&packet_info, GetPacketInfoPointer(index), sizeof(PacketInfo));
return packet_info;
}
@ -198,7 +200,7 @@ private:
void UpdateBufferInfo() {
if (info_offset) {
memcpy(shared_memory->GetPointer(info_offset), &info, sizeof(info));
std::memcpy(shared_memory->GetPointer(info_offset), &info, sizeof(info));
}
}
@ -225,7 +227,7 @@ private:
};
/// Wraps the payload into packet and puts it to the receive buffer
void IR_USER::PutToReceive(const std::vector<u8>& payload) {
void IR_USER::PutToReceive(std::span<const u8> payload) {
LOG_TRACE(Service_IR, "called, data={}", fmt::format("{:02x}", fmt::join(payload, " ")));
std::size_t size = payload.size();
@ -464,8 +466,8 @@ IR_USER::IR_USER(Core::System& system) : ServiceFramework("ir:USER", 1) {
send_event = system.Kernel().CreateEvent(ResetType::OneShot, "IR:SendEvent");
receive_event = system.Kernel().CreateEvent(ResetType::OneShot, "IR:ReceiveEvent");
extra_hid = std::make_unique<ExtraHID>(
[this](const std::vector<u8>& data) { PutToReceive(data); }, system.CoreTiming());
extra_hid = std::make_unique<ExtraHID>([this](std::span<const u8> data) { PutToReceive(data); },
system.CoreTiming());
}
IR_USER::~IR_USER() {
@ -481,7 +483,7 @@ void IR_USER::ReloadInputDevices() {
IRDevice::IRDevice(SendFunc send_func_) : send_func(send_func_) {}
IRDevice::~IRDevice() = default;
void IRDevice::Send(const std::vector<u8>& data) {
void IRDevice::Send(std::span<const u8> data) {
send_func(data);
}

10
src/core/hle/service/ir/ir_user.h
View file

@ -6,7 +6,7 @@
#include <functional>
#include <memory>
#include <vector>
#include <span>
#include "core/hle/service/service.h"
namespace Kernel {
@ -26,7 +26,7 @@ public:
* A function object that implements the method to send data to the 3DS, which takes a vector of
* data to send.
*/
using SendFunc = std::function<void(const std::vector<u8>& data)>;
using SendFunc = std::function<void(std::span<const u8> data)>;
explicit IRDevice(SendFunc send_func);
virtual ~IRDevice();
@ -38,11 +38,11 @@ public:
virtual void OnDisconnect() = 0;
/// Called when data is received from the 3DS. This is invoked by the ir:USER send function.
virtual void OnReceive(const std::vector<u8>& data) = 0;
virtual void OnReceive(std::span<const u8> data) = 0;
protected:
/// Sends data to the 3DS. The actual sending method is specified in the constructor
void Send(const std::vector<u8>& data);
void Send(std::span<const u8> data);
private:
// NOTE: This value is *not* serialized because it's always passed in the constructor
@ -161,7 +161,7 @@ private:
*/
void ReleaseReceivedData(Kernel::HLERequestContext& ctx);
void PutToReceive(const std::vector<u8>& payload);
void PutToReceive(std::span<const u8> payload);
std::shared_ptr<Kernel::Event> conn_status_event, send_event, receive_event;
std::shared_ptr<Kernel::SharedMemory> shared_memory;

3
src/core/hle/service/mic_u.cpp
View file

@ -2,6 +2,7 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include <span>
#include <boost/serialization/weak_ptr.hpp>
#include "audio_core/input.h"
#include "audio_core/input_details.h"
@ -77,7 +78,7 @@ struct State {
u8 sample_size = 0;
SampleRate sample_rate = SampleRate::Rate16360;
void WriteSamples(const std::vector<u8>& samples) {
void WriteSamples(std::span<const u8> samples) {
u32 bytes_total_written = 0;
const std::size_t remaining_space = size - offset;
std::size_t bytes_to_write = std::min(samples.size(), remaining_space);

24
src/core/hle/service/nwm/nwm_uds.cpp
View file

@ -843,14 +843,14 @@ void NWM_UDS::Unbind(Kernel::HLERequestContext& ctx) {
rb.Push<u32>(0);
}
ResultCode NWM_UDS::BeginHostingNetwork(const u8* network_info_buffer,
std::size_t network_info_size, std::vector<u8> passphrase) {
ResultCode NWM_UDS::BeginHostingNetwork(std::span<const u8> network_info_buffer,
std::vector<u8> passphrase) {
// TODO(Subv): Store the passphrase and verify it when attempting a connection.
{
std::lock_guard lock(connection_status_mutex);
network_info = {};
std::memcpy(&network_info, network_info_buffer, network_info_size);
std::memcpy(&network_info, network_info_buffer.data(), network_info_buffer.size());
// The real UDS module throws a fatal error if this assert fails.
ASSERT_MSG(network_info.max_nodes > 1, "Trying to host a network of only one member.");
@ -921,8 +921,7 @@ void NWM_UDS::BeginHostingNetwork(Kernel::HLERequestContext& ctx) {
ASSERT(passphrase.size() == passphrase_size);
LOG_DEBUG(Service_NWM, "called");
auto result = BeginHostingNetwork(network_info_buffer.data(), network_info_buffer.size(),
std::move(passphrase));
auto result = BeginHostingNetwork(network_info_buffer, std::move(passphrase));
LOG_DEBUG(Service_NWM, "An UDS network has been created.");
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
@ -940,8 +939,7 @@ void NWM_UDS::BeginHostingNetworkDeprecated(Kernel::HLERequestContext& ctx) {
ASSERT(passphrase.size() == passphrase_size);
LOG_DEBUG(Service_NWM, "called");
auto result = BeginHostingNetwork(network_info_buffer.data(), network_info_buffer.size(),
std::move(passphrase));
auto result = BeginHostingNetwork(network_info_buffer, std::move(passphrase));
LOG_DEBUG(Service_NWM, "An UDS network has been created.");
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
@ -1277,10 +1275,10 @@ private:
};
void NWM_UDS::ConnectToNetwork(Kernel::HLERequestContext& ctx, u16 command_id,
const u8* network_info_buffer, std::size_t network_info_size,
u8 connection_type, std::vector<u8> passphrase) {
std::span<const u8> network_info_buffer, u8 connection_type,
std::vector<u8> passphrase) {
network_info = {};
std::memcpy(&network_info, network_info_buffer, network_info_size);
std::memcpy(&network_info, network_info_buffer.data(), network_info_buffer.size());
// Start the connection sequence
StartConnectionSequence(network_info.host_mac_address);
@ -1304,8 +1302,7 @@ void NWM_UDS::ConnectToNetwork(Kernel::HLERequestContext& ctx) {
std::vector<u8> passphrase = rp.PopStaticBuffer();
ConnectToNetwork(ctx, 0x1E, network_info_buffer.data(), network_info_buffer.size(),
connection_type, std::move(passphrase));
ConnectToNetwork(ctx, 0x1E, network_info_buffer, connection_type, std::move(passphrase));
LOG_DEBUG(Service_NWM, "called");
}
@ -1322,8 +1319,7 @@ void NWM_UDS::ConnectToNetworkDeprecated(Kernel::HLERequestContext& ctx) {
std::vector<u8> passphrase = rp.PopStaticBuffer();
ConnectToNetwork(ctx, 0x09, network_info_buffer.data(), network_info_buffer.size(),
connection_type, std::move(passphrase));
ConnectToNetwork(ctx, 0x09, network_info_buffer, connection_type, std::move(passphrase));
LOG_DEBUG(Service_NWM, "called");
}

6
src/core/hle/service/nwm/nwm_uds.h
View file

@ -452,12 +452,12 @@ private:
u32 sharedmem_size, const NodeInfo& node, u16 version,
std::shared_ptr<Kernel::SharedMemory> sharedmem);
ResultCode BeginHostingNetwork(const u8* network_info_buffer, std::size_t network_info_size,
ResultCode BeginHostingNetwork(std::span<const u8> network_info_buffer,
std::vector<u8> passphrase);
void ConnectToNetwork(Kernel::HLERequestContext& ctx, u16 command_id,
const u8* network_info_buffer, std::size_t network_info_size,
u8 connection_type, std::vector<u8> passphrase);
std::span<const u8> network_info_buffer, u8 connection_type,
std::vector<u8> passphrase);
void BeaconBroadcastCallback(std::uintptr_t user_data, s64 cycles_late);

6
src/core/hle/service/nwm/uds_connection.cpp
View file

@ -22,7 +22,7 @@ std::vector<u8> GenerateAuthenticationFrame(AuthenticationSeq seq) {
return data;
}
AuthenticationSeq GetAuthenticationSeqNumber(const std::vector<u8>& body) {
AuthenticationSeq GetAuthenticationSeqNumber(std::span<const u8> body) {
AuthenticationFrame frame;
std::memcpy(&frame, body.data(), sizeof(frame));
@ -74,9 +74,9 @@ std::vector<u8> GenerateAssocResponseFrame(AssocStatus status, u16 association_i
return data;
}
std::tuple<AssocStatus, u16> GetAssociationResult(const std::vector<u8>& body) {
std::tuple<AssocStatus, u16> GetAssociationResult(std::span<const u8> body) {
AssociationResponseFrame frame;
memcpy(&frame, body.data(), sizeof(frame));
std::memcpy(&frame, body.data(), sizeof(frame));
constexpr u16 AssociationIdMask = 0x3FFF;
return std::make_tuple(frame.status_code, frame.assoc_id & AssociationIdMask);

5
src/core/hle/service/nwm/uds_connection.h
View file

@ -4,6 +4,7 @@
#pragma once
#include <span>
#include <tuple>
#include <vector>
#include "common/common_types.h"
@ -41,7 +42,7 @@ static_assert(sizeof(AssociationResponseFrame) == 6, "AssociationResponseFrame h
std::vector<u8> GenerateAuthenticationFrame(AuthenticationSeq seq);
/// Returns the sequence number from the body of an Authentication frame.
AuthenticationSeq GetAuthenticationSeqNumber(const std::vector<u8>& body);
AuthenticationSeq GetAuthenticationSeqNumber(std::span<const u8> body);
/// Generates an 802.11 association response frame with the specified status, association id and
/// network id, starting at the frame body.
@ -49,6 +50,6 @@ std::vector<u8> GenerateAssocResponseFrame(AssocStatus status, u16 association_i
/// Returns a tuple of (association status, association id) from the body of an AssociationResponse
/// frame.
std::tuple<AssocStatus, u16> GetAssociationResult(const std::vector<u8>& body);
std::tuple<AssocStatus, u16> GetAssociationResult(std::span<const u8> body);
} // namespace Service::NWM

26
src/core/hle/service/nwm/uds_data.cpp
View file

@ -28,7 +28,7 @@ static std::vector<u8> GenerateLLCHeader(EtherType protocol) {
header.protocol = protocol;
std::vector<u8> buffer(sizeof(header));
memcpy(buffer.data(), &header, sizeof(header));
std::memcpy(buffer.data(), &header, sizeof(header));
return buffer;
}
@ -53,7 +53,7 @@ static std::vector<u8> GenerateSecureDataHeader(u16 data_size, u8 channel, u16 d
header.src_node_id = src_node_id;
std::vector<u8> buffer(sizeof(header));
memcpy(buffer.data(), &header, sizeof(header));
std::memcpy(buffer.data(), &header, sizeof(header));
return buffer;
}
@ -83,7 +83,7 @@ static std::array<u8, CryptoPP::Weak::MD5::DIGESTSIZE> GetDataCryptoCTR(
* @returns The key used for data frames crypto.
*/
[[maybe_unused]] static std::array<u8, CryptoPP::AES::BLOCKSIZE> GenerateDataCCMPKey(
const std::vector<u8>& passphrase, const NetworkInfo& network_info) {
std::span<const u8> passphrase, const NetworkInfo& network_info) {
// Calculate the MD5 hash of the input passphrase.
std::array<u8, CryptoPP::Weak::MD5::DIGESTSIZE> passphrase_hash;
CryptoPP::Weak::MD5().CalculateDigest(passphrase_hash.data(), passphrase.data(),
@ -158,9 +158,9 @@ static std::vector<u8> GenerateCCMPAAD(const MacAddress& sender, const MacAddres
* @returns The decrypted payload.
*/
[[maybe_unused]] static std::vector<u8> DecryptDataFrame(
const std::vector<u8>& encrypted_payload,
const std::array<u8, CryptoPP::AES::BLOCKSIZE>& ccmp_key, const MacAddress& sender,
const MacAddress& receiver, const MacAddress& bssid, u16 sequence_number, u16 frame_control) {
std::span<const u8> encrypted_payload, const std::array<u8, CryptoPP::AES::BLOCKSIZE>& ccmp_key,
const MacAddress& sender, const MacAddress& receiver, const MacAddress& bssid,
u16 sequence_number, u16 frame_control) {
// Reference: IEEE 802.11-2007
@ -218,7 +218,7 @@ static std::vector<u8> GenerateCCMPAAD(const MacAddress& sender, const MacAddres
* @returns The encrypted payload.
*/
[[maybe_unused]] static std::vector<u8> EncryptDataFrame(
const std::vector<u8>& payload, const std::array<u8, CryptoPP::AES::BLOCKSIZE>& ccmp_key,
std::span<const u8> payload, const std::array<u8, CryptoPP::AES::BLOCKSIZE>& ccmp_key,
const MacAddress& sender, const MacAddress& receiver, const MacAddress& bssid,
u16 sequence_number, u16 frame_control) {
// Reference: IEEE 802.11-2007
@ -266,7 +266,7 @@ static std::vector<u8> GenerateCCMPAAD(const MacAddress& sender, const MacAddres
return {};
}
std::vector<u8> GenerateDataPayload(const std::vector<u8>& data, u8 channel, u16 dest_node,
std::vector<u8> GenerateDataPayload(std::span<const u8> data, u8 channel, u16 dest_node,
u16 src_node, u16 sequence_number) {
std::vector<u8> buffer = GenerateLLCHeader(EtherType::SecureData);
std::vector<u8> securedata_header = GenerateSecureDataHeader(
@ -277,7 +277,7 @@ std::vector<u8> GenerateDataPayload(const std::vector<u8>& data, u8 channel, u16
return buffer;
}
SecureDataHeader ParseSecureDataHeader(const std::vector<u8>& data) {
SecureDataHeader ParseSecureDataHeader(std::span<const u8> data) {
SecureDataHeader header;
// Skip the LLC header
@ -308,20 +308,20 @@ std::vector<u8> GenerateEAPoLStartFrame(u16 association_id, const NodeInfo& node
return buffer;
}
EtherType GetFrameEtherType(const std::vector<u8>& frame) {
EtherType GetFrameEtherType(std::span<const u8> frame) {
LLCHeader header;
std::memcpy(&header, frame.data(), sizeof(header));
return header.protocol;
}
u16 GetEAPoLFrameType(const std::vector<u8>& frame) {
u16 GetEAPoLFrameType(std::span<const u8> frame) {
// Ignore the LLC header
u16_be eapol_type;
std::memcpy(&eapol_type, frame.data() + sizeof(LLCHeader), sizeof(eapol_type));
return eapol_type;
}
NodeInfo DeserializeNodeInfoFromFrame(const std::vector<u8>& frame) {
NodeInfo DeserializeNodeInfoFromFrame(std::span<const u8> frame) {
EAPoLStartPacket eapol_start;
// Skip the LLC header
@ -372,7 +372,7 @@ std::vector<u8> GenerateEAPoLLogoffFrame(const MacAddress& mac_address, u16 netw
return buffer;
}
EAPoLLogoffPacket ParseEAPoLLogoffFrame(const std::vector<u8>& frame) {
EAPoLLogoffPacket ParseEAPoLLogoffFrame(std::span<const u8> frame) {
EAPoLLogoffPacket eapol_logoff;
// Skip the LLC header

13
src/core/hle/service/nwm/uds_data.h
View file

@ -5,6 +5,7 @@
#pragma once
#include <array>
#include <span>
#include <vector>
#include "common/common_types.h"
#include "common/swap.h"
@ -118,13 +119,13 @@ static_assert(sizeof(EAPoLLogoffPacket) == 0x298, "EAPoLLogoffPacket has the wro
* Generates an unencrypted 802.11 data payload.
* @returns The generated frame payload.
*/
std::vector<u8> GenerateDataPayload(const std::vector<u8>& data, u8 channel, u16 dest_node,
std::vector<u8> GenerateDataPayload(std::span<const u8> data, u8 channel, u16 dest_node,
u16 src_node, u16 sequence_number);
/*
* Returns the SecureDataHeader stored in an 802.11 data frame.
*/
SecureDataHeader ParseSecureDataHeader(const std::vector<u8>& data);
SecureDataHeader ParseSecureDataHeader(std::span<const u8> data);
/*
* Generates an unencrypted 802.11 data frame body with the EAPoL-Start format for UDS
@ -136,19 +137,19 @@ std::vector<u8> GenerateEAPoLStartFrame(u16 association_id, const NodeInfo& node
/*
* Returns the EtherType of the specified 802.11 frame.
*/
EtherType GetFrameEtherType(const std::vector<u8>& frame);
EtherType GetFrameEtherType(std::span<const u8> frame);
/*
* Returns the EAPoL type (Start / Logoff) of the specified 802.11 frame.
* Note: The frame *must* be an EAPoL frame.
*/
u16 GetEAPoLFrameType(const std::vector<u8>& frame);
u16 GetEAPoLFrameType(std::span<const u8> frame);
/*
* Returns a deserialized NodeInfo structure from the information inside an EAPoL-Start packet
* encapsulated in an 802.11 data frame.
*/
NodeInfo DeserializeNodeInfoFromFrame(const std::vector<u8>& frame);
NodeInfo DeserializeNodeInfoFromFrame(std::span<const u8> frame);
/*
* Returns a NodeInfo constructed from the data in the specified EAPoLNodeInfo.
@ -166,6 +167,6 @@ std::vector<u8> GenerateEAPoLLogoffFrame(const MacAddress& mac_address, u16 netw
/*
* Returns a EAPoLLogoffPacket representing the specified 802.11-encapsulated data frame.
*/
EAPoLLogoffPacket ParseEAPoLLogoffFrame(const std::vector<u8>& frame);
EAPoLLogoffPacket ParseEAPoLLogoffFrame(std::span<const u8> frame);
} // namespace Service::NWM

16
src/core/hle/service/soc_u.cpp
View file

@ -312,7 +312,7 @@ static void TranslateSockOptDataToPlatform(std::vector<u8>& out, const std::vect
linger_out.l_linger = static_cast<decltype(linger_out.l_linger)>(
reinterpret_cast<const CTRLinger*>(in.data())->l_linger);
out.resize(sizeof(linger));
memcpy(out.data(), &linger_out, sizeof(linger));
std::memcpy(out.data(), &linger_out, sizeof(linger));
return;
}
// Other options should have the size of an int, even for booleans
@ -332,7 +332,7 @@ static void TranslateSockOptDataToPlatform(std::vector<u8>& out, const std::vect
return;
}
out.resize(sizeof(int));
memcpy(out.data(), &value, sizeof(int));
std::memcpy(out.data(), &value, sizeof(int));
}
static u32 TranslateSockOptSizeToPlatform(int platform_level, int platform_opt) {
@ -349,7 +349,7 @@ static void TranslateSockOptDataFromPlatform(std::vector<u8>& out, const std::ve
reinterpret_cast<const linger*>(in.data())->l_onoff);
linger_out.l_linger = static_cast<decltype(linger_out.l_linger)>(
reinterpret_cast<const linger*>(in.data())->l_linger);
memcpy(out.data(), &linger_out, std::min(out.size(), sizeof(CTRLinger)));
std::memcpy(out.data(), &linger_out, std::min(out.size(), sizeof(CTRLinger)));
return;
}
if (out.size() == sizeof(u8) && in.size() == sizeof(int)) {
@ -569,7 +569,7 @@ union CTRSockAddr {
ASSERT_MSG(ctr_addr.raw.len == sizeof(CTRSockAddrIn),
"Unhandled address size (len) in CTRSockAddr::ToPlatform");
result.sa_family = SocketDomainToPlatform(ctr_addr.raw.sa_family);
memset(result.sa_data, 0, sizeof(result.sa_data));
std::memset(result.sa_data, 0, sizeof(result.sa_data));
// We can not guarantee ABI compatibility between platforms so we copy the fields manually
switch (result.sa_family) {
@ -577,7 +577,7 @@ union CTRSockAddr {
sockaddr_in* result_in = reinterpret_cast<sockaddr_in*>(&result);
result_in->sin_port = ctr_addr.in.sin_port;
result_in->sin_addr.s_addr = ctr_addr.in.sin_addr;
memset(result_in->sin_zero, 0, sizeof(result_in->sin_zero));
std::memset(result_in->sin_zero, 0, sizeof(result_in->sin_zero));
break;
}
default:
@ -1542,7 +1542,7 @@ void SOC_U::GetNetworkOpt(Kernel::HLERequestContext& ctx) {
case NetworkOpt::NETOPT_MAC_ADDRESS: {
if (opt_len >= 6) {
std::array<u8, 6> fake_mac = {0};
memcpy(opt_data.data(), fake_mac.data(), fake_mac.size());
std::memcpy(opt_data.data(), fake_mac.data(), fake_mac.size());
}
LOG_WARNING(Service_SOC, "(STUBBED) called, level={} opt_name={}", level, opt_name);
err = 0;
@ -1777,8 +1777,8 @@ std::optional<SOC_U::InterfaceInfo> SOC_U::GetDefaultInterfaceInfo() {
int num_interfaces = bytes_used / sizeof(INTERFACE_INFO);
for (int i = 0; i < num_interfaces; i++) {
if (((sockaddr*)&(interface_list[i].iiAddress))->sa_family == AF_INET &&
memcmp(&((sockaddr_in*)&(interface_list[i].iiAddress))->sin_addr.s_addr,
&s_info.sin_addr.s_addr, sizeof(s_info.sin_addr.s_addr)) == 0) {
std::memcmp(&((sockaddr_in*)&(interface_list[i].iiAddress))->sin_addr.s_addr,
&s_info.sin_addr.s_addr, sizeof(s_info.sin_addr.s_addr)) == 0) {
ret.address = ((sockaddr_in*)&(interface_list[i].iiAddress))->sin_addr.s_addr;
ret.netmask = ((sockaddr_in*)&(interface_list[i].iiNetmask))->sin_addr.s_addr;
ret.broadcast =

4
src/core/hw/aes/ccm.cpp
View file

@ -42,7 +42,7 @@ public:
} // namespace
std::vector<u8> EncryptSignCCM(const std::vector<u8>& pdata, const CCMNonce& nonce,
std::vector<u8> EncryptSignCCM(std::span<const u8> pdata, const CCMNonce& nonce,
std::size_t slot_id) {
if (!IsNormalKeyAvailable(slot_id)) {
LOG_ERROR(HW_AES, "Key slot {} not available. Will use zero key.", slot_id);
@ -63,7 +63,7 @@ std::vector<u8> EncryptSignCCM(const std::vector<u8>& pdata, const CCMNonce& non
return cipher;
}
std::vector<u8> DecryptVerifyCCM(const std::vector<u8>& cipher, const CCMNonce& nonce,
std::vector<u8> DecryptVerifyCCM(std::span<const u8> cipher, const CCMNonce& nonce,
std::size_t slot_id) {
if (!IsNormalKeyAvailable(slot_id)) {
LOG_ERROR(HW_AES, "Key slot {} not available. Will use zero key.", slot_id);

5
src/core/hw/aes/ccm.h
View file

@ -6,6 +6,7 @@
#include <array>
#include <cstddef>
#include <span>
#include <vector>
#include "common/common_types.h"
@ -23,7 +24,7 @@ using CCMNonce = std::array<u8, CCM_NONCE_SIZE>;
* @param slot_id The slot ID of the key to use for encryption
* @returns a vector of u8 containing the encrypted data with MAC at the end
*/
std::vector<u8> EncryptSignCCM(const std::vector<u8>& pdata, const CCMNonce& nonce,
std::vector<u8> EncryptSignCCM(std::span<const u8> pdata, const CCMNonce& nonce,
std::size_t slot_id);
/**
@ -33,7 +34,7 @@ std::vector<u8> EncryptSignCCM(const std::vector<u8>& pdata, const CCMNonce& non
* @param slot_id The slot ID of the key to use for decryption
* @returns a vector of u8 containing the decrypted data; an empty vector if the verification fails
*/
std::vector<u8> DecryptVerifyCCM(const std::vector<u8>& cipher, const CCMNonce& nonce,
std::vector<u8> DecryptVerifyCCM(std::span<const u8> cipher, const CCMNonce& nonce,
std::size_t slot_id);
} // namespace HW::AES

6
src/core/hw/gpu.cpp
View file

@ -116,13 +116,13 @@ static void MemoryFill(const Regs::MemoryFillConfig& config) {
u32 value = config.value_32bit;
std::size_t len = (end - start) / sizeof(u32);
for (std::size_t i = 0; i < len; ++i)
memcpy(&start[i * sizeof(u32)], &value, sizeof(u32));
std::memcpy(&start[i * sizeof(u32)], &value, sizeof(u32));
}
} else {
// fill with 16-bit values
u16 value_16bit = config.value_16bit.Value();
for (u8* ptr = start; ptr < end; ptr += sizeof(u16))
memcpy(ptr, &value_16bit, sizeof(u16));
std::memcpy(ptr, &value_16bit, sizeof(u16));
}
}
@ -521,7 +521,7 @@ static void VBlankCallback(std::uintptr_t user_data, s64 cycles_late) {
/// Initialize hardware
void Init(Memory::MemorySystem& memory) {
g_memory = &memory;
memset(&g_regs, 0, sizeof(g_regs));
std::memset(&g_regs, 0, sizeof(g_regs));
auto& framebuffer_top = g_regs.framebuffer_config[0];
auto& framebuffer_sub = g_regs.framebuffer_config[1];

2
src/core/hw/lcd.cpp
View file

@ -64,7 +64,7 @@ template void Write<u8>(u32 addr, const u8 data);
/// Initialize hardware
void Init() {
memset(&g_regs, 0, sizeof(g_regs));
std::memset(&g_regs, 0, sizeof(g_regs));
LOG_DEBUG(HW_LCD, "initialized OK");
}

4
src/core/hw/rsa/rsa.cpp
View file

@ -31,7 +31,7 @@ std::vector<u8> HexToBytes(const std::string& hex) {
constexpr std::size_t SlotSize = 4;
std::array<RsaSlot, SlotSize> rsa_slots;
std::vector<u8> RsaSlot::GetSignature(const std::vector<u8>& message) const {
std::vector<u8> RsaSlot::GetSignature(std::span<const u8> message) const {
CryptoPP::Integer sig =
CryptoPP::ModularExponentiation(CryptoPP::Integer(message.data(), message.size()),
CryptoPP::Integer(exponent.data(), exponent.size()),
@ -85,7 +85,7 @@ RsaSlot GetSlot(std::size_t slot_id) {
return rsa_slots[slot_id];
}
std::vector<u8> CreateASN1Message(const std::vector<u8>& data) {
std::vector<u8> CreateASN1Message(std::span<const u8> data) {
static constexpr std::array<u8, 224> asn1_header = {
{0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

5
src/core/hw/rsa/rsa.h
View file

@ -4,6 +4,7 @@
#pragma once
#include <span>
#include <vector>
#include "common/common_types.h"
@ -14,7 +15,7 @@ public:
RsaSlot() = default;
RsaSlot(std::vector<u8> exponent, std::vector<u8> modulus)
: init(true), exponent(std::move(exponent)), modulus(std::move(modulus)) {}
std::vector<u8> GetSignature(const std::vector<u8>& message) const;
std::vector<u8> GetSignature(std::span<const u8> message) const;
explicit operator bool() const {
// TODO(B3N30): Maybe check if exponent and modulus are vailid
@ -31,6 +32,6 @@ void InitSlots();
RsaSlot GetSlot(std::size_t slot_id);
std::vector<u8> CreateASN1Message(const std::vector<u8>& data);
std::vector<u8> CreateASN1Message(std::span<const u8> data);
} // namespace HW::RSA

2
src/core/loader/3dsx.cpp
View file

@ -149,7 +149,7 @@ static THREEDSX_Error Load3DSXFile(FileUtil::IOFile& file, u32 base_addr,
return ERROR_READ;
// BSS clear
memset((char*)loadinfo.seg_ptrs[2] + hdr.data_seg_size - hdr.bss_size, 0, hdr.bss_size);
std::memset((char*)loadinfo.seg_ptrs[2] + hdr.data_seg_size - hdr.bss_size, 0, hdr.bss_size);
// Relocate the segments
for (unsigned int current_segment = 0; current_segment < NUM_SEGMENTS; ++current_segment) {

2
src/core/loader/elf.cpp
View file

@ -327,7 +327,7 @@ std::shared_ptr<CodeSet> ElfReader::LoadInto(u32 vaddr) {
codeset_segment->addr = segment_addr;
codeset_segment->size = aligned_size;
memcpy(&program_image[current_image_position], GetSegmentPtr(i), p->p_filesz);
std::memcpy(&program_image[current_image_position], GetSegmentPtr(i), p->p_filesz);
current_image_position += aligned_size;
}
}

19
src/core/loader/ncch.cpp
View file

@ -171,7 +171,7 @@ void AppLoader_NCCH::ParseRegionLockoutInfo(u64 program_id) {
std::vector<u8> smdh_buffer;
if (ReadIcon(smdh_buffer) == ResultStatus::Success && smdh_buffer.size() >= sizeof(SMDH)) {
SMDH smdh;
memcpy(&smdh, smdh_buffer.data(), sizeof(SMDH));
std::memcpy(&smdh, smdh_buffer.data(), sizeof(SMDH));
u32 region_lockout = smdh.region_lockout;
constexpr u32 REGION_COUNT = 7;
std::vector<u32> regions;
@ -185,15 +185,20 @@ void AppLoader_NCCH::ParseRegionLockoutInfo(u64 program_id) {
} else {
const auto region = Core::GetSystemTitleRegion(program_id);
if (region.has_value()) {
cfg->SetPreferredRegionCodes({region.value()});
const std::array regions{region.value()};
cfg->SetPreferredRegionCodes(regions);
}
}
}
bool AppLoader_NCCH::IsGbaVirtualConsole(const std::vector<u8>& code) {
const u32* gbaVcHeader = reinterpret_cast<const u32*>(code.data() + code.size() - 0x10);
return code.size() >= 0x10 && gbaVcHeader[0] == MakeMagic('.', 'C', 'A', 'A') &&
gbaVcHeader[1] == 1;
bool AppLoader_NCCH::IsGbaVirtualConsole(std::span<const u8> code) {
if (code.size() < 0x10) [[unlikely]] {
return false;
}
u32 gbaVcHeader[2];
std::memcpy(gbaVcHeader, code.data() + code.size() - 0x10, sizeof(gbaVcHeader));
return gbaVcHeader[0] == MakeMagic('.', 'C', 'A', 'A') && gbaVcHeader[1] == 1;
}
ResultStatus AppLoader_NCCH::Load(std::shared_ptr<Kernel::Process>& process) {
@ -317,7 +322,7 @@ ResultStatus AppLoader_NCCH::ReadTitle(std::string& title) {
return ResultStatus::ErrorInvalidFormat;
}
memcpy(&smdh, data.data(), sizeof(Loader::SMDH));
std::memcpy(&smdh, data.data(), sizeof(Loader::SMDH));
const auto& short_title = smdh.GetShortTitle(SMDH::TitleLanguage::English);
auto title_end = std::find(short_title.begin(), short_title.end(), u'\0');

2
src/core/loader/ncch.h
View file

@ -78,7 +78,7 @@ private:
void ParseRegionLockoutInfo(u64 program_id);
/// Detects whether the NCCH contains GBA Virtual Console.
bool IsGbaVirtualConsole(const std::vector<u8>& code);
bool IsGbaVirtualConsole(std::span<const u8> code);
FileSys::NCCHContainer base_ncch;
FileSys::NCCHContainer update_ncch;

7
src/core/loader/smdh.cpp
View file

@ -11,12 +11,13 @@
namespace Loader {
bool IsValidSMDH(const std::vector<u8>& smdh_data) {
if (smdh_data.size() < sizeof(Loader::SMDH))
bool IsValidSMDH(std::span<const u8> smdh_data) {
if (smdh_data.size() < sizeof(Loader::SMDH)) {
return false;
}
u32 magic;
memcpy(&magic, smdh_data.data(), sizeof(u32));
std::memcpy(&magic, smdh_data.data(), sizeof(u32));
return Loader::MakeMagic('S', 'M', 'D', 'H') == magic;
}

3
src/core/loader/smdh.h
View file

@ -5,6 +5,7 @@
#pragma once
#include <array>
#include <span>
#include <vector>
#include "common/common_funcs.h"
#include "common/common_types.h"
@ -17,7 +18,7 @@ namespace Loader {
* @param smdh_data data buffer to test
* @return bool test result
*/
bool IsValidSMDH(const std::vector<u8>& smdh_data);
bool IsValidSMDH(std::span<const u8> smdh_data);
/// SMDH data structure that contains titles, icons etc. See https://www.3dbrew.org/wiki/SMDH
struct SMDH {

5
src/core/movie.cpp
View file

@ -130,7 +130,7 @@ struct CTMHeader {
static_assert(sizeof(CTMHeader) == 256, "CTMHeader should be 256 bytes");
#pragma pack(pop)
static u64 GetInputCount(const std::vector<u8>& input) {
static u64 GetInputCount(std::span<const u8> input) {
u64 input_count = 0;
for (std::size_t pos = 0; pos < input.size(); pos += sizeof(ControllerState)) {
if (input.size() < pos + sizeof(ControllerState)) {
@ -476,8 +476,7 @@ Movie::ValidationResult Movie::ValidateHeader(const CTMHeader& header) const {
return ValidationResult::OK;
}
Movie::ValidationResult Movie::ValidateInput(const std::vector<u8>& input,
u64 expected_count) const {
Movie::ValidationResult Movie::ValidateInput(std::span<const u8> input, u64 expected_count) const {
return GetInputCount(input) == expected_count ? ValidationResult::OK
: ValidationResult::InputCountDismatch;
}

3
src/core/movie.h
View file

@ -5,6 +5,7 @@
#pragma once
#include <functional>
#include <span>
#include <boost/serialization/vector.hpp>
#include "common/common_types.h"
@ -156,7 +157,7 @@ private:
void Record(const Service::IR::ExtraHIDResponse& extra_hid_response);
ValidationResult ValidateHeader(const CTMHeader& header) const;
ValidationResult ValidateInput(const std::vector<u8>& input, u64 expected_count) const;
ValidationResult ValidateInput(std::span<const u8> input, u64 expected_count) const;
PlayMode play_mode;

3
src/core/rpc/packet.h
View file

@ -6,6 +6,7 @@
#include <array>
#include <functional>
#include <span>
#include "common/common_types.h"
namespace RPC {
@ -67,7 +68,7 @@ public:
private:
void HandleReadMemory(u32 address, u32 data_size);
void HandleWriteMemory(u32 address, const u8* data, u32 data_size);
void HandleWriteMemory(u32 address, std::span<const u8> data);
struct PacketHeader header;
std::array<u8, MAX_PACKET_DATA_SIZE> packet_data;

17
src/core/rpc/rpc_server.cpp
View file

@ -37,18 +37,19 @@ void RPCServer::HandleReadMemory(Packet& packet, u32 address, u32 data_size) {
packet.SendReply();
}
void RPCServer::HandleWriteMemory(Packet& packet, u32 address, const u8* data, u32 data_size) {
void RPCServer::HandleWriteMemory(Packet& packet, u32 address, std::span<const u8> data) {
// Only allow writing to certain memory regions
if ((address >= Memory::PROCESS_IMAGE_VADDR && address <= Memory::PROCESS_IMAGE_VADDR_END) ||
(address >= Memory::HEAP_VADDR && address <= Memory::HEAP_VADDR_END) ||
(address >= Memory::N3DS_EXTRA_RAM_VADDR && address <= Memory::N3DS_EXTRA_RAM_VADDR_END)) {
// Note: Memory write occurs asynchronously from the state of the emulator
Core::System::GetInstance().Memory().WriteBlock(
*Core::System::GetInstance().Kernel().GetCurrentProcess(), address, data, data_size);
*Core::System::GetInstance().Kernel().GetCurrentProcess(), address, data.data(),
data.size());
// If the memory happens to be executable code, make sure the changes become visible
// Is current core correct here?
Core::System::GetInstance().InvalidateCacheRange(address, data_size);
Core::System::GetInstance().InvalidateCacheRange(address, data.size());
}
packet.SetPacketDataSize(0);
packet.SendReply();
@ -72,14 +73,14 @@ bool RPCServer::ValidatePacket(const PacketHeader& packet_header) {
void RPCServer::HandleSingleRequest(std::unique_ptr<Packet> request_packet) {
bool success = false;
const auto& packet_data = request_packet->GetPacketData();
if (ValidatePacket(request_packet->GetHeader())) {
// Currently, all request types use the address/data_size wire format
u32 address = 0;
u32 data_size = 0;
std::memcpy(&address, request_packet->GetPacketData().data(), sizeof(address));
std::memcpy(&data_size, request_packet->GetPacketData().data() + sizeof(address),
sizeof(data_size));
std::memcpy(&address, packet_data.data(), sizeof(address));
std::memcpy(&data_size, packet_data.data() + sizeof(address), sizeof(data_size));
switch (request_packet->GetPacketType()) {
case PacketType::ReadMemory:
@ -90,8 +91,8 @@ void RPCServer::HandleSingleRequest(std::unique_ptr<Packet> request_packet) {
break;
case PacketType::WriteMemory:
if (data_size > 0 && data_size <= MAX_PACKET_DATA_SIZE - (sizeof(u32) * 2)) {
const u8* data = request_packet->GetPacketData().data() + (sizeof(u32) * 2);
HandleWriteMemory(*request_packet, address, data, data_size);
const auto data = std::span{packet_data}.subspan(sizeof(u32) * 2, data_size);
HandleWriteMemory(*request_packet, address, data);
success = true;
}
break;

3
src/core/rpc/rpc_server.h
View file

@ -7,6 +7,7 @@
#include <condition_variable>
#include <memory>
#include <mutex>
#include <span>
#include <thread>
#include "common/threadsafe_queue.h"
#include "core/rpc/server.h"
@ -27,7 +28,7 @@ private:
void Start();
void Stop();
void HandleReadMemory(Packet& packet, u32 address, u32 data_size);
void HandleWriteMemory(Packet& packet, u32 address, const u8* data, u32 data_size);
void HandleWriteMemory(Packet& packet, u32 address, std::span<const u8> data);
bool ValidatePacket(const PacketHeader& packet_header);
void HandleSingleRequest(std::unique_ptr<Packet> request);
void HandleRequestsLoop();

4
src/core/savestate.cpp
View file

@ -108,8 +108,8 @@ void System::SaveState(u32 slot) const {
oa&* this;
const std::string& str{sstream.str()};
auto buffer = Common::Compression::CompressDataZSTDDefault(
reinterpret_cast<const u8*>(str.data()), str.size());
const auto data = std::span<const u8>{reinterpret_cast<const u8*>(str.data()), str.size()};
auto buffer = Common::Compression::CompressDataZSTDDefault(data);
const auto path = GetSaveStatePath(title_id, slot);
if (!FileUtil::CreateFullPath(path)) {

2
src/core/tracer/recorder.cpp
View file

@ -180,7 +180,7 @@ void Recorder::MemoryAccessed(const u8* data, u32 size, u32 physical_address) {
element.uses_existing_data = (memory_regions.find(element.hash) != memory_regions.end());
if (!element.uses_existing_data) {
element.extra_data.resize(size);
memcpy(element.extra_data.data(), data, size);
std::memcpy(element.extra_data.data(), data, size);
memory_regions.insert({element.hash, 0}); // file offset will be initialized in Finish()
}

1
src/core/tracer/recorder.h
View file

@ -4,6 +4,7 @@
#pragma once
#include <span>
#include <string>
#include <unordered_map>
#include <vector>

2
src/tests/audio_core/decoder_tests.cpp
View file

@ -38,7 +38,7 @@ TEST_CASE("DSP HLE Audio Decoder", "[audio_core]") {
request.header.cmd = AudioCore::HLE::DecoderCommand::EncodeDecode;
u8* fcram = memory.GetFCRAMPointer(0);
memcpy(fcram, fixure_buffer, fixure_buffer_size);
std::memcpy(fcram, fixure_buffer, fixure_buffer_size);
request.decode_aac_request.src_addr = Memory::FCRAM_PADDR;
request.decode_aac_request.dst_addr_ch0 = Memory::FCRAM_PADDR + 1024;
request.decode_aac_request.dst_addr_ch1 = Memory::FCRAM_PADDR + 1048576; // 1 MB

4
src/tests/audio_core/hle/hle.cpp
View file

@ -78,7 +78,7 @@ TEST_CASE("DSP LLE vs HLE", "[audio_core][hle]") {
std::vector<u8> lle_read_buffer;
lle_read_buffer = lle.PipeRead(AudioCore::DspPipe::Audio, 2);
u16 lle_size;
memcpy(&lle_size, lle_read_buffer.data(), sizeof(lle_size));
std::memcpy(&lle_size, lle_read_buffer.data(), sizeof(lle_size));
lle_read_buffer = lle.PipeRead(AudioCore::DspPipe::Audio, lle_size * 2);
// HLE
@ -89,7 +89,7 @@ TEST_CASE("DSP LLE vs HLE", "[audio_core][hle]") {
std::vector<u8> hle_read_buffer(32);
hle_read_buffer = hle.PipeRead(AudioCore::DspPipe::Audio, 2);
u16 hle_size;
memcpy(&hle_size, hle_read_buffer.data(), sizeof(hle_size));
std::memcpy(&hle_size, hle_read_buffer.data(), sizeof(hle_size));
hle_read_buffer = hle.PipeRead(AudioCore::DspPipe::Audio, hle_size * 2);
REQUIRE(hle_size == lle_size);

2
src/tests/audio_core/lle/lle.cpp
View file

@ -70,7 +70,7 @@ TEST_CASE("DSP LLE Sanity", "[audio_core][lle]") {
buffer = lle.PipeRead(AudioCore::DspPipe::Audio, 2);
u16 size;
memcpy(&size, buffer.data(), sizeof(size));
std::memcpy(&size, buffer.data(), sizeof(size));
// see AudioCore::DspHle::Impl::AudioPipeWriteStructAddresses()
REQUIRE(size * 2 == 30);
}

4
src/tests/common/file_util.cpp
View file

@ -21,6 +21,6 @@ TEST_CASE("SplitFilename83 Sanity", "[common]") {
std::string expected_short_name = filename.substr(0, 6).append("~1");
std::string expected_extension = filename.substr(filename.find('.') + 1, 3);
REQUIRE(memcmp(short_name.data(), expected_short_name.data(), short_name.size()) == 0);
REQUIRE(memcmp(extension.data(), expected_extension.data(), extension.size()) == 0);
REQUIRE(std::memcmp(short_name.data(), expected_short_name.data(), short_name.size()) == 0);
REQUIRE(std::memcmp(extension.data(), expected_extension.data(), extension.size()) == 0);
}

6
src/video_core/debug_utils/debug_utils.cpp
View file

@ -226,7 +226,7 @@ void DumpShader(const std::string& filename, const ShaderRegs& config,
std::vector<nihstro::ConstantInfo> constant_table;
for (unsigned i = 0; i < setup.uniforms.b.size(); ++i) {
nihstro::ConstantInfo constant;
memset(&constant, 0, sizeof(constant));
std::memset(&constant, 0, sizeof(constant));
constant.type = nihstro::ConstantInfo::Bool;
constant.regid = i;
constant.b = setup.uniforms.b[i];
@ -234,7 +234,7 @@ void DumpShader(const std::string& filename, const ShaderRegs& config,
}
for (unsigned i = 0; i < setup.uniforms.i.size(); ++i) {
nihstro::ConstantInfo constant;
memset(&constant, 0, sizeof(constant));
std::memset(&constant, 0, sizeof(constant));
constant.type = nihstro::ConstantInfo::Int;
constant.regid = i;
constant.i.x = setup.uniforms.i[i].x;
@ -245,7 +245,7 @@ void DumpShader(const std::string& filename, const ShaderRegs& config,
}
for (unsigned i = 0; i < sizeof(setup.uniforms.f) / sizeof(setup.uniforms.f[0]); ++i) {
nihstro::ConstantInfo constant;
memset(&constant, 0, sizeof(constant));
std::memset(&constant, 0, sizeof(constant));
constant.type = nihstro::ConstantInfo::Float;
constant.regid = i;
constant.f.x = nihstro::to_float24(setup.uniforms.f[i].x.ToFloat32());

2
src/video_core/gpu_debugger.h
View file

@ -51,7 +51,7 @@ public:
gx_command_history.emplace_back();
Service::GSP::Command& cmd = gx_command_history.back();
memcpy(&cmd, command_data, sizeof(Service::GSP::Command));
std::memcpy(&cmd, command_data, sizeof(Service::GSP::Command));
ForEachObserver([this](DebuggerObserver* observer) {
observer->GXCommandProcessed(static_cast<int>(this->gx_command_history.size()));

2
src/video_core/pica.cpp
View file

@ -33,7 +33,7 @@ void Shutdown() {
template <typename T>
void Zero(T& o) {
static_assert(std::is_trivial_v<T>, "It's undefined behavior to memset a non-trivial type");
memset(&o, 0, sizeof(o));
std::memset(&o, 0, sizeof(o));
}
State::State() : geometry_pipeline(*this) {

5
src/video_core/renderer_opengl/gl_resource_manager.cpp
View file

@ -122,7 +122,7 @@ void OGLShader::Release() {
handle = 0;
}
void OGLProgram::Create(bool separable_program, const std::vector<GLuint>& shaders) {
void OGLProgram::Create(bool separable_program, std::span<const GLuint> shaders) {
if (handle != 0)
return;
@ -136,7 +136,8 @@ void OGLProgram::Create(std::string_view vert_shader, std::string_view frag_shad
frag.Create(frag_shader, GL_FRAGMENT_SHADER);
MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
Create(false, {vert.handle, frag.handle});
const std::array shaders{vert.handle, frag.handle};
Create(false, shaders);
}
void OGLProgram::Release() {

3
src/video_core/renderer_opengl/gl_resource_manager.h
View file

@ -4,6 +4,7 @@
#pragma once
#include <span>
#include <utility>
#include <vector>
#include <glad/glad.h>
@ -129,7 +130,7 @@ public:
}
/// Creates a new program from given shader objects
void Create(bool separable_program, const std::vector<GLuint>& shaders);
void Create(bool separable_program, std::span<const GLuint> shaders);
/// Creates a new program from given shader soruce code
void Create(std::string_view vert_shader, std::string_view frag_shader);

Some files were not shown because too many files have changed in this diff Show more