name string | code string | asm string | file string |
|---|---|---|---|
PaAlsaStreamComponent_GetAvailableFrames | static PaError PaAlsaStreamComponent_GetAvailableFrames( PaAlsaStreamComponent *self, unsigned long *numFrames, int *xrunOccurred )
{
PaError result = paNoError;
snd_pcm_sframes_t framesAvail = alsa_snd_pcm_avail_update( self->pcm );
*xrunOccurred = 0;
if( -EPIPE == framesAvail )
{
*xrunOcc... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq 0x38(%rdi), %rdi
callq 0x6140
andl $0x0, (%r15)
cmpq $-0x20, %rax
jne 0xe622
movl $0x1, (%r15)
xorl %ebx, %ebx
jmp 0xe629
movq %rax, %rbx
testl %ebx, %ebx
js 0xe634
movq %rbx, (%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x6400
lea... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
Float32_To_Int32_Dither | static void Float32_To_Int32_Dither(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
float *src = (float*)sourceBuffer;
PaInt32 *dest = (PaInt32*)destinationBuffer;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movq %rdx, %r14
movq %rdi, %r15
movslq %ecx, %r12
movslq %esi, %r13
shlq $0x2, %r13
shlq $0x2, %r12
subl $0x1, %ebp
jb 0xf174
movq %rbx, %rdi
callq 0xfff1
cvtss2sd %xmm0, %xmm0
cvtss2sd (%r14), %xmm1
mulsd 0xf297... | /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Float32_To_Int32_Clip | static void Float32_To_Int32_Clip(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
float *src = (float*)sourceBuffer;
PaInt32 *dest = (PaInt32*)destinationBuffer;
... | movslq %ecx, %rax
movslq %esi, %rcx
shlq $0x2, %rax
shlq $0x2, %rcx
movss 0xf237(%rip), %xmm0 # 0x1e3d0
movss 0xf233(%rip), %xmm1 # 0x1e3d4
movsd 0xf257(%rip), %xmm2 # 0x1e400
subl $0x1, %r8d
jb 0xf1db
movss (%rdx), %xmm3
mulss %xmm0, %xmm3
movl $0x80000000, %esi # imm = 0x80000000
ucomiss %xmm3, %xmm... | /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Float32_To_Int24 | static void Float32_To_Int24(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
float *src = (float*)sourceBuffer;
unsigned char *dest = (unsigned char*)destinationBuffer... | pushq %rbx
movslq %ecx, %rax
leal (%rsi,%rsi,2), %ecx
movslq %ecx, %rcx
addq $0x2, %rdi
shlq $0x2, %rax
movsd 0xf186(%rip), %xmm0 # 0x1e400
subl $0x1, %r8d
jb 0xf2a5
cvtss2sd (%rdx), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %ebx
movb %bh, -0x2(%rdi)
movl %ebx, %esi
shrl $0x10, %esi
movb %sil, -0x1(%rdi)
shrl $0x18... | /syb0rg[P]PortAudio2/src/common/pa_converters.c |
main | int main(int argc, char **argv) {
struct option_data data;
clock_t t1, t2;
FILE *file = stdin;
lanli_buffer *ib, *ob;
lanli_callback callback = NULL;
void *opaque = NULL;
lanli_document *document;
/* Parse options */
data.basename = argv[0];
data.done = 0;
data.show_time = 0;
data.iunit = DEF_I... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edi, %r13d
movq %rsi, 0x88(%rsp)
movq (%rsi), %rax
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
andq $0x0, 0x8(%rcx)
movq $0x400, 0x10(%rcx) # imm = 0x400
movq $0x40, 0x18(%rcx)
andq $0x0, 0x20(%rcx)
movq 0x2d11(%rip), %rax # ... | /hoedown[P]lanli/bin/lanli.c |
main | int main(int argc, char **argv) {
int i;
int first = 1; // 标记是否是第一帧pcm
float x[FRAME_SIZE];
FILE *f1, *fout;
DenoiseState *st;
st = rnnoise_create(NULL);
if (argc != 3) {
fprintf(stderr, "usage: %s <noisy speech> <output denoised>\n", argv[0]);
return 1;
}
f1 = fopen(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb48, %rsp # imm = 0xB48
movq %rsi, %r15
movl %edi, %ebp
xorl %edi, %edi
callq 0x50a9
cmpl $0x3, %ebp
jne 0x13b1
movq %rax, %rbx
movq 0x8(%r15), %rdi
leaq 0x4d90(%rip), %rsi # 0x6030
callq 0x1100
movq %rax, %r14
movq 0x10(%r15), %r... | /PandoraLS[P]rnnoise_toys/examples/rnnoise_demo.c |
celt_iir | void celt_iir(const opus_val32 *_x,
const opus_val16 *den,
opus_val32 *_y,
int N,
int ord,
opus_val16 *mem) {
#ifdef SMALL_FOOTPRINT
int i,j;
for (i=0;i<N;i++)
{
opus_val32 sum = _x[i];
for (j=0;j<ord;j++)
{
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %rbx
movl %r8d, %r13d
movq %rsp, %r12
leaq 0xf(,%r13,4), %rax
andq $-0x10, %rax
subq %rax, %r12
movq %r12, %rsp
leal (%r8,%r14), %eax
leaq 0xf(,%rax,4), %rcx
andq $-0x10, %rcx
m... | /PandoraLS[P]rnnoise_toys/src/celt_lpc.c |
opus_ifft_c | void opus_ifft_c(const kiss_fft_state *st, const kiss_fft_cpx *fin, kiss_fft_cpx *fout) {
int i;
celt_assert2 (fin != fout, "In-place FFT not supported");
/* Bit-reverse the input */
for (i = 0; i < st->nfft; i++)
fout[st->bitrev[i]] = fin[i];
for (i = 0; i < st->nfft; i++)
fout[i].i... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x0, (%rdi)
jle 0x2792
xorl %ecx, %ecx
movq 0x30(%r14), %rax
movswq (%rax,%rcx,2), %rax
movq (%rsi,%rcx,8), %rdx
movq %rdx, (%rbx,%rax,8)
incq %rcx
movslq (%r14), %rax
cmpq %rax, %rcx
jl 0x2752
testl %eax, %eax
jle 0x2792
xorl %ecx, %ecx
movaps 0x38... | /PandoraLS[P]rnnoise_toys/src/kiss_fft.c |
compute_rnn | void compute_rnn(RNNState *rnn, float *gains, float *vad, const float *input) {
int i;
float dense_out[MAX_NEURONS];
float noise_input[MAX_NEURONS * 3];
float denoise_input[MAX_NEURONS * 3];
// 获得 vad output
compute_dense(rnn->model->input_dense, dense_out, input);
compute_gru(rnn->model->v... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe08, %rsp # imm = 0xE08
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rbp
movq 0x8(%rbp), %rdi
movq %rsp, %r13
movq %r13, %rsi
movq %rcx, %rdx
callq 0x33fc
movq 0x18(%rbp), %rdi
movq 0x8(%r14), %rsi
movq... | /PandoraLS[P]rnnoise_toys/src/rnn.c |
rnnoise_model_from_file | RNNModel *rnnoise_model_from_file(FILE *f) {
int i, in;
if (fscanf(f, "rnnoise-nu model file version %d\n", &in) != 1 || in != 1)
return NULL;
RNNModel *ret = calloc(1, sizeof(RNNModel));
if (!ret)
return NULL;
#define ALLOC_LAYER(type, name) \
type *name; \
name = calloc(1, s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
leaq 0x17a0c(%rip), %rsi # 0x1ba88
xorl %ebx, %ebx
leaq 0xc(%rsp), %rdx
xorl %eax, %eax
callq 0x1040
cmpl $0x1, %eax
jne 0x4c82
cmpl $0x1, 0xc(%rsp)
jne 0x4c82
movl $0x1, %edi
movl $0x60, %esi
callq 0x1090
testq %rax,... | /PandoraLS[P]rnnoise_toys/src/rnn_reader.c |
main | int main(int argc, char *argv[])
{
ggml_time_init();
yolo_model model;
yolo_params params;
if (!yolo_params_parse(argc, argv, params)) {
return 1;
}
if (!load_model(params.model, model)) {
fprintf(stderr, "%s: failed to load model from '%s'\n", __func__, params.model.c_str());
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x348, %rsp # imm = 0x348
movq %rsi, %rbx
movl %edi, %ebp
callq 0x30d0
movabsq $0x1a0000001a0, %r13 # imm = 0x1A0000001A0
movq %r13, 0x18(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsp)
movups %xmm0, 0x30(%rsp)
leaq 0xc8(%rsp), %rdi... | /ggerganov[P]ggml/examples/yolo/yolov3-tiny.cpp |
stbi_load_from_file | STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
{
unsigned char *result;
stbi__context s;
stbi__start_file(&s,f);
result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
if (result) {
// need to 'unget' all the characters in the IO buffer
fseek(f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x1e18d(%rip), %rax # 0x25d78
leaq 0x40(%rsp), %rcx
movq %rax, -0x18(%rcx)
movups 0x1e16d(%rip), %xmm0 # 0x25d68
movups %xmm0, -0x28(%rcx)
movq %... | /ggerganov[P]ggml/examples/stb_image.h |
stbi_load_16_from_callbacks | STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)
{
stbi__context s;
stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);
return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq 0x10(%rdi), %rax
leaq 0x38(%rsp), %rcx
movq %rax, -0x18(%rcx)
movups (%rdi), %xmm0
movups %xmm0, -0x28(%rcx)
movq %rsi, -0x10(%rcx)
movabsq $0x8000000001, %rax # imm = 0x800000... | /ggerganov[P]ggml/examples/stb_image.h |
stbi_is_hdr_from_file | STBIDEF int stbi_is_hdr_from_file(FILE *f)
{
#ifndef STBI_NO_HDR
long pos = ftell(f);
int res;
stbi__context s;
stbi__start_file(&s,f);
res = stbi__hdr_test(&s);
fseek(f, pos, SEEK_SET);
return res;
#else
STBI_NOTUSED(f);
return 0;
#endif
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
callq 0x3030
movq %rax, %r14
movq 0x1d2d2(%rip), %rax # 0x25d78
leaq 0x40(%rsp), %rcx
movq %rax, -0x18(%rcx)
movups 0x1d2b2(%rip), %xmm0 # 0x25d68
movups %xmm0, -0x28(%rcx)
movq %rbx, -0x10(%rcx)
movabsq $0x8000000001, %rax # imm = ... | /ggerganov[P]ggml/examples/stb_image.h |
stbi_zlib_decode_buffer | STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
{
stbi__zbuf a;
a.zbuffer = (stbi_uc *) ibuffer;
a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
return (int) (a.zout - a.zout_start);
else
return -1;
} | pushq %rbp
pushq %rbx
subq $0x1008, %rsp # imm = 0x1008
movl %esi, %eax
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rdx, (%rbx)
movslq %ecx, %rcx
addq %rdx, %rcx
movq %rcx, 0x8(%rbx)
xorl %ebp, %ebp
movq %rbx, %rdi
movl %eax, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x8c52
movl 0x18(%rbx), %ecx
subl 0x20(%rb... | /ggerganov[P]ggml/examples/stb_image.h |
stbi_info_from_callbacks | STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
{
stbi__context s;
stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
return stbi__info_main(&s,x,y,comp);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq 0x10(%rdi), %rax
leaq 0x40(%rsp), %rcx
movq %rax, -0x18(%rcx)
movups (%rdi), %xmm0
movups %xmm0, -0x28(%rcx)
movq %rsi, -0x10(%rcx)
movabsq $0x8000000001, %rax # imm = 0x8000000001
movq %rax, -0x8(%rcx)
... | /ggerganov[P]ggml/examples/stb_image.h |
Warning(char const*, ...) | void Warning(const char* msg, ...) {
va_list ap;
fprintf(stderr, "ninja: warning: ");
va_start(ap, msg);
vfprintf(stderr, msg, ap);
va_end(ap);
fprintf(stderr, "\n");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x4b88
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
... | /adityavs[P]ninja/src/util.cc |
Error(char const*, ...) | void Error(const char* msg, ...) {
va_list ap;
fprintf(stderr, "ninja: error: ");
va_start(ap, msg);
vfprintf(stderr, msg, ap);
va_end(ap);
fprintf(stderr, "\n");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x4c4a
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
... | /adityavs[P]ninja/src/util.cc |
BuildLog::OpenForWriteIfNeeded() | bool BuildLog::OpenForWriteIfNeeded() {
if (log_file_path_.empty()) {
return true;
}
log_file_ = fopen(log_file_path_.c_str(), "ab");
if (!log_file_) {
return false;
}
if (setvbuf(log_file_, NULL, _IOLBF, BUFSIZ) != 0) {
return false;
}
SetCloseOnExec(fileno(log_file_));
// Opening a file... | pushq %r14
pushq %rbx
pushq %rax
movb $0x1, %r14b
cmpq $0x0, 0x48(%rdi)
je 0x5c4b
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
leaq 0x1c390(%rip), %rsi # 0x21f54
callq 0x4410
movq %rax, 0x38(%rbx)
xorl %r14d, %r14d
testq %rax, %rax
je 0x5c4b
movl $0x2000, %ecx # imm = 0x2000
movq %rax, %rdi
xorl %esi, %esi
movl ... | /adityavs[P]ninja/src/build_log.cc |
BuildLog::WriteEntry(_IO_FILE*, BuildLog::LogEntry const&) | bool BuildLog::WriteEntry(FILE* f, const LogEntry& entry) {
return fprintf(f, "%d\t%d\t%" PRId64 "\t%s\t%" PRIx64 "\n",
entry.start_time, entry.end_time, entry.mtime,
entry.output.c_str(), entry.command_hash) > 0;
} | pushq %rax
movq %rsi, %rdi
movl 0x28(%rdx), %eax
movl 0x2c(%rdx), %ecx
movq 0x30(%rdx), %r8
movq (%rdx), %r9
movq 0x20(%rdx), %rdx
movq %rdx, (%rsp)
leaq 0x1c338(%rip), %rsi # 0x21fae
movl %eax, %edx
xorl %eax, %eax
callq 0x4560
testl %eax, %eax
setg %al
popq %rcx
retq
| /adityavs[P]ninja/src/build_log.cc |
BuildLog::Load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | LoadStatus BuildLog::Load(const string& path, string* err) {
METRIC_RECORD(".ninja_log load");
FILE* file = fopen(path.c_str(), "r");
if (!file) {
if (errno == ENOENT)
return LOAD_NOT_FOUND;
*err = strerror(errno);
return LOAD_ERROR;
}
int log_version = 0;
int unique_entry_count = 0;
in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x400c8, %rsp # imm = 0x400C8
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movb 0x29752(%rip), %al # 0x2f3f8
testb %al, %al
je 0x6082
movq 0x2973b(%rip), %rsi # 0x2f3f0
leaq 0x98(%rsp), %rdi
callq 0x19300
movq (%rbx), %rdi
leaq... | /adityavs[P]ninja/src/build_log.cc |
BuildLog::Restat(StringPiece, DiskInterface const&, int, char**, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool BuildLog::Restat(const StringPiece path,
const DiskInterface& disk_interface,
const int output_count, char** outputs,
std::string* const err) {
METRIC_RECORD(".ninja_log restat");
Close();
std::string temp_path = path.AsString() + ".restat";
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %r14
movl %r8d, 0xc(%rsp)
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, 0x30(%rsp)
movq %rdi, %r12
movb 0x29210(%rip), %al # 0x2f418
testb %al, %al
je 0x64bc
movq 0x291f9(%rip), %rsi # 0x2f410
leaq 0x58(%rsp), %rdi
callq ... | /adityavs[P]ninja/src/build_log.cc |
LineReader::ReadLine(char**, char**) | bool ReadLine(char** line_start, char** line_end) {
if (line_start_ >= buf_end_ || !line_end_) {
// Buffer empty, refill.
size_t size_read = fread(buf_, 1, sizeof(buf_), file_);
if (!size_read)
return false;
line_start_ = buf_;
buf_end_ = buf_ + size_read;
} else {
//... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x40008(%rdi), %r12
cmpq %r12, 0x40010(%rdi)
jae 0x6601
movq 0x40018(%r14), %r13
testq %r13, %r13
je 0x6601
incq %r13
movq %r13, 0x40010(%r14)
jmp 0x6637
leaq 0x8(%r14), %r13
movq (%r1... | /adityavs[P]ninja/src/build_log.cc |
std::hash<StringPiece>::operator()(StringPiece) const | static inline
unsigned int MurmurHash2(const void* key, size_t len) {
static const unsigned int seed = 0xDECAFBAD;
const unsigned int m = 0x5bd1e995;
const int r = 24;
unsigned int h = seed ^ len;
const unsigned char* data = (const unsigned char*)key;
while (len >= 4) {
unsigned int k;
memcpy(&k, da... | movl %edx, %eax
xorl $0xdecafbad, %eax # imm = 0xDECAFBAD
cmpq $0x4, %rdx
jb 0x686e
imull $0x5bd1e995, (%rsi), %ecx # imm = 0x5BD1E995
movl %ecx, %edi
shrl $0x18, %edi
xorl %ecx, %edi
imull $0x5bd1e995, %edi, %ecx # imm = 0x5BD1E995
imull $0x5bd1e995, %eax, %eax # imm = 0x5BD1E995
xorl %ecx, %eax
addq $0x4, %rsi
... | /adityavs[P]ninja/src/hash_map.h |
BuildStatus::BuildStatus(BuildConfig const&) | BuildStatus::BuildStatus(const BuildConfig& config)
: config_(config), start_time_millis_(GetTimeMillis()), started_edges_(0),
finished_edges_(0), total_edges_(0), progress_status_format_(NULL),
current_rate_(config.parallelism) {
// Don't do anything fancy in verbose mode.
if (config_.verbosity != ... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, (%rdi)
callq 0x194c1
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movl %eax, 0x18(%rbx)
leaq 0x28(%rbx), %rcx
movl %eax, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movq %rcx, 0x38(%rbx)
movq %rcx, 0x40(%rbx)
movq %rax, 0x48(%rbx)
leaq 0x50(... | /adityavs[P]ninja/src/build.cc |
BuildStatus::PrintStatus(Edge const*, BuildStatus::EdgeStatus) | void BuildStatus::PrintStatus(const Edge* edge, EdgeStatus status) {
if (config_.verbosity == BuildConfig::QUIET)
return;
bool force_full_command = config_.verbosity == BuildConfig::VERBOSE;
string to_print = edge->GetBinding("description");
if (to_print.empty() || force_full_command)
to_print = edge-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq (%rdi), %rax
movl (%rax), %r15d
cmpl $0x1, %r15d
je 0x7223
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1b1a1(%rip), %rsi # 0x221f1
leaq 0x1b1a5(%rip), %rdx # 0x221fc
le... | /adityavs[P]ninja/src/build.cc |
BuildStatus::FormatProgressStatus[abi:cxx11](char const*, BuildStatus::EdgeStatus) const | string BuildStatus::FormatProgressStatus(
const char* progress_status_format, EdgeStatus status) const {
string out;
char buf[32];
int percent;
for (const char* s = progress_status_format; *s != '\0'; ++s) {
if (*s == '%') {
++s;
switch (*s) {
case '%':
out.push_back('%');
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x48(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0xb0(%rsi), %rax
movq %rax, 0x20(%rsp)
leaq 0xb8(%rsi), %rax
movq %rax, 0x18(%rsp)
leaq 0xa8(... | /adityavs[P]ninja/src/build.cc |
Plan::NodeFinished(Node*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool Plan::NodeFinished(Node* node, string* err) {
// If this node provides dyndep info, load it now.
if (node->dyndep_pending()) {
assert(builder_ && "dyndep requires Plan to have a Builder");
// Load the now-clean dyndep file. This will also update the
// build plan and schedule any new work that is ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x1, 0x31(%rsi)
jne 0x81de
movq 0x60(%r15), %rdi
testq %rdi, %rdi
je 0x8256
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0... | /adityavs[P]ninja/src/build.cc |
Plan::EdgeMaybeReady(std::_Rb_tree_iterator<std::pair<Edge* const, Plan::Want>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool Plan::EdgeMaybeReady(map<Edge*, Want>::iterator want_e, string* err) {
Edge* edge = want_e->first;
if (edge->AllInputsReady()) {
if (want_e->second != kWantNothing) {
ScheduleWork(want_e);
} else {
// We do not need to build this edge, but we might need to build one of
// its dependen... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rsi), %r12
movq %r12, %rdi
callq 0x1450a
testb %al, %al
je 0x8378
cmpl $0x0, 0x28(%r15)
je 0x8361
movq %r14, %rdi
movq %r15, %rsi
callq 0x8006
jmp 0x8378
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
movq... | /adityavs[P]ninja/src/build.cc |
Plan::DyndepsLoaded(DependencyScan*, Node const*, DyndepFile const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool Plan::DyndepsLoaded(DependencyScan* scan, const Node* node,
const DyndepFile& ddf, string* err) {
// Recompute the dirty state of all our direct and indirect dependents now
// that our dyndep information has been loaded.
if (!RefreshDyndepDependents(scan, node, err))
return false... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r15
movq %rdi, %r14
movq %r8, %rcx
callq 0x87b4
testb %al, %al
je 0x8664
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%r12), %rax
addq $0x8, %r12
movq %rax, 0x28(%rsp)... | /adityavs[P]ninja/src/build.cc |
RealCommandRunner::GetActiveEdges() | vector<Edge*> RealCommandRunner::GetActiveEdges() {
vector<Edge*> edges;
for (map<const Subprocess*, Edge*>::iterator e = subproc_to_edge_.begin();
e != subproc_to_edge_.end(); ++e)
edges.push_back(e->second);
return edges;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x2d8(%rsi), %r15
addq $0x2c8, %r14 # imm = 0x2C8
cmpq %r14, %r15
je 0x8adf
leaq 0x28(%r15), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x8ac7
movq (%rdx), %rax
movq %ra... | /adityavs[P]ninja/src/build.cc |
RealCommandRunner::StartCommand(Edge*) | bool RealCommandRunner::StartCommand(Edge* edge) {
string command = edge->EvaluateCommand();
Subprocess* subproc = subprocs_.Add(command, edge->use_console());
if (!subproc)
return false;
subproc_to_edge_.insert(make_pair(subproc, edge));
return true;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
xorl %edx, %edx
callq 0x14026
movq %r14, %rdi
callq 0x14c60
leaq 0x10(%rbx), %rdi
movzbl %al, %edx
movq %rsp, %rsi
callq 0x1d144
movq %rax, %r15
testq %rax, %rax
je 0x8bf1
addq $0x2c0, %rbx # imm = 0x2C0
leaq 0x... | /adityavs[P]ninja/src/build.cc |
Builder::~Builder() | Builder::~Builder() {
Cleanup();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8e66
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x8e34
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x80(%rbx)
leaq 0x10(%rbx), %r14
addq $0x40, %rbx
movq %rbx, %rdi
callq 0xb146
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb1e6
movq %rax, %rdi
callq... | /adityavs[P]ninja/src/build.cc |
BuildStatus::SlidingRateInfo::UpdateRate(int) | void UpdateRate(int update_hint) {
if (update_hint == last_update_)
return;
last_update_ = update_hint;
if (times_.size() == N)
times_.pop();
times_.push(stopwatch_.Elapsed());
if (times_.back() != times_.front())
rate_ = times_.size() / (times_.back() - times_.fro... | cmpl %esi, 0x68(%rdi)
je 0xaafb
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x68(%rdi)
leaq 0x18(%rdi), %r14
movq 0x60(%rdi), %rax
movq %rax, %rcx
subq 0x40(%rdi), %rcx
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
shlq $0x6, %rcx
movq 0x38(%rdi), %rax
movq 0x48(%rdi), %rdx
subq 0x50(%rdi), %rdx
sarq... | /adityavs[P]ninja/src/build.h |
Cleaner::Reset() | void Cleaner::Reset() {
status_ = 0;
cleaned_files_count_ = 0;
removed_.clear();
cleaned_.clear();
} | pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x90(%rdi)
movl %eax, 0x80(%rdi)
addq $0x20, %rdi
callq 0xd4c6
addq $0x50, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0xd4f4
| /adityavs[P]ninja/src/clean.cc |
Cleaner::LoadDyndeps() | void Cleaner::LoadDyndeps() {
// Load dyndep files that exist, before they are cleaned.
for (vector<Edge*>::iterator e = state_->edges_.begin();
e != state_->edges_.end(); ++e) {
if (Node* dyndep = (*e)->dyndep_) {
// Capture and ignore errors loading the dyndep file.
// We clean as much of t... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %rax
movq 0x68(%rax), %r13
cmpq 0x70(%rax), %r13
je 0xc956
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
leaq 0x10(%rdi), %r14
movq %rsp, %r15
movq (%r13), %rcx
movq 0x40(%rcx), %rsi
testq %rsi, %rsi
je 0xc94c
movq %r12, (%rsp)
movq $0x0, 0x8(... | /adityavs[P]ninja/src/clean.cc |
Cleaner::CleanDead(std::unordered_map<StringPiece, BuildLog::LogEntry*, std::hash<StringPiece>, std::equal_to<StringPiece>, std::allocator<std::pair<StringPiece const, BuildLog::LogEntry*>>> const&) | int Cleaner::CleanDead(const BuildLog::Entries& entries) {
Reset();
PrintHeader();
for (BuildLog::Entries::const_iterator i = entries.begin(); i != entries.end(); ++i) {
Node* n = state_->LookupNode(i->first);
if (!n || !n->in_edge()) {
Remove(i->first.AsString());
}
}
PrintFooter();
retur... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x90(%rdi)
movl %eax, 0x80(%rdi)
addq $0x20, %rdi
callq 0xd4c6
leaq 0x50(%rbx), %rdi
callq 0xd4f4
movq %rbx, %rdi
callq 0xc702
movq 0x10(%r14), %r12
testq %r12, %r12
je 0xca53
leaq 0x18(%rsp), %r15
le... | /adityavs[P]ninja/src/clean.cc |
Cleaner::CleanTarget(char const*) | int Cleaner::CleanTarget(const char* target) {
assert(target);
Reset();
Node* node = state_->LookupNode(target);
if (node) {
CleanTarget(node);
} else {
Error("unknown target '%s'", target);
status_ = 1;
}
return status_;
} | pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xcc6f
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x90(%rdi)
movl %eax, 0x80(%rdi)
addq $0x20, %rdi
callq 0xd4c6
leaq 0x50(%rbx), %rdi
callq 0xd4f4
movq (%rbx), %r15
movq %r14, %rdi
callq 0x4180
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x... | /adityavs[P]ninja/src/clean.cc |
Cleaner::CleanTargets(int, char**) | int Cleaner::CleanTargets(int target_count, char* targets[]) {
Reset();
PrintHeader();
LoadDyndeps();
for (int i = 0; i < target_count; ++i) {
string target_name = targets[i];
uint64_t slash_bits;
string err;
if (!CanonicalizePath(&target_name, &slash_bits, &err)) {
Error("failed to canoni... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x48(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x90(%rdi)
movl %eax, 0x80(%rdi)
addq $0x20, %rdi
callq 0xd4c6
leaq 0x50(%rbx), %rdi
callq 0xd4f4
movq %rbx, %rdi
callq 0xc702
movq %rbx, %rdi
callq 0xc8e0
... | /adityavs[P]ninja/src/clean.cc |
Cleaner::CleanRule(Rule const*) | int Cleaner::CleanRule(const Rule* rule) {
assert(rule);
Reset();
PrintHeader();
LoadDyndeps();
DoCleanRule(rule);
PrintFooter();
return status_;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xcf9d
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x90(%rdi)
movl %eax, 0x80(%rdi)
addq $0x20, %rdi
callq 0xd4c6
leaq 0x50(%rbx), %rdi
callq 0xd4f4
movq %rbx, %rdi
callq 0xc702
movq %rbx, %rdi
callq 0xc8e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xce70
... | /adityavs[P]ninja/src/clean.cc |
Cleaner::CleanRules(int, char**) | int Cleaner::CleanRules(int rule_count, char* rules[]) {
assert(rules);
Reset();
PrintHeader();
LoadDyndeps();
for (int i = 0; i < rule_count; ++i) {
const char* rule_name = rules[i];
const Rule* rule = state_->bindings_.LookupRule(rule_name);
if (rule) {
if (IsVerbose())
printf("Ru... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x10(%rsp)
testq %rdx, %rdx
je 0xd210
movl %esi, %ebp
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x90(%rdi)
movl %eax, 0x80(%rdi)
addq $0x20, %rdi
callq 0xd4c6
leaq 0x50(%rbx), %rdi
callq 0xd4f4
movq %rbx, %rdi
callq 0xc702
mo... | /adityavs[P]ninja/src/clean.cc |
(anonymous namespace)::EndsWith(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool EndsWith(const string& input, const string& needle) {
return (input.size() >= needle.size() &&
input.substr(input.size() - needle.size()) == needle);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq 0x8(%rdi), %rdx
subq 0x8(%rsi), %rdx
jae 0xd8c4
xorl %ebp, %ebp
jmp 0xd924
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
movq $-0x1, %rcx
callq 0x4360
movq 0x8(%rbx), %rdx
cmpq 0x8(%r14), %rdx
jne 0xd8ff
movq (%rsp), %rbx
testq %rdx, %rdx
je 0xd90... | /adityavs[P]ninja/src/clparser.cc |
DyndepLoader::LoadDyndeps(Node*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) const | bool DyndepLoader::LoadDyndeps(Node* node, std::string* err) const {
DyndepFile ddf;
return LoadDyndeps(node, &ddf, err);
} | pushq %rbx
subq $0x30, %rsp
movq %rdx, %rcx
leaq 0x8(%rsp), %rax
movl $0x0, (%rax)
xorl %edx, %edx
movq %rdx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rdx, 0x20(%rax)
movq %rsp, %rdx
callq 0xddce
movl %eax, %ebx
movq %rsp, %rdi
callq 0xb696
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %... | /adityavs[P]ninja/src/dyndep.cc |
DyndepLoader::LoadDyndeps(Node*, DyndepFile*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) const | bool DyndepLoader::LoadDyndeps(Node* node, DyndepFile* ddf,
std::string* err) const {
// We are loading the dyndep file now so it is no longer pending.
node->set_dyndep_pending(false);
// Load the dyndep information from the file.
EXPLAIN("loading dyndep file '%s'", node->path().... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movb $0x0, 0x31(%rsi)
leaq 0x2165a(%rip), %rax # 0x2f450
cmpb $0x1, (%rax)
je 0xdf53
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xe1aa
testb %... | /adityavs[P]ninja/src/dyndep.cc |
DyndepLoader::UpdateEdge(Edge*, Dyndeps const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) const | bool DyndepLoader::UpdateEdge(Edge* edge, Dyndeps const* dyndeps,
std::string* err) const {
// Add dyndep-discovered bindings to the edge.
// We know the edge already has its own binding
// scope because it has a "dyndep" binding.
if (dyndeps->restat_)
edge->env_->AddBinding("r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
cmpb $0x1, 0x1(%rdx)
jne 0xe2e5
movq 0x48(%r14), %r12
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x13d7b(%rip), %rsi # 0x21fee
leaq 0x13d7a(%rip), %rdx # 0x21ff4
leaq 0x8(%rs... | /adityavs[P]ninja/src/dyndep.cc |
Node::AddOutEdge(Edge*) | void AddOutEdge(Edge* edge) { out_edges_.push_back(edge); } | pushq %rax
movq %rsi, %rax
movq %rsi, (%rsp)
movq 0x48(%rdi), %rsi
cmpq 0x50(%rdi), %rsi
je 0xe428
movq %rax, (%rsi)
addq $0x8, 0x48(%rdi)
jmp 0xe434
addq $0x40, %rdi
movq %rsp, %rdx
callq 0xb774
popq %rax
retq
| /adityavs[P]ninja/src/graph.h |
DyndepParser::DyndepParser(State*, FileReader*, DyndepFile*) | Parser(State* state, FileReader* file_reader)
: state_(state), file_reader_(file_reader) {} | movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
leaq 0x204d6(%rip), %rax # 0x2ec28
movq %rax, (%rdi)
movq %rcx, 0x48(%rdi)
leaq 0x20580(%rip), %rax # 0x2ece0
addq $0x10, %rax
movq %rax, 0x50(%rdi)
leaq 0x60(%rdi), %rax
xorl %ecx, %ecx
movl %ecx, 0x... | /adityavs[P]ninja/src/parser.h |
DyndepParser::Parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool DyndepParser::Parse(const string& filename, const string& input,
string* err) {
lexer_.Start(filename, input);
// Require a supported ninja_dyndep_version value immediately so
// we can exit before encountering any syntactic surprises.
bool haveDyndepVersion = false;
for (;;) {... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdi, %r15
leaq 0x18(%rdi), %r14
movq (%rsi), %rax
movq 0x8(%rsi), %r9
movq (%rdx), %rcx
movq 0x8(%rdx), %r8
movq %r14, %rdi
movq %rax, %rsi
movq %r9, %rdx
callq 0x1e290
xorl %r13d, %r13d
leaq 0x14210(%rip), %r12 ... | /adityavs[P]ninja/src/dyndep_parser.cc |
DepsLog::~DepsLog() | DepsLog::~DepsLog() {
Close();
} | pushq %rbx
movq %rdi, %rbx
callq 0x103e6
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x103ae
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x4340
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x103c3
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x4340
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x103dc
movq (%rbx)... | /adityavs[P]ninja/src/deps_log.cc |
Edge::GetBindingBool(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool Edge::GetBindingBool(const string& key) const {
return !GetBinding(key).empty();
} | pushq %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1489a
movq (%rbx), %rdi
movq 0x8(%rbx), %rbx
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x144f4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4340
testq %rbx, %rbx
setne %al
addq $0x20, %rsp
popq %rbx
retq
| /adityavs[P]ninja/src/graph.cc |
EdgeEnv::MakePathList[abi:cxx11](Node const* const*, unsigned long, char) const | std::string EdgeEnv::MakePathList(const Node* const* const span,
const size_t size, const char sep) const {
string result;
for (const Node* const* i = span; i != span + size; ++i) {
if (!result.empty())
result.push_back(sep);
const string& path = (*i)->PathDecanonical... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testq %rcx, %rcx
je 0x14844
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0x28(%rsp), %rbp
shlq $0x3, %r14
xo... | /adityavs[P]ninja/src/graph.cc |
Edge::GetBinding(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string Edge::GetBinding(const std::string& key) const {
EdgeEnv env(this, EdgeEnv::kShellEscape);
return env.LookupVariable(key);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
leaq 0x1a493(%rip), %r15 # 0x2ed40
leaq 0x8(%rsp), %rbx
movq %r15, -0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rsi, 0x18(%rbx)
movl $0x0, 0x20(%rbx)
movb $0x0, 0x24(%rbx)
movq %rsp, %rsi
callq 0x14534
movq %r15, (%r... | /adityavs[P]ninja/src/graph.cc |
Edge::GetUnescapedRspfile[abi:cxx11]() const | std::string Edge::GetUnescapedRspfile() const {
EdgeEnv env(this, EdgeEnv::kDoNotEscape);
return env.LookupVariable("rspfile");
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
leaq 0x1a273(%rip), %r15 # 0x2ed40
leaq 0x30(%rsp), %rbx
movq %r15, -0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rsi, 0x18(%rbx)
movl $0x1, 0x20(%rbx)
movb $0x0, 0x24(%rbx)
leaq 0x18(%rsp), %r12
movq %r12,... | /adityavs[P]ninja/src/graph.cc |
Edge::Dump(char const*) const | void Edge::Dump(const char* prefix) const {
printf("%s[ ", prefix);
for (vector<Node*>::const_iterator i = inputs_.begin();
i != inputs_.end() && *i != NULL; ++i) {
printf("%s ", (*i)->path().c_str());
}
printf("--%s-> ", rule_->name().c_str());
for (vector<Node*>::const_iterator i = outputs_.begin... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xe7a6(%rip), %rdi # 0x23343
xorl %eax, %eax
callq 0x4090
movq 0x10(%rbx), %r15
cmpq 0x18(%rbx), %r15
je 0x14bd4
leaq 0xe793(%rip), %r14 # 0x23348
movq (%r15), %rax
testq %rax, %rax
je 0x14bd4
movq (%rax), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x4090
... | /adityavs[P]ninja/src/graph.cc |
ImplicitDepLoader::LoadDepsFromLog(Edge*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool ImplicitDepLoader::LoadDepsFromLog(Edge* edge, string* err) {
// NOTE: deps are only supported for single-target edges.
Node* output = edge->outputs_[0];
DepsLog::Deps* deps = deps_log_ ? deps_log_->GetDeps(output) : NULL;
if (!deps) {
EXPLAIN("deps for '%s' are missing", output->path().c_str());
r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x28(%rsi), %rax
movq (%rax), %r12
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x14db4
movq %rsi, %rbx
movq %r12, %rsi
callq 0x10b8c
testq %rax, %rax
je 0x14db4
movq %rax, %r15
movq 0x28(%r12), %r8
movq (%rax), %rcx
cmpq %rc... | /adityavs[P]ninja/src/graph.cc |
ImplicitDepLoader::LoadDepFile(Edge*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool ImplicitDepLoader::LoadDepFile(Edge* edge, const string& path,
string* err) {
METRIC_RECORD("depfile load");
// Read depfile content. Treat a missing depfile as empty.
string content;
switch (disk_interface_->ReadFile(path, &content, err)) {
case DiskInterface::Okay:
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r15
movb 0x1a641(%rip), %al # 0x2f490
testb %al, %al
je 0x15640
movq 0x1a62a(%rip), %rsi # 0x2f488
leaq 0x110(%rsp), %rdi
callq 0x19300
leaq 0... | /adityavs[P]ninja/src/graph.cc |
ImplicitDepLoader::PreallocateSpace(Edge*, int) | vector<Node*>::iterator ImplicitDepLoader::PreallocateSpace(Edge* edge,
int count) {
edge->inputs_.insert(edge->inputs_.end() - edge->order_only_deps_,
(size_t)count, 0);
edge->implicit_deps_ += count;
return edge->inputs_.end() - ... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x10(%rsi), %rdi
movq 0x18(%rsi), %rsi
movslq 0x5c(%rbx), %rax
shlq $0x3, %rax
subq %rax, %rsi
movslq %edx, %r14
movq %rsp, %rcx
movq $0x0, (%rcx)
movq %r14, %rdx
callq 0x15eda
addl %r14d, 0x58(%rbx)
movq 0x18(%rbx), %rax
movslq 0x5c(%rbx), %rcx
shlq $0x3, %rcx
subq... | /adityavs[P]ninja/src/graph.cc |
ImplicitDepLoader::CreatePhonyInEdge(Node*) | void ImplicitDepLoader::CreatePhonyInEdge(Node* node) {
if (node->in_edge())
return;
Edge* phony_edge = state_->AddEdge(&State::kPhonyRule);
node->set_in_edge(phony_edge);
phony_edge->outputs_.push_back(node);
// RecomputeDirty might not be called for phony_edge if a previous call
// to RecomputeDirty... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
cmpq $0x0, 0x38(%rsi)
jne 0x15906
movq %rsi, %rbx
movq (%rdi), %rdi
leaq 0x19c8e(%rip), %rsi # 0x2f560
callq 0x19f2e
movq %rax, %r14
movq %rax, 0x38(%rbx)
movq 0x30(%rax), %rsi
cmpq 0x38(%rax), %rsi
je 0x158f2
movq %rbx, (%rsi)
addq $0x8, 0x30(%r14)
jmp 0x15901
mov... | /adityavs[P]ninja/src/graph.cc |
StringPiece::AsString[abi:cxx11]() const | std::string AsString() const {
return len_ ? std::string(str_, len_) : std::string();
} | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x15984
movq (%rsi), %rsi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x5330
jmp 0x15997
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
| /adityavs[P]ninja/src/string_piece.h |
GraphViz::AddTarget(Node*) | void GraphViz::AddTarget(Node* node) {
if (visited_nodes_.find(node) != visited_nodes_.end())
return;
string pathstr = node->path();
replace(pathstr.begin(), pathstr.end(), '\\', '/');
printf("\"%p\" [label=\"%s\"]\n", node, pathstr.c_str());
visited_nodes_.insert(node);
Edge* edge = node->in_edge();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x16341
leaq 0x18(%rbx), %rdx
movq %rdx, %rcx
xorl %edi, %edi
cmpq %rsi, 0x20(%rax)
setb %dil
cmovaeq %rax, %rcx
movq 0x10(%rax,%rdi,8), %rax
testq %rax, %ra... | /adityavs[P]ninja/src/graphviz.cc |
LinePrinter::LinePrinter() | LinePrinter::LinePrinter() : have_blank_line_(true), console_locked_(false) {
const char* term = getenv("TERM");
#ifndef _WIN32
smart_terminal_ = isatty(1) && term && string(term) != "dumb";
#else
// Disable output buffer. It'd be nice to use line buffering but
// MSDN says: "For some systems, [_IOLBF] provide... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movw $0x1, 0x2(%rdi)
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x40(%rdi), %r12
movq %r12, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movb %al, 0x40(%rdi)
leaq 0xcfa1... | /adityavs[P]ninja/src/line_printer.cc |
LinePrinter::PrintOrBuffer(char const*, unsigned long) | void LinePrinter::PrintOrBuffer(const char* data, size_t size) {
if (console_locked_) {
output_buffer_.append(data, size);
} else {
// Avoid printf and C strings, since the actual output might contain null
// bytes like UTF-16 does (yuck).
fwrite(data, 1, size, stdout);
}
} | movq %rsi, %rax
cmpb $0x1, 0x3(%rdi)
jne 0x168df
addq $0x30, %rdi
movq %rax, %rsi
jmp 0x40a0
movq 0x186ca(%rip), %rcx # 0x2efb0
movq (%rcx), %rcx
movl $0x1, %esi
movq %rax, %rdi
jmp 0x4750
| /adityavs[P]ninja/src/line_printer.cc |
LinePrinter::PrintOnNewLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void LinePrinter::PrintOnNewLine(const string& to_print) {
if (console_locked_ && !line_buffer_.empty()) {
output_buffer_.append(line_buffer_);
output_buffer_.append(1, '\n');
line_buffer_.clear();
}
if (!have_blank_line_) {
PrintOrBuffer("\n", 1);
}
if (!to_print.empty()) {
PrintOrBuffer(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x3(%rdi)
jne 0x1694a
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0x1694a
leaq 0x30(%rbx), %r15
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x4140
movq 0x38(%rbx), %rsi
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
movl $0x... | /adityavs[P]ninja/src/line_printer.cc |
LinePrinter::SetConsoleLocked(bool) | void LinePrinter::SetConsoleLocked(bool locked) {
if (locked == console_locked_)
return;
if (locked)
PrintOnNewLine("");
console_locked_ = locked;
if (!locked) {
PrintOnNewLine(output_buffer_);
if (!line_buffer_.empty()) {
Print(line_buffer_, line_type_);
}
output_buffer_.clear(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
cmpb %bpl, 0x3(%rdi)
je 0x16a76
movq %rdi, %rbx
testb %bpl, %bpl
je 0x16a05
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xb437(%rip), %rdx # 0x21e05
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x5330
leaq 0x8(%rsp), %rsi
movq %rbx, %... | /adityavs[P]ninja/src/line_printer.cc |
ManifestParser::ParsePool(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool ManifestParser::ParsePool(string* err) {
string name;
if (!lexer_.ReadIdent(&name))
return lexer_.Error("expected pool name", err);
if (!ExpectToken(Lexer::NEWLINE, err))
return false;
if (state_->LookupPool(name) != NULL)
return lexer_.Error("duplicate pool '" + name + "'", err);
int dept... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x80(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x18(%rdi), %r14
leaq 0x70(%rsp), %rsi
movq %r14, %rdi
callq 0x1e7de
testb %al, %al
je 0x16ef1
movq %r15, %rdi
movl... | /adityavs[P]ninja/src/manifest_parser.cc |
ManifestParser::ParseEdge(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool ManifestParser::ParseEdge(string* err) {
vector<EvalString> ins, outs;
{
EvalString out;
if (!lexer_.ReadPath(&out, err))
return false;
while (!out.empty()) {
outs.push_back(out);
out.Clear();
if (!lexer_.ReadPath(&out, err))
return false;
}
}
// Add all i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rsi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x100(%rsp)
xorl %eax, %eax
movq %rax, 0x110(%rsp)
movq %rax, 0xf0(%rsp)
movaps %xmm0, 0xe0(%rsp)
leaq 0x80(%rsp), %rsi
movq %rax, 0x10(%rsi)
movaps %xmm0, (%rsi)... | /adityavs[P]ninja/src/manifest_parser.cc |
ManifestParser::ParseRule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool ManifestParser::ParseRule(string* err) {
string name;
if (!lexer_.ReadIdent(&name))
return lexer_.Error("expected rule name", err);
if (!ExpectToken(Lexer::NEWLINE, err))
return false;
if (env_->LookupRuleCurrentScope(name) != NULL)
return lexer_.Error("duplicate rule '" + name + "'", err);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x60(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x18(%rdi), %r14
leaq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x1e7de
testb %al, %al
je 0x185e8
movq %r15, %rdi
movl... | /adityavs[P]ninja/src/manifest_parser.cc |
Metrics::Report() | void Metrics::Report() {
int width = 0;
for (vector<Metric*>::iterator i = metrics_.begin();
i != metrics_.end(); ++i) {
width = max((int)(*i)->name.size(), width);
}
printf("%-*s\t%-6s\t%-9s\t%s\n", width,
"metric", "count", "avg (us)", "total (ms)");
for (vector<Metric*>::iterator i = m... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rcx, %rax
je 0x19434
xorl %edx, %edx
movq (%rax), %rsi
movl 0x8(%rsi), %ebp
cmpl %ebp, %edx
cmovgl %edx, %ebp
addq $0x8, %rax
movl %ebp, %edx
cmpq %rcx, %rax
jne 0x1941c
jmp 0x19436
xorl %ebp, %ebp
leaq 0... | /adityavs[P]ninja/src/metrics.cc |
JoinStringPiece[abi:cxx11](std::vector<StringPiece, std::allocator<StringPiece>> const&, char) | string JoinStringPiece(const vector<StringPiece>& list, char sep) {
if (list.empty()) {
return "";
}
string ret;
{
size_t cap = list.size() - 1;
for (size_t i = 0; i < list.size(); ++i) {
cap += list[i].len_;
}
ret.reserve(cap);
}
for (size_t i = 0; i < list.size(); ++i) {
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
cmpq %rcx, %rax
je 0x1b4ad
movl %edx, %ebp
movq %rsi, %r14
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
subq %rax, %rcx
sarq $0x4, %rcx
leaq -0x1(%rcx... | /adityavs[P]ninja/src/string_piece_util.cc |
EqualsCaseInsensitiveASCII(StringPiece, StringPiece) | bool EqualsCaseInsensitiveASCII(StringPiece a, StringPiece b) {
if (a.len_ != b.len_) {
return false;
}
for (size_t i = 0; i < a.len_; ++i) {
if (ToLowerASCII(a.str_[i]) != ToLowerASCII(b.str_[i])) {
return false;
}
}
return true;
} | cmpq %rcx, %rsi
jne 0x1b545
testq %rsi, %rsi
je 0x1b548
decq %rsi
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %eax
leal -0x41(%rax), %r8d
leal 0x20(%rax), %r9d
cmpb $0x1a, %r8b
movzbl %r9b, %r8d
cmovael %eax, %r8d
movzbl (%rdx,%rcx), %eax
leal -0x41(%rax), %r9d
leal 0x20(%rax), %r10d
cmpb $0x1a, %r9b
movzbl %r10b, %r9d
cmovael... | /adityavs[P]ninja/src/string_piece_util.cc |
Fatal(char const*, ...) | void Fatal(const char* msg, ...) {
va_list ap;
fprintf(stderr, "ninja: fatal: ");
va_start(ap, msg);
vfprintf(stderr, msg, ap);
va_end(ap);
fprintf(stderr, "\n");
#ifdef _WIN32
// On Windows, some tools may inject extra threads.
// exit() may block on locks held by those threads, so forcibly exit.
ffl... | pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x1b7cb
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)... | /adityavs[P]ninja/src/util.cc |
Subprocess::Finish() | ExitStatus Subprocess::Finish() {
assert(pid_ != -1);
int status;
if (waitpid(pid_, &status, 0) < 0)
Fatal("waitpid(%d): %s", pid_, strerror(errno));
pid_ = -1;
if (WIFEXITED(status)) {
int exit = WEXITSTATUS(status);
if (exit == 0)
return ExitSuccess;
} else if (WIFSIGNALED(status)) {
... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x24(%rdi), %edi
cmpl $-0x1, %edi
je 0x1cabf
leaq 0xc(%rsp), %rsi
xorl %edx, %edx
callq 0x42a0
testl %eax, %eax
js 0x1cade
movl $0xffffffff, 0x24(%rbx) # imm = 0xFFFFFFFF
movl 0xc(%rsp), %eax
movl %eax, %ecx
andl $0x7f, %ecx
je 0x1caa9
movl %ecx, %eax
shll $0x18, %eax
ad... | /adityavs[P]ninja/src/subprocess-posix.cc |
Subprocess::Start(SubprocessSet*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool Subprocess::Start(SubprocessSet* set, const string& command) {
int output_pipe[2];
if (pipe(output_pipe) < 0)
Fatal("pipe: %s", strerror(errno));
fd_ = output_pipe[0];
#if !defined(USE_PPOLL)
// If available, we use ppoll in DoWork(); otherwise we use pselect
// and so must avoid overly-large FDs.
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4500
testl %eax, %eax
js 0x1ccd3
movl 0x8(%rsp), %edi
movl %edi, 0x20(%rbx)
cmpl $0x400, %edi # imm = 0x400
jge 0x1ccdc
callq 0x1c028
leaq 0x10(%rsp), %rdi
... | /adityavs[P]ninja/src/subprocess-posix.cc |
Subprocess::OnPipeReady() | void Subprocess::OnPipeReady() {
char buf[4 << 10];
ssize_t len = read(fd_, buf, sizeof(buf));
if (len > 0) {
buf_.append(buf, len);
} else {
if (len < 0)
Fatal("read: %s", strerror(errno));
close(fd_);
fd_ = -1;
}
} | pushq %rbx
subq $0x1000, %rsp # imm = 0x1000
movq %rdi, %rbx
movl 0x20(%rdi), %edi
movq %rsp, %rsi
movl $0x1000, %edx # imm = 0x1000
callq 0x4570
testq %rax, %rax
jle 0x1cdba
movq %rsp, %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x40a0
jmp 0x1cdcb
js 0x1cdd4
movl 0x20(%rbx), %edi
callq 0x4760
movl $... | /adityavs[P]ninja/src/subprocess-posix.cc |
SubprocessSet::HandlePendingInterruption() | void SubprocessSet::HandlePendingInterruption() {
sigset_t pending;
sigemptyset(&pending);
if (sigpending(&pending) == -1) {
perror("ninja: sigpending");
return;
}
if (sigismember(&pending, SIGINT))
interrupted_ = SIGINT;
else if (sigismember(&pending, SIGTERM))
interrupted_ = SIGTERM;
els... | pushq %rbx
subq $0x80, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4480
movq %rbx, %rdi
callq 0x40f0
cmpl $-0x1, %eax
je 0x1ce7d
movq %rsp, %rdi
movl $0x2, %esi
callq 0x41c0
testl %eax, %eax
je 0x1ce43
movl $0x2, 0x1279f(%rip) # 0x2f5e0
jmp 0x1ce89
movq %rsp, %rdi
movl $0xf, %esi
callq 0x41c0
testl %eax, %eax
je 0... | /adityavs[P]ninja/src/subprocess-posix.cc |
Lexer::DescribeLastError[abi:cxx11]() | string Lexer::DescribeLastError() {
if (last_token_) {
switch (last_token_[0]) {
case '\t':
return "tabs are not allowed, use spaces";
}
}
return "lexing error";
} | pushq %rbx
movq %rdi, %rbx
movq 0x28(%rsi), %rax
testq %rax, %rax
je 0x1e305
cmpb $0x9, (%rax)
jne 0x1e305
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5def(%rip), %rsi # 0x240eb
leaq 0x5e08(%rip), %rdx # 0x2410b
jmp 0x1e31a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5d59(%rip), %rsi # 0x2406c
leaq... | /adityavs[P]ninja/src/lexer.cc |
Lexer::ReadToken() | Lexer::Token Lexer::ReadToken() {
const char* p = ofs_;
const char* q;
const char* start;
Lexer::Token token;
for (;;) {
start = p;
{
unsigned char yych;
unsigned int yyaccept = 0;
static const unsigned char yybm[] = {
0, 128, 128, 128, 128, 128, 128, 128,
128, 128, 0, 128, 128, 128, 128,... | pushq %rbx
movq 0x20(%rdi), %rax
movzbl (%rax), %ecx
cmpl $0x20, %ecx
jne 0x1e367
leaq 0x1(%rax), %rcx
movzbl (%rcx), %esi
incq %rcx
cmpl $0x20, %esi
je 0x1e343
cmpb $0xc, %sil
jbe 0x1e417
cmpl $0x23, %esi
jne 0x1e3c5
decq %rcx
xorl %edx, %edx
movq %rcx, %rsi
jmp 0x1e3a2
cmpb $0x5e, %cl
ja 0x1e432
cmpb $0x2c, %cl
ja 0x... | /adityavs[P]ninja/src/lexer.cc |
_cxx_global_var_init | std::string
QPDFObject::getDescription()
{
qpdf_offset_t shift = (getTypeCode() == ::ot_dictionary) ? 2
: (getTypeCode() == ::ot_array) ? 1
: 0;
if (object_description) {
switch (object_description->index()) {
... | pushq %rbp
movq %rsp, %rbp
leaq 0x47579d(%rip), %rdi # 0x4926e8
callq 0x1beb0
movq 0x473ff1(%rip), %rdi # 0x490f48
leaq 0x47578a(%rip), %rsi # 0x4926e8
leaq 0x474993(%rip), %rdx # 0x4918f8
callq 0x1bce0
popq %rbp
retq
nopl (%rax)
| /qpdf[P]qpdf/libqpdf/QPDFObject.cc |
GLOBAL__sub_I_QPDFObject.cc | std::string
QPDFObject::getDescription()
{
qpdf_offset_t shift = (getTypeCode() == ::ot_dictionary) ? 2
: (getTypeCode() == ::ot_array) ? 1
: 0;
if (object_description) {
switch (object_description->index()) {
... | pushq %rbp
movq %rsp, %rbp
callq 0x1cf40
popq %rbp
retq
nopl (%rax,%rax)
| /qpdf[P]qpdf/libqpdf/QPDFObject.cc |
main | int
main(int argc, char* argv[])
{
if (argc != 6) {
usage();
}
char* infilename = argv[1];
char* outfilename = argv[2];
JDIMENSION width = QUtil::string_to_uint(argv[3]);
JDIMENSION height = QUtil::string_to_uint(argv[4]);
char* colorspace = argv[5];
J_COLOR_SPACE cs =
(... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x6, -0x8(%rbp)
je 0x1dfd4
callq 0x1e340
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
m... | /qpdf[P]qpdf/libtests/dct_compress.cc |
BitStream::reset() | void
BitStream::reset()
{
p = start;
bit_offset = 7;
if (QIntC::to_uint(nbytes) > static_cast<unsigned int>(-1) / 8) {
throw std::runtime_error("array too large for bitstream");
}
bits_available = 8 * nbytes;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, 0x10(%rdi)
movq $0x7, 0x18(%rdi)
addq $0x8, %rdi
callq 0x1f100
cmpl $0x1fffffff, %eax # imm = 0x1FFFFFFF
jbe 0x1eb93
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi,... | /qpdf[P]qpdf/libqpdf/BitStream.cc |
BitWriter::writeBitsSigned(long long, unsigned long) | void
BitWriter::writeBitsSigned(long long val, size_t bits)
{
unsigned long long uval = 0;
if (val < 0) {
uval = (1ULL << bits) + static_cast<unsigned long long>(val);
} else {
uval = static_cast<unsigned long long>(val);
}
writeBits(uval, bits);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0x1fcb1
movq -0x18(%rbp), %rcx
movl $0x1, %eax
shlq %cl, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0... | /qpdf[P]qpdf/libqpdf/BitWriter.cc |
BufferInputSource::BufferInputSource(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | BufferInputSource::BufferInputSource(std::string const& description, std::string const& contents) :
own_memory(true),
description(description),
buf(new Buffer(contents.length())),
cur_offset(0),
max_offset(QIntC::to_offset(buf->getSize()))
{
memcpy(buf->getBuffer(), contents.c_str(), contents.le... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x21490
movq -0x40(%rbp), %rdi
leaq 0x469bb1(%rip), %rax # 0x48a870
movq %rax, (%rdi)
movb $0x1, 0xa8(%rdi)
addq $0xb0, %rdi
movq %rdi, -0x38(%rbp)
movq -... | /qpdf[P]qpdf/libqpdf/BufferInputSource.cc |
BufferInputSource::findAndSkipNextEOL() | qpdf_offset_t
BufferInputSource::findAndSkipNextEOL()
{
if (this->cur_offset < 0) {
throw std::logic_error("INTERNAL ERROR: BufferInputSource offset < 0");
}
qpdf_offset_t end_pos = this->max_offset;
if (this->cur_offset >= end_pos) {
this->last_offset = end_pos;
this->cur_offset... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, 0xd8(%rax)
jge 0x20f31
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x2ec3f4(%rip), %rsi # 0x30d2ed
callq 0x1bbe0
jmp 0x20f00
movq -0x58(%rbp), %rd... | /qpdf[P]qpdf/libqpdf/BufferInputSource.cc |
BufferInputSource::read(char*, unsigned long) | size_t
BufferInputSource::read(char* buffer, size_t length)
{
if (this->cur_offset < 0) {
throw std::logic_error("INTERNAL ERROR: BufferInputSource offset < 0");
}
qpdf_offset_t end_pos = this->max_offset;
if (this->cur_offset >= end_pos) {
this->last_offset = end_pos;
return 0;
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, 0xd8(%rax)
jge 0x21369
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq 0x2ebfbc(%rip), %rsi # 0x30d2ed
c... | /qpdf[P]qpdf/libqpdf/BufferInputSource.cc |
QIntC::IntConverter<unsigned long, long long, false, true>::convert(unsigned long const&) | inline static To
convert(From const& i)
{
// From is unsigned, and to is signed. Convert To's max to the
// unsigned version of To and compare i against that.
auto maxval = static_cast<typename to_u<To>::type>(std::numeric_limits<To>::max());
if (i > maxva... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x21650
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jbe 0x2163e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x21660
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
void QIntC::range_check_error<long long>(long long const&, long long const&) | void
range_check_error(T const& cur, T const& delta)
{
if ((delta > 0) && ((std::numeric_limits<T>::max() - cur) < delta)) {
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "adding " << delta << " to " << cur << " would cause an integer overflow";
... | pushq %rbp
movq %rsp, %rbp
subq $0x3e0, %rsp # imm = 0x3E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jle 0x21a53
callq 0x21650
movq -0x8(%rbp), %rcx
subq (%rcx), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x21a53
leaq -0x188(%rbp), %rdi
callq 0x1be00
movq -0... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
QIntC::IntConverter<long long, unsigned long, true, false>::error(long long) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte signed type to a " << sizeof(To) << "-byte unsigned type";
throw s... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1be00
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0x21d13
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rbp... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
FileInputSource::seek(long long, int) | void
FileInputSource::seek(qpdf_offset_t offset, int whence)
{
if (QUtil::seek(this->file, offset, whence) == -1) {
QUtil::throw_system_error(
std::string("seek to ") + this->filename + ", offset " + std::to_string(offset) + " (" +
std::to_string(whence) + ")");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x158(%rbp)
movq 0xd0(%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x2aff70
cmpl $-0x1, %eax
jne 0x246e4
leaq -0xf9(%rbp), %rdi
m... | /qpdf[P]qpdf/libqpdf/FileInputSource.cc |
FileInputSource::read(char*, unsigned long) | size_t
FileInputSource::read(char* buffer, size_t length)
{
this->last_offset = QUtil::tell(this->file);
size_t len = fread(buffer, 1, length, this->file);
if (len == 0) {
if (ferror(this->file)) {
throw QPDFExc(
qpdf_e_system,
this->filename,
... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq 0xd0(%rax), %rdi
callq 0x2affb0
movq %rax, %rcx
movq -0xf0(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp),... | /qpdf[P]qpdf/libqpdf/FileInputSource.cc |
InputSource::read_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long, long long) | size_t
InputSource::read_line(std::string& str, size_t count, qpdf_offset_t at)
{
// Return at most max_line_length characters from the next line. Lines are terminated by one or
// more \r or \n characters. Consume the trailing newline characters but don't return them.
// After this is called, the file will... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x25820
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x2e... | /qpdf[P]qpdf/libqpdf/InputSource.cc |
InputSource::findFirst(char const*, long long, unsigned long, InputSource::Finder&) | bool
InputSource::findFirst(char const* start_chars, qpdf_offset_t offset, size_t len, Finder& finder)
{
// Basic approach: search for the first character of start_chars starting from offset but not
// going past len (if len != 0). Once the first character is found, see if it is the beginning
// of a sequen... | pushq %rbp
movq %rsp, %rbp
subq $0x4e0, %rsp # imm = 0x4E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x490(%rbp)
movq $0x400, -0x448(%rbp) # imm = 0x400
movq -0x18(%rbp), %rdi
callq 0x1b5a0
cmpq $0x1, %... | /qpdf[P]qpdf/libqpdf/InputSource.cc |
InputSource::findLast(char const*, long long, unsigned long, InputSource::Finder&) | bool
InputSource::findLast(char const* start_chars, qpdf_offset_t offset, size_t len, Finder& finder)
{
bool found = false;
qpdf_offset_t after_found_offset = 0;
qpdf_offset_t cur_offset = offset;
size_t cur_len = len;
while (this->findFirst(start_chars, cur_offset, cur_len, finder)) {
if (f... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x29(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
mov... | /qpdf[P]qpdf/libqpdf/InputSource.cc |
InputSource::read_line[abi:cxx11](unsigned long, long long) | inline std::string
InputSource::read_line(size_t count, qpdf_offset_t at)
{
std::string result(count, '\0');
read_line(result, count, at);
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x... | /qpdf[P]qpdf/libqpdf/InputSource.cc |
QIntC::IntConverter<long, unsigned long, true, false>::convert(long const&) | inline static To
convert(From const& i)
{
// From is signed, and To is unsigned. If i > 0, it's safe to
// convert it to the corresponding unsigned type and to
// compare with To's max.
auto ii = static_cast<typename to_u<From>::type>(i);
if ((... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jl 0x25b7a
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x21cc0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jbe 0x25b86
movq -0x8(%rb... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
QIntC::IntConverter<long, unsigned long, true, false>::error(long) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte signed type to a " << sizeof(To) << "-byte unsigned type";
throw s... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1be00
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0x25be3
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rbp... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
InsecureRandomDataProvider::random() | long
InsecureRandomDataProvider::random()
{
if (!this->seeded_random) {
// Seed the random number generator with something simple, but just to be interesting, don't
// use the unmodified current time. It would be better if this were a more secure seed.
auto seed = static_cast<unsigned int>(... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x8(%rax)
jne 0x25e88
callq 0x2b0cc0
xorq $0xcccc, %rax # imm = 0xCCCC
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x1c010
movq -0x18(%rbp), %rax
movb $0x1, 0x8(%rax)
callq 0x1c090
... | /qpdf[P]qpdf/libqpdf/InsecureRandomDataProvider.cc |
JSON::writeClose(Pipeline*, bool, unsigned long, char const*) | void
JSON::writeClose(Pipeline* p, bool first, size_t depth, char const* delimiter)
{
if (first) {
*p << delimiter;
} else {
std::string s{"\n"};
s.append(2 * depth, ' ');
*p << s + delimiter;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
testb $0x1, -0x9(%rbp)
je 0x260d7
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x46eb0
jmp 0x261a3
leaq -0x41(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq ... | /qpdf[P]qpdf/libqpdf/JSON.cc |
JSON::writeNext(Pipeline*, bool&, unsigned long) | void
JSON::writeNext(Pipeline* p, bool& first, size_t depth)
{
if (first) {
first = false;
std::string s{"\n"};
s.append(2 * depth, ' ');
*p << s;
} else {
std::string s{",\n"};
s.append(2 * depth, ' ');
*p << s;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0x2627f
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1be40
movq -0x80(%rbp), %rdx
leaq 0x3098f2(%rip), %rsi # ... | /qpdf[P]qpdf/libqpdf/JSON.cc |
JSON::JSON_dictionary::write(Pipeline*, unsigned long) const | void
JSON::JSON_dictionary::write(Pipeline* p, size_t depth) const
{
bool first = true;
writeDictionaryOpen(p, first, depth);
for (auto const& iter: members) {
writeDictionaryItem(p, first, iter.first, iter.second, 1 + depth);
}
writeDictionaryClose(p, first, depth);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x1, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x19(%rbp), %rsi
callq 0x26330
movq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(... | /qpdf[P]qpdf/libqpdf/JSON.cc |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.