Makes it impossible to indirectly violate the ODR in some other
translation unit due to these existing.

Instead, pass in the core timing instance and make the dependency
explicit in the interface.

Now that the NSO header has the proper size, we can just use sizeof on
it instead of having magic constants.

This source file was utilizing its own version of the NSO header.
Instead of keeping this around, we can have the patch manager also use
the version of the header that we have defined in loader/nso.h

The total struct itself is 0x100 (256) bytes in size, so we should be
providing that amount of data.

Without the data, this can result in omitted data from the final loaded
NSO file.

Given this is utilized by the loaders, this allows avoiding inclusion of
the kernel process definitions where avoidable.

This also keeps the loading format for all executable data separate from
the kernel objects.

Given the class is now currently unused, it can be removed.

Neither the NRO or NSO loaders actually make use of the functions or
members provided by the Linker interface, so we can just remove the
inheritance altogether.

For rom directories (and by extension, XCI/NSP/NAX/NCA) this is for the NSO with name 'main', for regular NSOs, this is the NSO.

While we're at it, we can also toss out the leftover capability parsing
from Citra.

No implementations actually modify instance state (and it would be
questionable to do that in the first place given the name), so we can
make this a const member function.

Similar to the NRO changes, we can also pass the process explicitly as a
parameter from Load instead of indirecting through the System class.

This simply acts as a forwarding function for the Load() function, so
this doesn't need to be directly exposed.

Load() is already given the process instance as a parameter, so instead
of coupling the class to the System class, we can just forward that
parameter to LoadNro()

Credits to Subv

* get rid of boost::optional

* Remove optional references

* Use std::reference_wrapper for optional references

* Fix clang format

* Fix clang format part 2

* Adressed feedback

* Fix clang format and MacOS build

When enabled in settings, PatchNSO will dump the unmodified NSO that it was passed to a file named <build id>.nso in the dump root for the current title ID.

Allows NRO homebrew to use the RomFS in the ASET section.

Prevents nullptr bug when trying to dump the RomFS of an NSP resulting from secondary_loader not being initialized.

The only reason the getter existed was to check whether or not the
program NCA was null. Instead, we can just provide a function to query
for the existence of it, instead of exposing it entirely.

If a malformed NSO is attempted to be loaded, we shouldn't continue
onwards. We should be reporting an error and bailing out.

This function doesn't need to care about ownership semantics, so we can
just pass it a reference to the file itself, rather than a
std::shared_ptr alias.

These only exist to ferry data into a Process instance and end up going
out of scope quite early. Because of this, we can just make it a plain
struct for holding things and just std::move it into the relevant
function. There's no need to make this inherit from the kernel's Object
type.

patch_manager: Return a std::unique_ptr from ParseControlNCA() and GetControlMetadata() instead of a std::shared_ptr

Neither of these functions require the use of shared ownership of the
returned pointer. This makes it more difficult to create reference
cycles with, and makes the interface more generic, as std::shared_ptr
instances can be created from a std::unique_ptr, but the vice-versa
isn't possible. This also alters relevant functions to take NCA
arguments by const reference rather than a const reference to a
std::shared_ptr. These functions don't alter the ownership of the memory
used by the NCA instance, so we can make the interface more generic by
not assuming anything about the type of smart pointer the NCA is
contained within and make it the caller's responsibility to ensure the
supplied NCA is valid.

Uses -p (--program) and following string as args.

Only added if arguments string is non-empty and a pass is requested by loader.

Reads the update included with the game if it has one and adds the new ErrorNoPackedUpdate status.

Fixes errors with certain updates

Avoid resource-heavy classes and remove quasi-duplicated code.