//
// Builtin `shift`.
//
int b_shift(int n, char *argv[], Shbltin_t *context) {
char *arg;
Shell_t *shp = context->shp;
while ((n = optget(argv, sh_optshift))) {
switch (n) {
case ':': {
errormsg(SH_DICT, 2, "%s", opt_info.arg);
break;
}
case '?': {
errormsg(SH_DICT, ERROR_usage(0), "%s", opt_info.arg);
return 2;
}
default: { break; }
}
}
if (error_info.errors) {
errormsg(SH_DICT, ERROR_usage(2), "%s", optusage(NULL));
__builtin_unreachable();
}
argv += opt_info.index;
n = ((arg = *argv) ? (int)sh_arith(shp, arg) : 1);
if (n < 0 || shp->st.dolc < n) {
errormsg(SH_DICT, ERROR_exit(1), e_number, arg);
__builtin_unreachable();
} else {
shp->st.dolv += n;
shp->st.dolc -= n;
}
return 0;
}
//
// Builtin `wait`.
//
int b_wait(int n, char *argv[], Shbltin_t *context) {
Shell_t *shp = context->shp;
while ((n = optget(argv, sh_optwait))) {
switch (n) {
case ':': {
errormsg(SH_DICT, 2, "%s", opt_info.arg);
break;
}
case '?': {
errormsg(SH_DICT, ERROR_usage(2), "%s", opt_info.arg);
__builtin_unreachable();
}
default: { break; }
}
}
if (error_info.errors) {
errormsg(SH_DICT, ERROR_usage(2), "%s", optusage(NULL));
__builtin_unreachable();
}
argv += opt_info.index;
job_bwait(argv);
return shp->exitval;
}
int b_let(int argc, char *argv[], Shbltin_t *context) {
int r;
char *arg;
Shell_t *shp = context->shp;
UNUSED(argc);
while ((r = optget(argv, sh_optlet))) {
switch (r) {
case ':': {
errormsg(SH_DICT, 2, "%s", opt_info.arg);
break;
}
case '?': {
errormsg(SH_DICT, ERROR_usage(2), "%s", opt_info.arg);
__builtin_unreachable();
}
default: { break; }
}
}
argv += opt_info.index;
if (error_info.errors || !*argv) {
errormsg(SH_DICT, ERROR_usage(2), "%s", optusage(NULL));
__builtin_unreachable();
}
while ((arg = *argv++)) r = !sh_arith(shp, arg);
return r;
}
int
Fgenerate_new_buffer_name (void)
{
char number[2];
int i = foo ();
if (i < 0)
__builtin_unreachable ();
if (i >= 2)
__builtin_unreachable ();
return sprintf (number, "%d", i); /* { dg-bogus "writing" } */
}
/* { dg-options "-O2" } */
void
g (int a, int b, int c, int d)
{
if (d)
{
((void)
(!(a && b && c) ? __builtin_unreachable (), 0 : 0));
}
((void)
(!(a && b && c) ? __builtin_unreachable (), 0 : 0));
}
int
bar (int x, long *y)
{
if (x)
{
fn (y[0]);
v = 1;
__builtin_unreachable ();
}
v = 1;
__builtin_unreachable ();
}
static int md5(lua_State *L) {
size_t len;
const char *input = lua_tolstring(L, 1, &len);
if (input == NULL) {
lua_pushstring(L, "first argument: should be the input string");
lua_error(L);
__builtin_unreachable();
}
unsigned char digest[MD5_DIGEST_LEN];
char output[MD5_STRLEN];
struct md5_ctx ctx;
md5_begin(&ctx);
md5_hash(input, len, &ctx);
md5_end(digest, &ctx);
// fill the digest bytewise in the output string
int i;
for (i = 0; i < MD5_DIGEST_LEN; i++) {
sprintf(output + 2*i, "%02x", digest[i]);
}
lua_pushstring(L, output);
return 1;
}
// where should this go...
extern "C" void abort() {
static void (*libc_abort)() = (void (*)())dlsym(RTLD_NEXT, "abort");
// In case something calls abort down the line:
static bool recursive = false;
if (!recursive) {
recursive = true;
fprintf(stderr, "Someone called abort!\n");
// If we call abort(), things may be seriously wrong. Set an alarm() to
// try to handle cases that we would just hang.
// (Ex if we abort() from a static constructor, and _printStackTrace uses
// that object, _printStackTrace will hang waiting for the first construction
// to finish.)
alarm(1);
try {
_printStacktrace();
} catch (ExcInfo) {
fprintf(stderr, "error printing stack trace during abort()");
}
// Cancel the alarm.
// This is helpful for when running in a debugger, since the debugger will catch the
// abort and let you investigate, but the alarm will still come back to kill the program.
alarm(0);
}
libc_abort();
__builtin_unreachable();
}
/*
Loads registers using values in pcb
@param Process ID
@param PID
@return Returns 0 if successful
*/
void load_process_state(pcb* pcb_p)
{
asm("MOV r0, %0"::"r"(pcb_p->R0):);
asm("MOV r1, %0"::"r"(pcb_p->R1):);
asm("MOV r2, %0"::"r"(pcb_p->R2):);
asm("MOV r3, %0"::"r"(pcb_p->R3):);
asm("MOV r4, %0"::"r"(pcb_p->R4):);
asm("MOV r5, %0"::"r"(pcb_p->R5):);
asm("MOV r6, %0"::"r"(pcb_p->R6):);
asm("MOV r7, %0"::"r"(pcb_p->R7):);
asm("MOV r8, %0"::"r"(pcb_p->R8):);
asm("MOV r9, %0"::"r"(pcb_p->R9):);
asm("MOV r10, %0"::"r"(pcb_p->R10):);
//asm("MOV r11, %0"::"r"(11):);
asm("MOV r12, %0"::"r"(pcb_p->R12):);
asm("MOV r13, %0"::"r"(pcb_p->R13):);
asm("MOV r14, %0"::"r"(pcb_p->R14):);
//assert(1==11);
asm("MOV r15, %0"::"r"(pcb_p->R15):);
__builtin_unreachable();
}
void abort(void)
{
// TODO: Add proper kernel panic.
printf("\nPANIC!!!!!!!!!!!!!! Abort all stations!\n");
while ( 1 ) { }
__builtin_unreachable();
}
static inline const char *string_for_property_type(PropertyType type) {
switch (type) {
case PropertyType::String:
return "string";
case PropertyType::Int:
return "int";
case PropertyType::Bool:
return "bool";
case PropertyType::Date:
return "date";
case PropertyType::Data:
return "data";
case PropertyType::Double:
return "double";
case PropertyType::Float:
return "float";
case PropertyType::Any:
return "any";
case PropertyType::Object:
return "object";
case PropertyType::Array:
return "array";
#if __GNUC__
default:
__builtin_unreachable();
#endif
}
}
void exit(int status) {
pthread_mutex_lock(&exit_mutex);
if (_exit_func) (*_exit_func)();
_fini();
syscall_exit(status);
__builtin_unreachable();
}
void _start(void)
{
/* Copy data segment */
memcpy(&_sdata, &_sidata, &_edata - &_sdata);
/* Zero BSS segment */
bzero(&_sbss, &_ebss - &_sbss);
/* We don't have CCM-SRAM, but why limit ourselves */
/* bzero(&_sfast, &_efast - &_sfast); */
/* FPU interrupt handling: lazy save of FP state */
FPU->FPCCR |= FPU_FPCCR_ASPEN_Msk | FPU_FPCCR_LSPEN_Msk;
/* Default NaN mode (don't propagate; just make NaN) and
* flush-to-zero handling for subnormals
*/
FPU->FPDSCR |= FPU_FPDSCR_DN_Msk | FPU_FPDSCR_FZ_Msk;
/* Enable the FPU in the coprocessor state register; CP10/11 */
SCB->CPACR |= 0x00f00000;
/* Invoke main. */
asm ("bl main");
__builtin_unreachable();
}
void abort(void)
{
// TODO: Proper kernel panic
printf("Kernel Panic: abort()\n");
while(1) {}
__builtin_unreachable();
}
static long sys_exit(int status)
{
const std::string msg = "Service exited with status " + std::to_string(status) + "\n";
OS::print(msg.data(), msg.size());
__arch_poweroff();
__builtin_unreachable();
}
void _exit(int status) {
kprintf("%s",std::string(LINEWIDTH, '=').c_str());
kprint("\n");
SYSINFO("service exited with status %i", status);
default_exit();
__builtin_unreachable();
}
void panic_epilogue(const char* why)
{
// Call custom on panic handler (if present).
if (panic_handler != nullptr) {
// Avoid recursion if the panic handler results in panic
auto final_action = panic_handler;
panic_handler = nullptr;
final_action(why);
}
#if defined(ARCH_x86)
SMP::global_lock();
// Signal End-Of-Transmission
kprint("\x04");
SMP::global_unlock();
#else
#warning "panic() handler not implemented for selected arch"
#endif
switch (OS::panic_action())
{
case OS::Panic_action::halt:
while (1) OS::halt();
case OS::Panic_action::shutdown:
extern void __arch_poweroff();
__arch_poweroff();
case OS::Panic_action::reboot:
default:
OS::reboot();
}
__builtin_unreachable();
}
int b_eval(int argc, char *argv[], Shbltin_t *context) {
int r;
Shell_t *shp = context->shp;
UNUSED(argc);
while ((r = optget(argv, sh_opteval))) {
switch (r) {
case ':': {
errormsg(SH_DICT, 2, "%s", opt_info.arg);
break;
}
case '?': {
errormsg(SH_DICT, ERROR_usage(0), "%s", opt_info.arg);
return 2;
}
default: { break; }
}
}
if (error_info.errors) {
errormsg(SH_DICT, ERROR_usage(2), "%s", optusage(NULL));
__builtin_unreachable();
}
argv += opt_info.index;
if (*argv && **argv) {
sh_offstate(shp, SH_MONITOR);
sh_eval(shp, sh_sfeval((const char **)argv), 0);
}
return shp->exitval;
}
/**
* Handle fatal errors
*
* @v fmt Error message format string
* @v ... Arguments
*/
void die ( const char *fmt, ... ) {
EFI_BOOT_SERVICES *bs;
EFI_RUNTIME_SERVICES *rs;
va_list args;
/* Print message */
va_start ( args, fmt );
vprintf ( fmt, args );
va_end ( args );
/* Reboot or exit as applicable */
if ( efi_systab ) {
/* Exit */
bs = efi_systab->BootServices;
bs->Exit ( efi_image_handle, EFI_LOAD_ERROR, 0, NULL );
printf ( "Failed to exit\n" );
rs = efi_systab->RuntimeServices;
rs->ResetSystem ( EfiResetWarm, 0, 0, NULL );
printf ( "Failed to reboot\n" );
} else {
/* Wait for keypress */
printf ( "Press a key to reboot..." );
getchar();
printf ( "\n" );
/* Reboot system */
reboot();
}
/* Should be impossible to reach this */
__builtin_unreachable();
}
/*
* xabort_errno - print a message to stderr, and exit the process.
* Calling abort() in libc might result other syscalls being called
* by libc.
*
* If error_code is not zero, it is also printed.
*/
void
xabort_errno(int error_code, const char *msg)
{
static const char main_msg[] = " libsyscall_intercept error\n";
if (msg != NULL) {
/* not using libc - inline strlen */
size_t len = 0;
while (msg[len] != '\0')
++len;
syscall_no_intercept(SYS_write, 2, msg, len);
}
if (error_code != 0) {
char buf[0x10];
size_t len = 1;
char *c = buf + sizeof(buf) - 1;
/* not using libc - inline sprintf */
do {
*c-- = error_code % 10;
++len;
error_code /= 10;
} while (error_code != 0);
*c = ' ';
syscall_no_intercept(SYS_write, 2, c, len);
}
syscall_no_intercept(SYS_write, 2, main_msg, sizeof(main_msg) - 1);
syscall_no_intercept(SYS_exit_group, 1);
__builtin_unreachable();
}
void N::deleteChildren(N *node) {
if (N::isLeaf(node)) {
return;
}
switch (node->getType()) {
case NTypes::N4: {
auto n = static_cast<N4 *>(node);
n->deleteChildren();
return;
}
case NTypes::N16: {
auto n = static_cast<N16 *>(node);
n->deleteChildren();
return;
}
case NTypes::N48: {
auto n = static_cast<N48 *>(node);
n->deleteChildren();
return;
}
case NTypes::N256: {
auto n = static_cast<N256 *>(node);
n->deleteChildren();
return;
}
}
assert(false);
__builtin_unreachable();
}
int pr13910_foo(int x) {
if (x == 1)
return 0;
else
return x;
__builtin_unreachable(); // expected no warning
}
void __cxa_throw(void *except, __cxa_info_type info, void (*dest)(void *))
{
auto rethrow = (void (*)(void*, __cxa_info_type, void(*)(void*)))dlsym(RTLD_NEXT, "__cxa_throw");
luw_backtrace();
rethrow(except, info, dest);
__builtin_unreachable(); // rethrow is noreturn
}
void abort(void)
{
// TODO: Add proper kernel panic.
printf("Popcorn Panic [abort()]: abandon ship!\n");
while ( 1 ) { }
__builtin_unreachable();
}
loadExecReboot(int r0, int r1, int r2, uint32_t hiId, uint32_t loId)
{
const size_t pathLen = 64;
wchar_t path[pathLen];
size_t read;
P9File f;
p9FileInit(f);
swprintf(path, pathLen, L"sdmc:/" FIRM_PATH_FMT, hiId, loId);
p9Open(f, path, 1);
p9Read(f, &read, (void *)FIRM_ADDR, FIRM_SIZE);
p9Close(f);
p9FileInit(f);
swprintf(path, pathLen, L"sdmc:/" FIRM_PATCH_PATH_FMT, hiId, loId);
p9Open(f, path, 1);
p9Read(f, &read, (void *)PATCH_ADDR, PATCH_SIZE);
p9Close(f);
while (p9RecvPxi() != 0x44846);
svcKernelSetState(SVC_KERNEL_STATE_INIT, hiId, loId,
SVC_KERNEL_STATE_TITLE_COMPAT);
if (loId != TID_CTR_NATIVE_FIRM && loId != TID_KTR_NATIVE_FIRM)
nandSector = 0;
svcBackdoor((void *)execReboot);
__builtin_unreachable();
}
__attribute__((__noreturn__)) void abort(void)
{
// TODO: add proper kernel panic
printf("Kernel Panic: aborting!\n");
while (1) { }
__builtin_unreachable();
}
void kernel_main() {
// enter user mode the first time somewhat manually:
scheduler_run(0);
--cpu.nested_isr;
asm volatile ( "jmp isr_to_usermode" );
__builtin_unreachable();
}
static int osrandom_rand_bytes(unsigned char *buffer, int size) {
int len;
int res;
switch(getentropy_works) {
#if defined(__APPLE__)
case CRYPTOGRAPHY_OSRANDOM_GETENTROPY_FALLBACK:
return dev_urandom_read(buffer, size);
#endif
case CRYPTOGRAPHY_OSRANDOM_GETENTROPY_WORKS:
while (size > 0) {
/* OpenBSD and macOS restrict maximum buffer size to 256. */
len = size > 256 ? 256 : size;
res = getentropy(buffer, (size_t)len);
if (res < 0) {
ERR_Cryptography_OSRandom_error(
CRYPTOGRAPHY_OSRANDOM_F_RAND_BYTES,
CRYPTOGRAPHY_OSRANDOM_R_GETENTROPY_FAILED,
__FILE__, __LINE__
);
return 0;
}
buffer += len;
size -= len;
}
return 1;
}
__builtin_unreachable();
}
static size_t
find_next_power_of_two(size_t number)
{
#if HAVE_BUILTIN_CLZLL
static const int size_bits = (int)sizeof(number) * CHAR_BIT;
if (sizeof(size_t) == sizeof(unsigned int)) {
return 1U << (size_bits - __builtin_clz((unsigned int)number));
} else if (sizeof(size_t) == sizeof(unsigned long)) {
return 1UL << (size_bits - __builtin_clzl((unsigned long)number));
} else if (sizeof(size_t) == sizeof(unsigned long long)) {
return 1ULL << (size_bits - __builtin_clzll((unsigned long long)number));
} else {
__builtin_unreachable();
}
#else
number--;
number |= number >> 1;
number |= number >> 2;
number |= number >> 4;
number |= number >> 8;
number |= number >> 16;
return number + 1;
#endif
}
static void check_bootloader(void) {
BootloaderKind kind = get_bootloaderKind();
switch (kind) {
case BLK_v1_0_0:
case BLK_v1_0_1:
case BLK_v1_0_2:
case BLK_v1_0_3:
case BLK_v1_0_3_elf:
case BLK_v1_0_3_sig:
case BLK_v1_0_4:
#ifndef DEBUG_ON
update_bootloader();
#endif
return;
case BLK_UNKNOWN:
#ifndef DEBUG_ON
unknown_bootloader();
#endif
return;
case BLK_v2_0_0:
case BLK_v1_1_0:
return;
}
#ifdef DEBUG_ON
__builtin_unreachable();
#else
unknown_bootloader();
#endif
}
