/// Initializes an empty database.
///
/// \param db The database to initialize.
///
/// \return The metadata record written into the new database.
///
/// \throw store::error If there is a problem initializing the database.
store::metadata
store::detail::initialize(sqlite::database& db)
{
PRE(empty_database(db));
const fs::path schema = schema_file();
std::ifstream input(schema.c_str());
if (!input)
throw error(F("Cannot open database schema '%s'") % schema);
LI(F("Populating new database with schema from %s") % schema);
const std::string schema_string = utils::read_stream(input);
try {
db.exec(schema_string);
const metadata metadata = metadata::fetch_latest(db);
LI(F("New metadata entry %s") % metadata.timestamp());
if (metadata.schema_version() != detail::current_schema_version) {
UNREACHABLE_MSG(F("current_schema_version is out of sync with "
"%s") % schema);
}
return metadata;
} catch (const store::integrity_error& e) {
// Could be raised by metadata::fetch_latest.
UNREACHABLE_MSG("Inconsistent code while creating a database");
} catch (const sqlite::error& e) {
throw error(F("Failed to initialize database: %s") % e.what());
}
}
void Mixers::DownmixAndMixIntoCurrentFrame(float gain, const QuadFrame32& samples) {
// TODO(merry): Limiter. (Currently we're performing final mixing assuming a disabled limiter.)
switch (state.output_format) {
case OutputFormat::Mono:
std::transform(current_frame.begin(), current_frame.end(), samples.begin(), current_frame.begin(),
[gain](const std::array<s16, 2>& accumulator, const std::array<s32, 4>& sample) -> std::array<s16, 2> {
// Downmix to mono
s16 mono = ClampToS16(static_cast<s32>((gain * sample[0] + gain * sample[1] + gain * sample[2] + gain * sample[3]) / 2));
// Mix into current frame
return AddAndClampToS16(accumulator, { mono, mono });
});
return;
case OutputFormat::Surround:
// TODO(merry): Implement surround sound.
// fallthrough
case OutputFormat::Stereo:
std::transform(current_frame.begin(), current_frame.end(), samples.begin(), current_frame.begin(),
[gain](const std::array<s16, 2>& accumulator, const std::array<s32, 4>& sample) -> std::array<s16, 2> {
// Downmix to stereo
s16 left = ClampToS16(static_cast<s32>(gain * sample[0] + gain * sample[2]));
s16 right = ClampToS16(static_cast<s32>(gain * sample[1] + gain * sample[3]));
// Mix into current frame
return AddAndClampToS16(accumulator, { left, right });
});
return;
}
UNREACHABLE_MSG("Invalid output_format %zu", static_cast<size_t>(state.output_format));
}
bool UnixNativeCodeManager::EHEnumNext(EHEnumState * pEHEnumState, EHClause * pEHClauseOut)
{
assert(pEHEnumState != NULL);
assert(pEHClauseOut != NULL);
UnixEHEnumState * pEnumState = (UnixEHEnumState *)pEHEnumState;
if (pEnumState->uClause >= pEnumState->nClauses)
{
return false;
}
pEnumState->uClause++;
pEHClauseOut->m_tryStartOffset = VarInt::ReadUnsigned(pEnumState->pEHInfo);
UInt32 tryEndDeltaAndClauseKind = VarInt::ReadUnsigned(pEnumState->pEHInfo);
pEHClauseOut->m_clauseKind = (EHClauseKind)(tryEndDeltaAndClauseKind & 0x3);
pEHClauseOut->m_tryEndOffset = pEHClauseOut->m_tryStartOffset + (tryEndDeltaAndClauseKind >> 2);
// For each clause, we have up to 4 integers:
// 1) try start offset
// 2) (try length << 2) | clauseKind
// 3) if (typed || fault || filter) { handler start offset }
// 4a) if (typed) { type RVA }
// 4b) if (filter) { filter start offset }
//
// The first two integers have already been decoded
switch (pEHClauseOut->m_clauseKind)
{
case EH_CLAUSE_TYPED:
pEHClauseOut->m_handlerAddress = pEnumState->pMethodStartAddress + VarInt::ReadUnsigned(pEnumState->pEHInfo);
// Read target type
{
// @TODO: CORERT: Compress EHInfo using type table index scheme
// https://github.com/dotnet/corert/issues/972
Int32 typeRelAddr = *((PTR_Int32&)pEnumState->pEHInfo)++;
pEHClauseOut->m_pTargetType = dac_cast<PTR_VOID>(pEnumState->pEHInfo + typeRelAddr);
}
break;
case EH_CLAUSE_FAULT:
pEHClauseOut->m_handlerAddress = pEnumState->pMethodStartAddress + VarInt::ReadUnsigned(pEnumState->pEHInfo);
break;
case EH_CLAUSE_FILTER:
pEHClauseOut->m_handlerAddress = pEnumState->pMethodStartAddress + VarInt::ReadUnsigned(pEnumState->pEHInfo);
pEHClauseOut->m_filterAddress = pEnumState->pMethodStartAddress + VarInt::ReadUnsigned(pEnumState->pEHInfo);
break;
default:
UNREACHABLE_MSG("unexpected EHClauseKind");
}
return true;
}
/// Registers a node as being dynamic.
///
/// This operation creates the given key as an inner node. Further set
/// operations that trespass this node will automatically create any missing
/// keys.
///
/// This method does not raise errors on invalid/unknown keys or other
/// tree-related issues. The reasons is that define() is a method that does not
/// depend on user input: it is intended to pre-populate the tree with a
/// specific structure, and that happens once at coding time.
///
/// \param dotted_key The key to be registered in dotted representation.
void
config::tree::define_dynamic(const std::string& dotted_key)
{
try {
const detail::tree_key key = detail::parse_key(dotted_key);
_root->define(key, 0, detail::new_node< detail::dynamic_inner_node >);
} catch (const error& e) {
UNREACHABLE_MSG("define() failing due to key errors is a programming "
"mistake: " + std::string(e.what()));
}
}
/// Terminates the current process reproducing the given status.
///
/// The caller process is abruptly terminated. In particular, no output streams
/// are flushed, no destructors are called, and no atexit(2) handlers are run.
///
/// \param status The status to "re-deliver" to the caller process.
void
process::terminate_self_with(const status& status)
{
if (status.exited()) {
::_exit(status.exitstatus());
} else {
INV(status.signaled());
(void)::kill(::getpid(), status.termsig());
UNREACHABLE_MSG(F("Signal %s terminated %s but did not terminate "
"ourselves") % status.termsig() % status.dead_pid());
}
}
Kernel::SharedPtr<Kernel::Event>& Get(InterruptType type, DspPipe dsp_pipe) {
switch (type) {
case InterruptType::Zero:
return zero;
case InterruptType::One:
return one;
case InterruptType::Pipe: {
const size_t pipe_index = static_cast<size_t>(dsp_pipe);
ASSERT(pipe_index < AudioCore::num_dsp_pipe);
return pipe[pipe_index];
}
}
UNREACHABLE_MSG("Invalid interrupt type = {}", static_cast<size_t>(type));
}
void GPUCommandListWidget::OnCommandDoubleClicked(const QModelIndex& index) {
const unsigned int command_id =
list_widget->model()->data(index, GPUCommandListModel::CommandIdRole).toUInt();
if (COMMAND_IN_RANGE(command_id, texturing.texture0) ||
COMMAND_IN_RANGE(command_id, texturing.texture1) ||
COMMAND_IN_RANGE(command_id, texturing.texture2)) {
unsigned texture_index;
if (COMMAND_IN_RANGE(command_id, texturing.texture0)) {
texture_index = 0;
} else if (COMMAND_IN_RANGE(command_id, texturing.texture1)) {
texture_index = 1;
} else if (COMMAND_IN_RANGE(command_id, texturing.texture2)) {
texture_index = 2;
} else {
UNREACHABLE_MSG("Unknown texture command");
}
// TODO: Open a surface debugger
}
}
void GPUCommandListWidget::OnCommandDoubleClicked(const QModelIndex& index) {
const unsigned int command_id =
list_widget->model()->data(index, GPUCommandListModel::CommandIdRole).toUInt();
if (COMMAND_IN_RANGE(command_id, texture0) || COMMAND_IN_RANGE(command_id, texture1) ||
COMMAND_IN_RANGE(command_id, texture2)) {
unsigned index;
if (COMMAND_IN_RANGE(command_id, texture0)) {
index = 0;
} else if (COMMAND_IN_RANGE(command_id, texture1)) {
index = 1;
} else if (COMMAND_IN_RANGE(command_id, texture2)) {
index = 2;
} else {
UNREACHABLE_MSG("Unknown texture command");
}
auto config = Pica::g_state.regs.GetTextures()[index].config;
auto format = Pica::g_state.regs.GetTextures()[index].format;
auto info = Pica::DebugUtils::TextureInfo::FromPicaRegister(config, format);
// TODO: Open a surface debugger
}
}
/// Ensures that an argument passed to the option is valid.
///
/// This must be reimplemented by subclasses that describe options with
/// arguments.
///
/// \throw cmdline::option_argument_value_error Subclasses must raise this
/// exception to indicate the cases in which str is invalid.
void
cmdline::base_option::validate(const std::string& /* str */) const
{
UNREACHABLE_MSG("Option does not support an argument");
}
