mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-07-27 04:50:28 +00:00
Make numerous improvements
- Python static hello world now 1.8mb - Python static fully loaded now 10mb - Python HTTPS client now uses MbedTLS - Python REPL now completes import stmts - Increase stack size for Python for now - Begin synthesizing posixpath and ntpath - Restore Python \N{UNICODE NAME} support - Restore Python NFKD symbol normalization - Add optimized code path for Intel SHA-NI - Get more Python unit tests passing faster - Get Python help() pagination working on NT - Python hashlib now supports MbedTLS PBKDF2 - Make memcpy/memmove/memcmp/bcmp/etc. faster - Add Mersenne Twister and Vigna to LIBC_RAND - Provide privileged __printf() for error code - Fix zipos opendir() so that it reports ENOTDIR - Add basic chmod() implementation for Windows NT - Add Cosmo's best functions to Python cosmo module - Pin function trace indent depth to that of caller - Show memory diagram on invalid access in MODE=dbg - Differentiate stack overflow on crash in MODE=dbg - Add stb_truetype and tools for analyzing font files - Upgrade to UNICODE 13 and reduce its binary footprint - COMPILE.COM now logs resource usage of build commands - Start implementing basic poll() support on bare metal - Set getauxval(AT_EXECFN) to GetModuleFileName() on NT - Add descriptions to strerror() in non-TINY build modes - Add COUNTBRANCH() macro to help with micro-optimizations - Make error / backtrace / asan / memory code more unbreakable - Add fast perfect C implementation of μ-Law and a-Law audio codecs - Make strtol() functions consistent with other libc implementations - Improve Linenoise implementation (see also github.com/jart/bestline) - COMPILE.COM now suppresses stdout/stderr of successful build commands
This commit is contained in:
parent
fa7b4f5bd1
commit
39bf41f4eb
806 changed files with 77494 additions and 63859 deletions
|
@ -132,7 +132,7 @@ int main(int argc, char *argv[]) {
|
|||
return 1;
|
||||
}
|
||||
|
||||
memset(&args, 0, sizeof(args));
|
||||
bzero(&args, sizeof(args));
|
||||
for (i = 3; i < argc; ++i) {
|
||||
if (argv[i][0] != '@') {
|
||||
args.p = realloc(args.p, ++args.n * sizeof(*args.p));
|
||||
|
|
|
@ -649,7 +649,7 @@ static void ResolveBreakpoints(void) {
|
|||
|
||||
static void BreakAtNextInstruction(void) {
|
||||
struct Breakpoint b;
|
||||
memset(&b, 0, sizeof(b));
|
||||
bzero(&b, sizeof(b));
|
||||
b.addr = GetIp() + m->xedd->length;
|
||||
b.oneshot = true;
|
||||
PushBreakpoint(&breakpoints, &b);
|
||||
|
@ -754,7 +754,7 @@ static bool IsXmmNonZero(long start, long end) {
|
|||
long i;
|
||||
uint8_t v1[16], vz[16];
|
||||
for (i = start; i < end; ++i) {
|
||||
memset(vz, 0, 16);
|
||||
bzero(vz, 16);
|
||||
memcpy(v1, m->xmm[i], 16);
|
||||
pcmpeqb(v1, v1, vz);
|
||||
if (pmovmskb(v1) != 0xffff) {
|
||||
|
@ -1268,7 +1268,7 @@ static void DrawMemoryZoomed(struct Panel *p, struct MemoryView *view,
|
|||
size = (p->bottom - p->top) * DUMPWIDTH;
|
||||
canvas = xcalloc(1, size);
|
||||
invalid = xcalloc(1, size);
|
||||
memset(&ranges, 0, sizeof(ranges));
|
||||
bzero(&ranges, sizeof(ranges));
|
||||
FindContiguousMemoryRanges(m, &ranges);
|
||||
for (k = i = 0; i < ranges.i; ++i) {
|
||||
if ((a >= ranges.p[i].a && a < ranges.p[i].b) ||
|
||||
|
@ -1279,7 +1279,7 @@ static void DrawMemoryZoomed(struct Panel *p, struct MemoryView *view,
|
|||
n = ROUNDUP(ROUNDUP(d - c, 16), 1ull << view->zoom);
|
||||
chunk = xmalloc(n);
|
||||
VirtualSend(m, chunk, c, d - c);
|
||||
memset(chunk + (d - c), 0, n - (d - c));
|
||||
bzero(chunk + (d - c), n - (d - c));
|
||||
for (j = 0; j < view->zoom; ++j) {
|
||||
cDecimate2xUint8x8(ROUNDUP(n, 16), chunk, kThePerfectKernel);
|
||||
n >>= 1;
|
||||
|
@ -1549,7 +1549,7 @@ static void DrawStatus(struct Panel *p) {
|
|||
a = &m->memstat;
|
||||
b = &lastmemstat;
|
||||
s = xmalloc(sizeof(struct Buffer));
|
||||
memset(s, 0, sizeof(*s));
|
||||
bzero(s, sizeof(*s));
|
||||
if (ips > 0) rw += AppendStat(s, "ips", ips, false);
|
||||
rw += AppendStat(s, "kb", m->real.n / 1024, false);
|
||||
rw += AppendStat(s, "reserve", a->reserved, a->reserved != b->reserved);
|
||||
|
@ -1734,7 +1734,7 @@ static void DrawDisplayOnly(struct Panel *p) {
|
|||
p->lines[i].i = 0;
|
||||
}
|
||||
DrawDisplay(p);
|
||||
memset(&b, 0, sizeof(b));
|
||||
bzero(&b, sizeof(b));
|
||||
tly = tyn / 2 - yn / 2;
|
||||
tlx = txn / 2 - xn / 2;
|
||||
AppendStr(&b, "\e[0m\e[H");
|
||||
|
@ -1769,7 +1769,7 @@ static int OnPtyFdTiocgwinsz(int fd, struct winsize *ws) {
|
|||
}
|
||||
|
||||
static int OnPtyFdTcgets(int fd, struct termios *c) {
|
||||
memset(c, 0, sizeof(*c));
|
||||
bzero(c, sizeof(*c));
|
||||
if (!(pty->conf & kPtyNocanon)) c->c_iflag |= ICANON;
|
||||
if (!(pty->conf & kPtyNoecho)) c->c_iflag |= ECHO;
|
||||
if (!(pty->conf & kPtyNoopost)) c->c_oflag |= OPOST;
|
||||
|
@ -2456,7 +2456,7 @@ static void OnHelp(void) {
|
|||
|
||||
static void ReadKeyboard(void) {
|
||||
char buf[64], *p = buf;
|
||||
memset(buf, 0, sizeof(buf));
|
||||
bzero(buf, sizeof(buf));
|
||||
dialog = NULL;
|
||||
if (readansi(ttyin, buf, sizeof(buf)) == -1) {
|
||||
if (errno == EINTR) {
|
||||
|
@ -2544,7 +2544,7 @@ static int64_t ParseHexValue(const char *s) {
|
|||
|
||||
static void HandleBreakpointFlag(const char *s) {
|
||||
struct Breakpoint b;
|
||||
memset(&b, 0, sizeof(b));
|
||||
bzero(&b, sizeof(b));
|
||||
if (isdigit(*s)) {
|
||||
b.addr = ParseHexValue(s);
|
||||
} else {
|
||||
|
@ -2764,6 +2764,7 @@ static void GetOpts(int argc, char *argv[]) {
|
|||
react = true;
|
||||
break;
|
||||
case 'r':
|
||||
m->ismetal = true;
|
||||
m->mode = XED_MACHINE_MODE_REAL;
|
||||
g_disisprog_disable = true;
|
||||
break;
|
||||
|
@ -2774,7 +2775,7 @@ static void GetOpts(int argc, char *argv[]) {
|
|||
HandleBreakpointFlag(optarg);
|
||||
break;
|
||||
case 'H':
|
||||
memset(&g_high, 0, sizeof(g_high));
|
||||
bzero(&g_high, sizeof(g_high));
|
||||
break;
|
||||
case 'v':
|
||||
++__log_level;
|
||||
|
|
|
@ -498,7 +498,7 @@ void AppendByte(struct Bytes *a, char b) {
|
|||
void AppendHistory(void) {
|
||||
struct Bytes line;
|
||||
if (interactive) {
|
||||
memset(&line, 0, sizeof(line));
|
||||
bzero(&line, sizeof(line));
|
||||
APPEND(&history.p, &history.i, &history.n, &line);
|
||||
}
|
||||
}
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -46,5 +46,4 @@ void LoadDebugSymbols(struct Elf *elf) {
|
|||
}
|
||||
close(fd);
|
||||
}
|
||||
fprintf(stderr, "got here\n");
|
||||
}
|
||||
|
|
|
@ -273,7 +273,7 @@ void DisFreeOps(struct DisOps *ops) {
|
|||
DisFreeOp(&ops->p[i]);
|
||||
}
|
||||
free(ops->p);
|
||||
memset(ops, 0, sizeof(*ops));
|
||||
bzero(ops, sizeof(*ops));
|
||||
}
|
||||
|
||||
void DisFree(struct Dis *d) {
|
||||
|
@ -282,5 +282,5 @@ void DisFree(struct Dis *d) {
|
|||
free(d->edges.p);
|
||||
free(d->loads.p);
|
||||
free(d->syms.p);
|
||||
memset(d, 0, sizeof(*d));
|
||||
bzero(d, sizeof(*d));
|
||||
}
|
||||
|
|
|
@ -966,7 +966,7 @@ static void OpFrstor(struct Machine *m) {
|
|||
a = Load(m, m->fpu.dp, sizeof(b), b);
|
||||
GetFpuEnv(m, a);
|
||||
for (i = 0; i < 8; ++i) {
|
||||
memset(&x, 0, sizeof(x));
|
||||
bzero(&x, sizeof(x));
|
||||
memcpy(&x, a + 28 + i * 10, 10);
|
||||
*FpuSt(m, i) = x;
|
||||
}
|
||||
|
|
|
@ -44,12 +44,12 @@ static void DeleteLastEmptyLine(char *p, size_t n) {
|
|||
|
||||
static void AppendLine(struct Lines *lines) {
|
||||
lines->p = realloc(lines->p, ++lines->n * sizeof(*lines->p));
|
||||
memset(lines->p + lines->n - 1, 0, sizeof(*lines->p));
|
||||
bzero(lines->p + lines->n - 1, sizeof(*lines->p));
|
||||
}
|
||||
|
||||
static void AppendTag(struct JavadownTags *tags) {
|
||||
tags->p = realloc(tags->p, ++tags->n * sizeof(*tags->p));
|
||||
memset(tags->p + tags->n - 1, 0, sizeof(*tags->p));
|
||||
bzero(tags->p + tags->n - 1, sizeof(*tags->p));
|
||||
}
|
||||
|
||||
static unsigned GetSpacePrefixLen(const char *p, size_t n) {
|
||||
|
@ -247,7 +247,7 @@ struct Javadown *ParseJavadown(const char *data, size_t size) {
|
|||
char *p;
|
||||
struct Lines lines;
|
||||
struct Javadown *jd;
|
||||
memset(&lines, 0, sizeof(lines));
|
||||
bzero(&lines, sizeof(lines));
|
||||
jd = calloc(1, sizeof(struct Javadown));
|
||||
p = strndup(data, size);
|
||||
SplitLines(&lines, p);
|
||||
|
|
|
@ -112,7 +112,7 @@ static void BootProgram(struct Machine *m, struct Elf *elf, size_t codesize) {
|
|||
m->ip = 0x7c00;
|
||||
elf->base = 0x7c00;
|
||||
CHECK_NE(-1, ReserveReal(m, 0x00f00000));
|
||||
memset(m->real.p, 0, 0x00f00000);
|
||||
bzero(m->real.p, 0x00f00000);
|
||||
Write16(m->real.p + 0x400, 0x3F8);
|
||||
Write16(m->real.p + 0x40E, 0xb0000 >> 4);
|
||||
Write16(m->real.p + 0x413, 0xb0000 / 1024);
|
||||
|
|
|
@ -1454,7 +1454,7 @@ static void OpDoubleShift(struct Machine *m, uint32_t rde) {
|
|||
static void OpFxsave(struct Machine *m, uint32_t rde) {
|
||||
int64_t v;
|
||||
uint8_t buf[32];
|
||||
memset(buf, 0, 32);
|
||||
bzero(buf, 32);
|
||||
Write16(buf + 0, m->fpu.cw);
|
||||
Write16(buf + 2, m->fpu.sw);
|
||||
Write8(buf + 4, m->fpu.tw);
|
||||
|
|
|
@ -160,6 +160,7 @@ struct Machine {
|
|||
jmp_buf onhalt;
|
||||
int64_t faultaddr;
|
||||
bool dlab;
|
||||
bool ismetal;
|
||||
struct MachineFds fds;
|
||||
uint8_t stash[4096];
|
||||
uint8_t icache[1024][40];
|
||||
|
|
|
@ -58,7 +58,7 @@ void FreeMachine(struct Machine *m) {
|
|||
void ResetMem(struct Machine *m) {
|
||||
FreeMachineRealFree(m);
|
||||
ResetTlb(m);
|
||||
memset(&m->memstat, 0, sizeof(m->memstat));
|
||||
bzero(&m->memstat, sizeof(m->memstat));
|
||||
m->real.i = 0;
|
||||
m->cr3 = 0;
|
||||
}
|
||||
|
@ -66,7 +66,7 @@ void ResetMem(struct Machine *m) {
|
|||
long AllocateLinearPage(struct Machine *m) {
|
||||
long page;
|
||||
if ((page = AllocateLinearPageRaw(m)) != -1) {
|
||||
memset(m->real.p + page, 0, 0x1000);
|
||||
bzero(m->real.p + page, 0x1000);
|
||||
}
|
||||
return page;
|
||||
}
|
||||
|
|
|
@ -45,7 +45,7 @@ void PrintMessageBox(int fd, const char *msg, long tyn, long txn) {
|
|||
w = 4 + GetWidthOfLongestLine(lines) + 4;
|
||||
x = lrint(txn / 2. - w / 2.);
|
||||
y = lrint(tyn / 2. - h / 2.);
|
||||
memset(&b, 0, sizeof(b));
|
||||
bzero(&b, sizeof(b));
|
||||
AppendFmt(&b, "\e[%d;%dH", y++, x);
|
||||
for (i = 0; i < w; ++i) AppendStr(&b, " ");
|
||||
AppendFmt(&b, "\e[%d;%dH ╔", y++, x);
|
||||
|
|
|
@ -45,7 +45,7 @@ ssize_t PrintPanels(int fd, long pn, struct Panel *p, long tyn, long txn) {
|
|||
struct Buffer b, *l;
|
||||
int x, y, i, j, width;
|
||||
enum { kUtf8, kAnsi, kAnsiCsi } state;
|
||||
memset(&b, 0, sizeof(b));
|
||||
bzero(&b, sizeof(b));
|
||||
AppendStr(&b, "\e[H");
|
||||
for (y = 0; y < tyn; ++y) {
|
||||
if (y) AppendStr(&b, "\r\n");
|
||||
|
|
|
@ -41,14 +41,14 @@
|
|||
*
|
||||
* \t TAB
|
||||
* \a BELL
|
||||
* \177 BACKSPACE
|
||||
* \r CURSOR START
|
||||
* \b CURSOR LEFT
|
||||
* \177 CURSOR LEFT
|
||||
* \b CURSOR LEFT OR CURSOR REWIND
|
||||
* \n CURSOR DOWN AND START IF OPOST
|
||||
* \f CURSOR DOWN AND START IF OPOST
|
||||
* \v CURSOR DOWN AND START IF OPOST
|
||||
* \eD CURSOR DOWN AND START
|
||||
* \eE CURSOR DOWN
|
||||
* \v CURSOR DOWN AND START OR \e[H\e[J
|
||||
* \eE CURSOR DOWN AND START
|
||||
* \eD CURSOR DOWN
|
||||
* \eM CURSOR UP
|
||||
* \ec FULL RESET
|
||||
* \e7 SAVE CURSOR POSITION
|
||||
|
@ -331,7 +331,7 @@ static void PtySetCodepage(struct Pty *pty, char id) {
|
|||
void PtyErase(struct Pty *pty, long dst, long n) {
|
||||
DCHECK_LE(dst + n, pty->yn * pty->xn);
|
||||
wmemset((void *)(pty->wcs + dst), ' ', n);
|
||||
wmemset((void *)(pty->prs + dst), 0, n);
|
||||
bzero((void *)(pty->prs + dst), n);
|
||||
}
|
||||
|
||||
void PtyMemmove(struct Pty *pty, long dst, long src, long n) {
|
||||
|
@ -729,7 +729,7 @@ static void PtySelectGraphicsRendition(struct Pty *pty) {
|
|||
x = 0;
|
||||
t = kSgr;
|
||||
p = pty->esc.s;
|
||||
memset(code, 0, sizeof(code));
|
||||
bzero(code, sizeof(code));
|
||||
for (;;) {
|
||||
c = *p++;
|
||||
switch (c) {
|
||||
|
|
|
@ -58,7 +58,7 @@ static void ResetSse(struct Machine *m) {
|
|||
m->sse.pm = true;
|
||||
m->sse.rc = RINT;
|
||||
m->sse.ftz = false;
|
||||
memset(m->xmm, 0, sizeof(m->xmm));
|
||||
bzero(m->xmm, sizeof(m->xmm));
|
||||
}
|
||||
|
||||
void ResetInstructionCache(struct Machine *m) {
|
||||
|
@ -81,16 +81,16 @@ void ResetCpu(struct Machine *m) {
|
|||
m->flags = SetFlag(m->flags, FLAGS_F1, true);
|
||||
m->flags = SetFlag(m->flags, FLAGS_F0, false);
|
||||
m->flags = SetFlag(m->flags, FLAGS_IOPL, 3);
|
||||
memset(m->reg, 0, sizeof(m->reg));
|
||||
memset(m->bofram, 0, sizeof(m->bofram));
|
||||
memset(&m->freelist, 0, sizeof(m->freelist));
|
||||
bzero(m->reg, sizeof(m->reg));
|
||||
bzero(m->bofram, sizeof(m->bofram));
|
||||
bzero(&m->freelist, sizeof(m->freelist));
|
||||
ResetSse(m);
|
||||
ResetFpu(m);
|
||||
}
|
||||
|
||||
void ResetTlb(struct Machine *m) {
|
||||
m->tlbindex = 0;
|
||||
memset(m->tlb, 0, sizeof(m->tlb));
|
||||
bzero(m->tlb, sizeof(m->tlb));
|
||||
m->codevirt = 0;
|
||||
m->codehost = 0;
|
||||
}
|
||||
|
|
|
@ -779,7 +779,7 @@ static void OpSsePalignrMmx(struct Machine *m, uint32_t rde) {
|
|||
char t[24];
|
||||
memcpy(t, GetModrmRegisterXmmPointerRead8(m, rde), 8);
|
||||
memcpy(t + 8, XmmRexrReg(m, rde), 8);
|
||||
memset(t + 16, 0, 8);
|
||||
bzero(t + 16, 8);
|
||||
memcpy(XmmRexrReg(m, rde), t + MIN(m->xedd->op.uimm0, 16), 8);
|
||||
}
|
||||
|
||||
|
|
|
@ -141,6 +141,13 @@ void OpPopZvq(struct Machine *m, uint32_t rde) {
|
|||
}
|
||||
|
||||
static void OpCall(struct Machine *m, uint32_t rde, uint64_t func) {
|
||||
if (!func) {
|
||||
/*
|
||||
* call null is technically possible but too fringe and disasterous
|
||||
* to accommodate at least until our debugger has rewind capability
|
||||
*/
|
||||
HaltMachine(m, kMachineProtectionFault);
|
||||
}
|
||||
Push(m, rde, m->ip);
|
||||
m->ip = func;
|
||||
}
|
||||
|
|
|
@ -470,7 +470,7 @@ static int AppendIovsGuest(struct Machine *m, struct Iovs *iv, int64_t iovaddr,
|
|||
static struct sigaction *CoerceSigactionToCosmo(
|
||||
struct sigaction *dst, const struct sigaction_linux *src) {
|
||||
if (!src) return NULL;
|
||||
memset(dst, 0, sizeof(*dst));
|
||||
bzero(dst, sizeof(*dst));
|
||||
ASSIGN(dst->sa_handler, src->sa_handler);
|
||||
ASSIGN(dst->sa_restorer, src->sa_restorer);
|
||||
ASSIGN(dst->sa_flags, src->sa_flags);
|
||||
|
@ -481,7 +481,7 @@ static struct sigaction *CoerceSigactionToCosmo(
|
|||
static struct sigaction_linux *CoerceSigactionToLinux(
|
||||
struct sigaction_linux *dst, const struct sigaction *src) {
|
||||
if (!dst) return NULL;
|
||||
memset(dst, 0, sizeof(*dst));
|
||||
bzero(dst, sizeof(*dst));
|
||||
ASSIGN(dst->sa_handler, src->sa_handler);
|
||||
ASSIGN(dst->sa_restorer, src->sa_restorer);
|
||||
ASSIGN(dst->sa_flags, src->sa_flags);
|
||||
|
@ -1179,7 +1179,7 @@ static int OpSigsuspend(struct Machine *m, int64_t maskaddr) {
|
|||
void *p;
|
||||
sigset_t mask;
|
||||
if (!(p = LoadBuf(m, maskaddr, 8))) return efault();
|
||||
memset(&mask, 0, sizeof(mask));
|
||||
bzero(&mask, sizeof(mask));
|
||||
memcpy(&mask, p, 8);
|
||||
return sigsuspend(&mask);
|
||||
}
|
||||
|
@ -1246,7 +1246,7 @@ static int OpSigprocmask(struct Machine *m, int how, int64_t setaddr,
|
|||
sigset_t *set, oldset, ss;
|
||||
if (setaddr) {
|
||||
set = &ss;
|
||||
memset(set, 0, sizeof(ss));
|
||||
bzero(set, sizeof(ss));
|
||||
VirtualSendRead(m, set, setaddr, 8);
|
||||
} else {
|
||||
set = NULL;
|
||||
|
@ -1326,6 +1326,9 @@ static int DoAccept(struct Machine *m, int fd, int64_t addraddr,
|
|||
void OpSyscall(struct Machine *m, uint32_t rde) {
|
||||
uint64_t i, ax, di, si, dx, r0, r8, r9;
|
||||
ax = Read64(m->ax);
|
||||
if (m->ismetal) {
|
||||
WARNF("metal syscall 0x%03x", ax);
|
||||
}
|
||||
di = Read64(m->di);
|
||||
si = Read64(m->si);
|
||||
dx = Read64(m->dx);
|
||||
|
@ -1440,7 +1443,7 @@ void OpSyscall(struct Machine *m, uint32_t rde) {
|
|||
SYSCALL(0x177, vmsplice(di, P(si), dx, r0));
|
||||
CASE(0xE7, HaltMachine(m, di | 0x100));
|
||||
default:
|
||||
VERBOSEF("missing syscall 0x%03x", ax);
|
||||
WARNF("missing syscall 0x%03x", ax);
|
||||
ax = enosys();
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -28,7 +28,7 @@
|
|||
|
||||
static bool IsHaltingInitialized(struct Machine *m) {
|
||||
jmp_buf zb;
|
||||
memset(zb, 0, sizeof(zb));
|
||||
bzero(zb, sizeof(zb));
|
||||
return memcmp(m->onhalt, zb, sizeof(m->onhalt)) != 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -18,7 +18,6 @@
|
|||
╚─────────────────────────────────────────────────────────────────────────────*/
|
||||
#include "libc/errno.h"
|
||||
#include "libc/mem/mem.h"
|
||||
#include "libc/runtime/carsort.h"
|
||||
#include "tool/build/lib/xlaterrno.h"
|
||||
|
||||
struct thatispacked LinuxErrno {
|
||||
|
|
|
@ -161,7 +161,7 @@ int main(int argc, char *argv[]) {
|
|||
unsigned char ch = data[i];
|
||||
if (col == 0) {
|
||||
fprintf(fout, "\t.byte\t");
|
||||
memset(glyphs, 0, sizeof(glyphs));
|
||||
bzero(glyphs, sizeof(glyphs));
|
||||
}
|
||||
/* TODO(jart): Fix Emacs */
|
||||
glyphs[col] = kCp437[ch == '"' || ch == '#' ? '.' : ch];
|
||||
|
|
|
@ -178,7 +178,7 @@ unsigned GetSourceId(const char *name, size_t len) {
|
|||
do {
|
||||
i = (hash + step * (step + 1) / 2) & (sources.n - 1);
|
||||
if (sources.p[i].hash == hash &&
|
||||
memcmp(name, &strings.p[sources.p[i].name], len) == 0) {
|
||||
!timingsafe_bcmp(name, &strings.p[sources.p[i].name], len)) {
|
||||
return sources.p[i].id;
|
||||
}
|
||||
step++;
|
||||
|
@ -252,7 +252,7 @@ void LoadRelationships(int argc, char *argv[]) {
|
|||
CHECK_NE(-1, (rc = read(fd, buf, MAX_READ)));
|
||||
close(fd);
|
||||
size = rc;
|
||||
memset(buf + size, 0, 16);
|
||||
bzero(buf + size, 16);
|
||||
for (p = buf, pe = p + size; p < pe; ++p) {
|
||||
p = strstr(p, kIncludePrefix);
|
||||
if (!p) break;
|
||||
|
@ -385,7 +385,7 @@ int main(int argc, char *argv[]) {
|
|||
needprefix = !startswith(path, "o/");
|
||||
prefix = !needprefix ? "" : buildroot;
|
||||
fprintf(fout, "\n%s%s.o: \\\n\t%s", prefix, StripExt(path), path);
|
||||
memset(visited, 0, bitmaplen);
|
||||
bzero(visited, bitmaplen);
|
||||
bts(visited, i);
|
||||
Dive(i);
|
||||
fprintf(fout, "\n");
|
||||
|
|
|
@ -266,7 +266,7 @@ void IndexSections(struct Object *obj) {
|
|||
const Elf64_Shdr *shdr;
|
||||
struct XedDecodedInst xedd;
|
||||
for (i = 0; i < obj->elf->e_shnum; ++i) {
|
||||
memset(§, 0, sizeof(sect));
|
||||
bzero(§, sizeof(sect));
|
||||
CHECK_NOTNULL((shdr = GetElfSectionHeaderAddress(obj->elf, obj->size, i)));
|
||||
if (shdr->sh_type != SHT_NULL) {
|
||||
CHECK_NOTNULL((name = GetElfSectionName(obj->elf, obj->size, shdr)));
|
||||
|
@ -450,7 +450,7 @@ void CheckStrictDeps(struct Package *pkg, struct Packages *deps) {
|
|||
}
|
||||
}
|
||||
free(pkg->undefs.p);
|
||||
memset(&pkg->undefs, 0, sizeof(pkg->undefs));
|
||||
bzero(&pkg->undefs, sizeof(pkg->undefs));
|
||||
}
|
||||
|
||||
forceinline bool IsRipRelativeModrm(uint8_t modrm) {
|
||||
|
@ -609,7 +609,7 @@ void CompressLowEntropyReadOnlyDataSections(struct Package *pkg,
|
|||
Elf64_Shdr *shdr;
|
||||
struct RlEncoder rle;
|
||||
bool haverldecode, isprofitable;
|
||||
memset(&rle, 0, sizeof(rle));
|
||||
bzero(&rle, sizeof(rle));
|
||||
haverldecode = IsSymbolDirectlyReachable(pkg, deps, "rldecode");
|
||||
for (i = 0; i < obj->elf->e_shnum; ++i) {
|
||||
if ((shdr = GetElfSectionHeaderAddress(obj->elf, obj->size, i)) &&
|
||||
|
@ -625,7 +625,8 @@ void CompressLowEntropyReadOnlyDataSections(struct Package *pkg,
|
|||
INFOF("%s(%s): rlencode()%s on %s is%s profitable (%,zu → %,zu bytes)",
|
||||
&pkg->strings.p[pkg->path], &pkg->strings.p[obj->path],
|
||||
haverldecode ? "" : " [NOT LINKED]", name,
|
||||
isprofitable ? "" : " NOT", shdr->sh_size, rle.i * sizeof(rle.p[0]));
|
||||
isprofitable ? "" : " NOT", shdr->sh_size,
|
||||
rle.i * sizeof(rle.p[0]));
|
||||
}
|
||||
}
|
||||
free(rle.p);
|
||||
|
@ -681,8 +682,8 @@ int main(int argc, char *argv[]) {
|
|||
struct Packages deps;
|
||||
if (argc == 2 && !strcmp(argv[1], "-n")) exit(0);
|
||||
showcrashreports();
|
||||
memset(&pkg, 0, sizeof(pkg));
|
||||
memset(&deps, 0, sizeof(deps));
|
||||
bzero(&pkg, sizeof(pkg));
|
||||
bzero(&deps, sizeof(deps));
|
||||
Package(argc, argv, &pkg, &deps);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -80,7 +80,7 @@
|
|||
L.c += L.c >> 1; \
|
||||
L.p = realloc(L.p, L.c * sizeof(*L.p)); \
|
||||
} \
|
||||
memset(L.p + L.n - 1, 0, sizeof(*L.p)); \
|
||||
bzero(L.p + L.n - 1, sizeof(*L.p)); \
|
||||
} while (0)
|
||||
|
||||
struct Trace {
|
||||
|
@ -705,7 +705,7 @@ static void Parse(struct Trace *t, const char *line, long lineno) {
|
|||
}
|
||||
CHECK_LT((arg = t->events.p[event].arity++), 6);
|
||||
if (isalpha(*p) && !startswith(p, "NULL")) {
|
||||
memset(&b, 0, sizeof(b));
|
||||
bzero(&b, sizeof(b));
|
||||
for (; isalpha(*p) || *p == '_'; ++p) {
|
||||
AppendSlice(&b, *p);
|
||||
}
|
||||
|
@ -732,7 +732,7 @@ static void Parse(struct Trace *t, const char *line, long lineno) {
|
|||
CHECK_NOTNULL((p = strchr(p, '}')), DEBUG);
|
||||
++p;
|
||||
} else if (*p == '"') {
|
||||
memset(&b, 0, sizeof(b));
|
||||
bzero(&b, sizeof(b));
|
||||
for (j = 0; (c = p[++j]);) {
|
||||
if (c == '"') {
|
||||
p += j + 1;
|
||||
|
@ -762,7 +762,7 @@ static void Parse(struct Trace *t, const char *line, long lineno) {
|
|||
if (*p == ',') ++p;
|
||||
if (*p == ' ') ++p;
|
||||
CHECK_EQ('"', *p, DEBUG);
|
||||
memset(&b, 0, sizeof(b));
|
||||
bzero(&b, sizeof(b));
|
||||
for (k = 0; (c = p[++k]);) {
|
||||
if (c == '"') {
|
||||
p += k + 1;
|
||||
|
|
|
@ -148,7 +148,9 @@ int RunLengthEncode1(void) {
|
|||
return feof(fin_) ? 0 : -1;
|
||||
}
|
||||
|
||||
int RunLengthEncode2(void) { return fputc(0, fout_) | fputc(0, fout_); }
|
||||
int RunLengthEncode2(void) {
|
||||
return fputc(0, fout_) | fputc(0, fout_);
|
||||
}
|
||||
|
||||
int EmitRun(unsigned char count, unsigned char byte) {
|
||||
do {
|
||||
|
|
|
@ -349,7 +349,7 @@ int ReadResponse(void) {
|
|||
unsigned char b[512];
|
||||
for (res = -1; res == -1;) {
|
||||
if (!Recv(b, 5)) break;
|
||||
CHECK_EQ(RUNITD_MAGIC, READ32BE(b));
|
||||
CHECK_EQ(RUNITD_MAGIC, READ32BE(b), "%#.5s", b);
|
||||
switch (b[4]) {
|
||||
case kRunitExit:
|
||||
if (!Recv(b, 1)) break;
|
||||
|
|
|
@ -215,12 +215,12 @@ void StartTcpServer(void) {
|
|||
|
||||
void SendExitMessage(int rc) {
|
||||
unsigned char msg[4 + 1 + 1];
|
||||
msg[0 + 0] = (unsigned char)((unsigned)RUNITD_MAGIC >> 030);
|
||||
msg[0 + 1] = (unsigned char)((unsigned)RUNITD_MAGIC >> 020);
|
||||
msg[0 + 2] = (unsigned char)((unsigned)RUNITD_MAGIC >> 010);
|
||||
msg[0 + 3] = (unsigned char)((unsigned)RUNITD_MAGIC >> 000);
|
||||
msg[0 + 0] = (RUNITD_MAGIC & 0xff000000) >> 030;
|
||||
msg[0 + 1] = (RUNITD_MAGIC & 0x00ff0000) >> 020;
|
||||
msg[0 + 2] = (RUNITD_MAGIC & 0x0000ff00) >> 010;
|
||||
msg[0 + 3] = (RUNITD_MAGIC & 0x000000ff) >> 000;
|
||||
msg[4] = kRunitExit;
|
||||
msg[5] = (unsigned char)rc;
|
||||
msg[5] = rc;
|
||||
CHECK_EQ(sizeof(msg), mbedtls_ssl_write(&ezssl, msg, sizeof(msg)));
|
||||
CHECK_EQ(0, EzTlsFlush(&ezbio, 0, 0));
|
||||
}
|
||||
|
@ -230,15 +230,15 @@ void SendOutputFragmentMessage(enum RunitCommand kind, unsigned char *buf,
|
|||
ssize_t rc;
|
||||
size_t sent;
|
||||
unsigned char msg[4 + 1 + 4];
|
||||
msg[0 + 0] = (unsigned char)((unsigned)RUNITD_MAGIC >> 030);
|
||||
msg[0 + 1] = (unsigned char)((unsigned)RUNITD_MAGIC >> 020);
|
||||
msg[0 + 2] = (unsigned char)((unsigned)RUNITD_MAGIC >> 010);
|
||||
msg[0 + 3] = (unsigned char)((unsigned)RUNITD_MAGIC >> 000);
|
||||
msg[0 + 0] = (RUNITD_MAGIC & 0xff000000) >> 030;
|
||||
msg[0 + 1] = (RUNITD_MAGIC & 0x00ff0000) >> 020;
|
||||
msg[0 + 2] = (RUNITD_MAGIC & 0x0000ff00) >> 010;
|
||||
msg[0 + 3] = (RUNITD_MAGIC & 0x000000ff) >> 000;
|
||||
msg[4 + 0] = kind;
|
||||
msg[5 + 0] = (unsigned char)((unsigned)size >> 030);
|
||||
msg[5 + 1] = (unsigned char)((unsigned)size >> 020);
|
||||
msg[5 + 2] = (unsigned char)((unsigned)size >> 010);
|
||||
msg[5 + 3] = (unsigned char)((unsigned)size >> 000);
|
||||
msg[5 + 0] = (size & 0xff000000) >> 030;
|
||||
msg[5 + 1] = (size & 0x00ff0000) >> 020;
|
||||
msg[5 + 2] = (size & 0x0000ff00) >> 010;
|
||||
msg[5 + 3] = (size & 0x000000ff) >> 000;
|
||||
CHECK_EQ(sizeof(msg), mbedtls_ssl_write(&ezssl, msg, sizeof(msg)));
|
||||
while (size) {
|
||||
CHECK_NE(-1, (rc = mbedtls_ssl_write(&ezssl, buf, size)));
|
||||
|
|
|
@ -45,6 +45,7 @@ bool basenamify_;
|
|||
int64_t image_base_;
|
||||
int strip_components_;
|
||||
const char *path_prefix_;
|
||||
struct timespec timestamp;
|
||||
|
||||
wontreturn void PrintUsage(int rc, FILE *f) {
|
||||
fprintf(f, "%s%s%s\n", "Usage: ", program_invocation_name,
|
||||
|
@ -106,7 +107,6 @@ void ProcessFile(struct ElfWriter *elf, const char *path) {
|
|||
size_t pathlen;
|
||||
struct stat st;
|
||||
const char *name;
|
||||
struct timespec timestamp;
|
||||
CHECK_NE(-1, (fd = open(path, O_RDONLY)));
|
||||
CHECK_NE(-1, fstat(fd, &st));
|
||||
if (S_ISDIR(st.st_mode)) {
|
||||
|
@ -127,11 +127,11 @@ void ProcessFile(struct ElfWriter *elf, const char *path) {
|
|||
if (path_prefix_) name = gc(xjoinpaths(path_prefix_, name));
|
||||
}
|
||||
if (S_ISDIR(st.st_mode)) {
|
||||
st.st_size = 0;
|
||||
if (!endswith(name, "/")) {
|
||||
name = gc(xasprintf("%s/", name));
|
||||
}
|
||||
}
|
||||
memset(×tamp, 0, sizeof(timestamp));
|
||||
elfwriter_zip(elf, name, name, strlen(name), map, st.st_size, st.st_mode,
|
||||
timestamp, timestamp, timestamp, nocompress_, image_base_);
|
||||
if (st.st_size) CHECK_NE(-1, munmap(map, st.st_size));
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue