name string | code string | asm string | file string |
|---|---|---|---|
cnn::Max::as_string(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const | string Max::as_string(const vector<string>& arg_names) const {
ostringstream s;
s << "max{" << arg_names[0] << ", " << arg_names[1] << "}";
return s.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
leaq 0x8(%rsp), %r15
movq %rdi, %rbx
movq %rdx, %r14
movq %r15, %rdi
callq 0xbf5a0
leaq 0x57172(%rip), %rsi # 0x188004
movq %r15, %rdi
callq 0xbf470
movq (%r14), %rsi
movq %rax, %rdi
callq 0xbf410
leaq 0x57ac5(%rip), %rsi # 0x188971
mov... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::InnerProduct3D_1D::dim_forward(std::vector<cnn::Dim, std::allocator<cnn::Dim>> const&) const | Dim InnerProduct3D_1D::dim_forward(const vector<Dim>& xs) const {
if (xs.size() != 2 && xs.size() != 3)
throw std::invalid_argument("Expected two or three arguments in InnerProduct3D_1D");
if (xs[0].ndims() != 3 ||
xs[1].ndims() != 1 ||
xs[0].size(2) != xs[1].size(0)) {
ostringstream s; s << "Ba... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq (%rdx), %rcx
movq 0x8(%rdx), %rax
movq %rdx, %rbx
subq %rcx, %rax
pushq $0x24
popq %rsi
cqto
idivq %rsi
andq $-0x2, %rax
cmpq $0x2, %rax
jne 0x131a62
cmpl $0x3, 0x1c(%rcx)
jne 0x1319f4
cmpl $0x1, 0x40(%rcx)
jne 0x1319f4
movl 0x8(%rcx), %ea... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::BlockDropout::as_string(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const | string BlockDropout::as_string(const vector<string>& arg_names) const {
ostringstream s;
s << "block_dropout(" << arg_names[0] << ",dropout_probability=" << dropout_probability << ')';
return s.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0xbf5a0
leaq 0x5648b(%rip), %rsi # 0x1884a0
movq %r12, %rdi
callq 0xbf470
movq (%r15), %rsi
movq %rax, %rdi
callq 0xbf410
leaq 0x56480(%rip), %... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::Sum::as_string(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const | string Sum::as_string(const vector<string>& arg_names) const {
ostringstream s;
s << arg_names[0];
for (unsigned i = 1; i < arg_names.size(); ++i)
s << " + " << arg_names[i];
return s.str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp # imm = 0x180
leaq 0x8(%rsp), %r15
movq %rdi, %rbx
movq %rdx, %r14
movq %r15, %rdi
callq 0xbf5a0
movq (%r14), %rsi
movq %r15, %rdi
callq 0xbf410
pushq $0x1
popq %r13
leaq 0x55e77(%rip), %r15 # 0x18833a
leaq 0x8(%rsp), %r12
movq 0x8(... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::Erf::as_string(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const | string Erf::as_string(const vector<string>& arg_names) const {
ostringstream s;
s << "erf(" << arg_names[0] << ')';
return s.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
leaq 0x8(%rsp), %r15
movq %rdi, %rbx
movq %rdx, %r14
movq %r15, %rdi
callq 0xbf5a0
leaq 0x55c52(%rip), %rsi # 0x1886ca
movq %r15, %rdi
callq 0xbf470
movq (%r14), %rsi
movq %rax, %rdi
callq 0xbf410
pushq $0x29
popq %rsi
movq %rax, %rdi
callq... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::Exp::as_string(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const | string Exp::as_string(const vector<string>& arg_names) const {
ostringstream os;
os << "exp(" << arg_names[0] << ')';
return os.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
leaq 0x8(%rsp), %r15
movq %rdi, %rbx
movq %rdx, %r14
movq %r15, %rdi
callq 0xbf5a0
leaq 0x55a4c(%rip), %rsi # 0x1887dc
movq %r15, %rdi
callq 0xbf470
movq (%r14), %rsi
movq %rax, %rdi
callq 0xbf410
pushq $0x29
popq %rsi
movq %rax, %rdi
callq... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::PairwiseRankLoss::dim_forward(std::vector<cnn::Dim, std::allocator<cnn::Dim>> const&) const | Dim PairwiseRankLoss::dim_forward(const vector<Dim>& xs) const {
if (xs.size() != 2 ||
xs[0] != xs[1] ||
xs[0].rows() != 1 ||
(xs[0].ndims() != 1 && xs[0].ndims() != 2)) {
ostringstream s; s << "Bad input dimensions in PairwiseRankLoss: " << xs;
throw std::invalid_argument(s.str());
}
re... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, %r14
movq (%rdx), %rdi
movq 0x8(%rdx), %rax
movq %rdx, %rbx
subq %rdi, %rax
cmpq $0x48, %rax
jne 0x13355a
leaq 0x24(%rdi), %rsi
callq 0x135a23
testb %al, %al
jne 0x13355a
movq (%rbx), %rax
cmpl $0x1, (%rax)
jne 0x13355a
movl 0x1c(%ra... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::Hinge::as_string(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const | string Hinge::as_string(const vector<string>& arg_names) const {
ostringstream os;
os << "hinge(" << arg_names[0] << ", pe=" << pelement << ", m=" << margin << ')';
return os.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0xbf5a0
leaq 0x5537c(%rip), %rsi # 0x18899f
movq %r12, %rdi
callq 0xbf470
movq (%r15), %rsi
movq %rax, %rdi
callq 0xbf410
leaq 0x55369(%rip), %... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::SoftSign::as_string(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const | string SoftSign::as_string(const vector<string>& arg_names) const {
ostringstream s;
s << "softsign(" << arg_names[0] << ')';
return s.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
leaq 0x8(%rsp), %r15
movq %rdi, %rbx
movq %rdx, %r14
movq %r15, %rdi
callq 0xbf5a0
leaq 0x550c2(%rip), %rsi # 0x188a76
movq %r15, %rdi
callq 0xbf470
movq (%r14), %rsi
movq %rax, %rdi
callq 0xbf410
pushq $0x29
popq %rsi
movq %rax, %rdi
callq... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::RestrictedLogSoftmax::as_string(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const | string RestrictedLogSoftmax::as_string(const vector<string>& arg_names) const {
ostringstream s;
s << "r_log_softmax(" << arg_names[0] << ')';
return s.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
leaq 0x8(%rsp), %r15
movq %rdi, %rbx
movq %rdx, %r14
movq %r15, %rdi
callq 0xbf5a0
leaq 0x54c6b(%rip), %rsi # 0x188bc9
movq %r15, %rdi
callq 0xbf470
movq (%r14), %rsi
movq %rax, %rdi
callq 0xbf410
pushq $0x29
popq %rsi
movq %rax, %rdi
callq... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::PickElement::as_string(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const | string PickElement::as_string(const vector<string>& arg_names) const {
ostringstream s;
s << "pick(" << arg_names[0] << ',' << *pval << ')';
return s.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0xbf5a0
leaq 0x54b66(%rip), %rsi # 0x188c55
movq %r12, %rdi
callq 0xbf470
movq (%r15), %rsi
movq %rax, %rdi
callq 0xbf410
pushq $0x2c
popq %rsi... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::PickRange::dim_forward(std::vector<cnn::Dim, std::allocator<cnn::Dim>> const&) const | Dim PickRange::dim_forward(const vector<Dim>& xs) const {
assert(xs.size() == 1);
if (!LooksLikeVector(xs[0])) {
ostringstream s; s << "Bad input dimensions in PickElement: " << xs;
throw std::invalid_argument(s.str());
}
assert(end <= xs[0][0]);
return Dim({end - start}, xs[0].bd);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
movq (%rdx), %rdi
movq 0x8(%rdx), %rax
subq %rdi, %rax
cmpq $0x24, %rax
jne 0x134399
movq %rdx, %r14
movq %rsi, %r15
callq 0x135a5a
testb %al, %al
je 0x1343b8
movq (%r14), %rax
movl 0x54(%r15), %ecx
cmpl $0x0, 0x1c(%r... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::AffineTransform::as_string(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const | string AffineTransform::as_string(const vector<string>& arg_names) const {
ostringstream s;
s << arg_names[0];
for (unsigned i = 1; i < arg_names.size(); i += 2)
s << " + " << arg_names[i] << " * " << arg_names[i+1];
return s.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
leaq 0x10(%rsp), %r15
movq %rdi, %rbx
movq %rdx, %r14
movq %r15, %rdi
callq 0xbf5a0
movq (%r14), %rsi
movq %r15, %rdi
callq 0xbf410
movq %rbx, 0x8(%rsp)
pushq $0x2
popq %rbx
leaq 0x53754(%rip), %r15 # 0x1883... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::L1Distance::as_string(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const | string L1Distance::as_string(const vector<string>& arg_names) const {
ostringstream s;
s << "|| " << arg_names[0] << " - " << arg_names[1] << " ||_1";
return s.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
leaq 0x8(%rsp), %r15
movq %rdi, %rbx
movq %rdx, %r14
movq %r15, %rdi
callq 0xbf5a0
leaq 0x600d(%rip), %rsi # 0x13b213
movq %r15, %rdi
callq 0xbf470
movq (%r14), %rsi
movq %rax, %rdi
callq 0xbf410
leaq 0x53332(%rip), %rsi # 0x188552
mov... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::LogisticSigmoid::as_string(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const | string LogisticSigmoid::as_string(const vector<string>& arg_names) const {
ostringstream s;
s << "\\sigma(" << arg_names[0] << ')';
return s.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
leaq 0x8(%rsp), %r15
movq %rdi, %rbx
movq %rdx, %r14
movq %r15, %rdi
callq 0xbf5a0
leaq 0x53a3f(%rip), %rsi # 0x189189
movq %r15, %rdi
callq 0xbf470
movq (%r14), %rsi
movq %rax, %rdi
callq 0xbf410
pushq $0x29
popq %rsi
movq %rax, %rdi
callq... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::LookupNode::accumulate_grad(cnn::Tensor const&) | void LookupNode::accumulate_grad(const Tensor& g) {
if(pindex) {
params->accumulate_grad(*pindex, g);
} else {
assert (pindices);
const vector<Tensor>& gb = g.batch_elems();
for (unsigned b = 0; b < pindices->size(); ++b) {
unsigned i = pindices->at(b);
assert (i < params->values.size())... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x78(%rdi), %rax
movq %rsi, %rdx
movq %rdi, %rbx
testq %rax, %rax
je 0x1367e3
movq 0xa0(%rbx), %rdi
movl (%rax), %esi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xd0cba
cmpq $0x0, 0x98(%rbx)
je 0x136888
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x1368de
xo... | /LeonCrashCode[P]LookAheadFeature/cnn/param-nodes.cc |
cnn::SimpleRNNBuilder::SimpleRNNBuilder(unsigned int, unsigned int, unsigned int, cnn::Model*, bool) | SimpleRNNBuilder::SimpleRNNBuilder(unsigned layers,
unsigned input_dim,
unsigned hidden_dim,
Model* model,
bool support_lags) : layers(layers), lagging(support_lags) {
unsigned layer_input_dim = input_dim;
for (unsigned i = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq 0x80df9(%rip), %rax # 0x1b7a20
orl $-0x1, 0x8(%rdi)
vxorps %xmm0, %xmm0, %xmm0
movl %ecx, %r13d
leaq 0x28(%rdi), %rcx
leaq 0x50(%rsp), %r14
leaq 0x30(%rsp), %rbp
movq %r8, %r15
movq %rdi, 0x18(%rsp)
vmovups %xmm0, 0xc(%rdi)
vmov... | /LeonCrashCode[P]LookAheadFeature/cnn/rnn.cc |
cnn::SimpleRNNBuilder::start_new_sequence_impl(std::vector<cnn::expr::Expression, std::allocator<cnn::expr::Expression>> const&) | void SimpleRNNBuilder::start_new_sequence_impl(const vector<Expression>& h_0) {
h.clear();
h0 = h_0;
if (h0.size()) { assert(h0.size() == layers); }
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x58, %rdi
movq %rsi, %r14
callq 0xcf68e
leaq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x137614
movq 0x78(%rbx), %rax
movq 0x70(%rbx), %rcx
subq %rcx, %rax
je 0x136fd3
movl 0x88(%rbx), %ecx
sarq $0x4, %rax
cmpq %rcx, %rax
jne 0x136fdb
addq $0x8, %rsp
popq %rbx
popq %... | /LeonCrashCode[P]LookAheadFeature/cnn/rnn.cc |
cnn::TensorTools::Constant(cnn::Tensor&, float) | void TensorTools::Constant(Tensor& d, float c) {
#if HAVE_CUDA
if (!c) {
CUDA_CHECK(cudaMemsetAsync(d.v, 0, d.d.size() * sizeof(float)));
} else {
fill(d.v, d.v + d.d.size(), c);
}
#else
if (!c) {
memset(d.v, c, d.d.size() * sizeof(float));
} else {
fill(d.v, d.v + d.d.size(), c);
}
#endif
} | pushq %rbx
subq $0x10, %rsp
movq 0x28(%rdi), %rbx
vmovss %xmm0, 0xc(%rsp)
callq 0xc6d22
vmovss 0xc(%rsp), %xmm1
vxorps %xmm0, %xmm0, %xmm0
movl %eax, %edx
vucomiss %xmm0, %xmm1
je 0x137b58
shlq $0x2, %rdx
vmovaps %xmm1, %xmm0
xorl %eax, %eax
cmpq %rax, %rdx
je 0x137b52
vmovss %xmm0, (%rbx,%rax)
addq $0x4, %rax
jmp 0x13... | /LeonCrashCode[P]LookAheadFeature/cnn/tensor.cc |
cnn::Conv1DNarrow::dim_forward(std::vector<cnn::Dim, std::allocator<cnn::Dim>> const&) const | Dim Conv1DNarrow::dim_forward(const vector<Dim>& xs) const {
if (xs.size() != 2) {
cerr << "Conv1DNarrow requires two inputs: " << xs << endl;
throw std::invalid_argument("Conv1DNarrow requires 2 dimensions");
}
unsigned ocols = xs[0].cols() - xs[1].cols() + 1;
if (xs[0].ndims() != 2 || xs[1].ndims() !=... | pushq %r14
pushq %rbx
pushq %rax
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq %rdx, %rbx
subq %rax, %rcx
cmpq $0x48, %rcx
jne 0x138fde
movq %rdi, %r14
movl 0x1c(%rax), %edi
movl 0x40(%rax), %esi
pushq $0x1
popq %rdx
movl %edx, %ecx
cmpl $0x2, %edi
jb 0x138f5f
movl 0x4(%rax), %ecx
cmpl $0x2, %esi
jb 0x138f67
movl 0x28(%r... | /LeonCrashCode[P]LookAheadFeature/cnn/conv.cc |
cnn::Conv1DWide::as_string(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const | string Conv1DWide::as_string(const vector<string>& arg_names) const {
ostringstream os;
os << "conv1d_wide(" << arg_names[0] << ", f=" << arg_names[1] << ')';
return os.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
leaq 0x8(%rsp), %r15
movq %rdi, %rbx
movq %rdx, %r14
movq %r15, %rdi
callq 0xbf5a0
leaq 0x50f7e(%rip), %rsi # 0x18a2e0
movq %r15, %rdi
callq 0xbf470
movq (%r14), %rsi
movq %rax, %rdi
callq 0xbf410
leaq 0x50e41(%rip), %rsi # 0x18a1bd
mov... | /LeonCrashCode[P]LookAheadFeature/cnn/conv.cc |
cnn::Conv1DWide::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void Conv1DWide::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
#ifdef HAVE_CUDA
throw std::runtime_error("Conv1DWide::backward not implement... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
cmpl $0x2, %r8d
jae 0x13979b
movq (%rsi), %rax
movq %r9, %r14
movl %r8d, %ebp
movq %rsi, %rbx
movq (%rax), %rdx
movq 0x8(%rax), %rax
cmpl $0x2, 0x1c(%rdx)
pushq $0x1
popq %r15
movl %r15d, %r12d
jb 0x13960c
movl 0x4(%rdx), %r12d
movl (%rd... | /LeonCrashCode[P]LookAheadFeature/cnn/conv.cc |
cnn::KMaxPooling::forward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor&) const | void KMaxPooling::forward_impl(const vector<const Tensor*>& xs, Tensor& fx) const {
#ifdef HAVE_CUDA
throw std::runtime_error("KMaxPooling::forward not implemented for CUDA");
#else
auto x=**xs[0];
auto y=*fx;
float tmp[1024];
assert(x.cols() < 1024);
unsigned mi = 0;
const unsigned rows = x.rows();
con... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1088, %rsp # imm = 0x1088
movq (%rsi), %rax
leaq 0x60(%rsp), %r15
movq %rdi, %rbx
movq %rdx, %r14
movq %r15, %rdi
movq (%rax), %rsi
callq 0xd11ee
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0xd114a
movq 0x10(%r15), %rax
cmpq $0x400, %ra... | /LeonCrashCode[P]LookAheadFeature/cnn/conv.cc |
cnn::KMaxPooling::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void KMaxPooling::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
#ifdef HAVE_CUDA
throw std::runtime_error("KMaxPooling::backward not imp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl 0x20(%rdi), %eax
cmpl $0x2, 0x3c(%rdi)
leaq 0x20(%rdi), %rbx
movq %r9, (%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
pushq $0x1
popq %rax
cmovael 0x24(%rdi), %eax
movq 0x48(%rdi), %rcx
leaq 0x38(%rsp), %r1... | /LeonCrashCode[P]LookAheadFeature/cnn/conv.cc |
cnn::operator<<(std::ostream&, cnn::Dim const&) | ostream& operator<<(ostream& os, const Dim& d) {
os << '{';
for (unsigned i = 0; i < d.nd; ++i) {
if (i) os << ',';
os << d.d[i];
}
if(d.bd != 1) os << 'X' << d.bd;
return os << '}';
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x7b
popq %rsi
callq 0xbf4e0
xorl %r15d, %r15d
pushq $0x2c
popq %rbp
movl 0x1c(%r14), %eax
cmpq %rax, %r15
jae 0x13a680
testq %r15, %r15
je 0x13a66f
movq %rbx, %rdi
movl %ebp, %esi
callq 0xbf4e0
movl (%r14,%r15,4), %esi
movq %... | /LeonCrashCode[P]LookAheadFeature/cnn/dim.cc |
cnn::operator<<(std::ostream&, std::vector<cnn::Dim, std::allocator<cnn::Dim>> const&) | ostream& operator<<(ostream& os, const vector<Dim>& ds) {
os << '[';
for (unsigned i = 0; i < ds.size(); ++i)
os << (i ? " " : "") << ds[i];
return os << ']';
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x5b
popq %rsi
callq 0xbf4e0
xorl %eax, %eax
pushq $0x24
popq %r15
leaq 0x3bb9(%rip), %r12 # 0x13e292
leaq 0x4df2b(%rip), %r13 # 0x18860b
movl %eax, %ebp
movq 0x8(%r14), %rax
subq (%r14), %rax
cq... | /LeonCrashCode[P]LookAheadFeature/cnn/dim.cc |
dtype_isvalid | static int
dtype_isvalid(const char * dtype)
{
if(!dtype)
return 0;
switch(dtype[0]) {
case '<':
case '>':
case '|':
case '=':
break;
default:
return 0;
}
switch(dtype[1]) {
case 'S':
case 'b':
case 'i':
... | xorl %eax, %eax
testq %rdi, %rdi
je 0x3c2e
movzbl (%rdi), %ecx
leal -0x3c(%rcx), %edx
cmpl $0x3, %edx
jb 0x3bf8
cmpl $0x7c, %ecx
jne 0x3c2e
movzbl 0x1(%rdi), %ecx
addl $-0x53, %ecx
cmpl $0x22, %ecx
ja 0x3c2e
movabsq $0x400498001, %rdx # imm = 0x400498001
btq %rcx, %rdx
jae 0x3c2e
pushq %rax
addq $0x2, %rdi
callq 0... | /rainwoodman[P]bigfile/src/bigfile.c |
dtype_convert | int
_dtype_convert(BigArrayIter * dst, BigArrayIter * src, size_t nmemb)
{
/* cast buf2 of dtype2 into buf1 of dtype1 */
/* match src to machine endianness */
if(src->array->dtype[0] != MACHINE_ENDIANNESS) {
BigArrayIter iter = *src;
byte_swap(&iter, nmemb);
}
BigArrayIter iter1 = *... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x358, %rsp # imm = 0x358
movq %rdx, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movq 0x100(%rsi), %rax
cmpb $0x3c, 0x4(%rax)
je 0x52f6
leaq 0x10(%rsp), %r15
movl $0x118, %edx # imm = 0x118
movq %r15, %rdi
movq %rbx, %rsi
callq ... | /rainwoodman[P]bigfile/src/bigfile.c |
os_gen_temp_filename | int
os_gen_temp_filename( char* buf, size_t buflen )
{
// Get the temporary directory: use the environment variable TMPDIR
// if it's defined, otherwise use P_tmpdir; if even that's not
// defined, return failure.
const char* tmp = getenv("TMPDIR");
if (tmp == 0)
tmp = P_tmpdir;
if (tmp ... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xc4636(%rip), %rdi # 0x190038
callq 0xc8420
testq %rax, %rax
leaq 0xc462e(%rip), %rcx # 0x19003f
cmovneq %rax, %rcx
leaq 0xc4628(%rip), %rdx # 0x190044
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xc85c0
movq %r... | /realnc[P]frobtads/src/osportable.cc |
CTcMake::set_compiler_options() | void CTcMake::set_compiler_options()
{
CTcMakePath *inc;
CTcMakeDef *def;
char buf[256];
/* set the error verbosity and warning level modes */
G_tcmain->set_verbosity(verbose_);
G_tcmain->set_show_err_numbers(show_err_numbers_);
G_tcmain->set_pedantic(pedantic_);
G_tcmain->set_suppr... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x100, %rsp # imm = 0x100
movq %rdi, %rbx
leaq 0x16c3ac(%rip), %rax # 0x23d7a8
movq (%rax), %rax
xorl %ecx, %ecx
cmpl $0x0, 0x8c(%rdi)
setne %cl
movq 0x18(%rax), %rdx
andq $-0x2, %rdx
orq %rdx, %rcx
movq %rcx, 0x18(%rax)
xorl %edx, %edx
cmpl $0x... | /realnc[P]frobtads/tads3/tcmake.cpp |
CTcParser::parse_function(int*, int, int, int, int) | CTPNStmTop *CTcParser::parse_function(int *err, int is_extern,
int replace, int modify,
int func_kw_present)
{
CTcToken tok;
CTcSymFunc *func_sym;
CTPNCodeBody *code_body;
int has_proto = TRUE;
int argc;
int opt_argc;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, 0x18(%rsp)
movl %ecx, %r13d
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
movq $0x0, 0x20(%rsp)
testl %r9d, %r9d
je 0xd92ba
leaq 0x164521(%rip), %rax # 0x23d7c0
movq (%rax), %rdi
xorl %r15d, %r15d
cmpl $0x80, 0xcc8(%rdi)
... | /realnc[P]frobtads/tads3/tcprsprg.cpp |
CTcParser::add_export_to_list(CTcPrsExport*) | void CTcParser::add_export_to_list(CTcPrsExport *exp)
{
/* link it at the end of our list */
if (exp_tail_ == 0)
exp_head_ = exp;
else
exp_tail_->set_next(exp);
exp_tail_ = exp;
} | movq 0x1e0(%rdi), %rax
leaq 0x20(%rax), %rcx
leaq 0x1d8(%rdi), %rdx
testq %rax, %rax
cmoveq %rdx, %rcx
movq %rsi, (%rcx)
movq %rsi, 0x1e0(%rdi)
retq
| /realnc[P]frobtads/tads3/tcprsprg.cpp |
CTcParser::parse_template_def(int*, CTcToken const*) | CTPNStmTop *CTcParser::parse_template_def(int *err, const CTcToken *class_tok)
{
CTcToken prop_tok;
CTcObjTemplateItem *alt_group_head;
CTcObjTemplateItem *item_head;
CTcObjTemplateItem *item_tail;
CTcSymObj *class_sym;
/* no items in our list yet */
item_head = item_tail = alt_group_head =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
testq %rdx, %rdx
je 0xdc608
movq %rdx, %r14
movq %rsi, %r15
leaq 0xc2a20(%rip), %rsi # 0x19efbf
movq %rdx, %rdi
callq 0xddc6a
testl %eax, %eax
je 0xdc5bd
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0xdcdfc
jmp 0... | /realnc[P]frobtads/tads3/tcprsprg.cpp |
CTcParser::add_inherited_templates(CTcSymObj*, CTcObjTemplateItem*, unsigned long) | void CTcParser::add_inherited_templates(CTcSymObj *sc_sym,
CTcObjTemplateItem *item_head,
size_t item_cnt)
{
inh_tpl_entry *head;
inh_tpl_entry *tail;
inh_tpl_entry *cur;
CTcObjTemplate *tpl;
/* start with an empty ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
movq %r12, %rsi
movq %r14, %rcx
callq 0xdd1fc
movq (%r12), %r12
testq %r12, %r12
je 0xdd114
movq (%r12), %rcx
movq %... | /realnc[P]frobtads/tads3/tcprsprg.cpp |
CTPNStmProg::fold_constants(CTcPrsSymtab*) | CTcPrsNode *CTPNStmProg::fold_constants(class CTcPrsSymtab *symtab)
{
CTPNStmTop *cur;
/* iterate through our statements and fold constants in each one */
for (cur = first_stm_ ; cur != 0 ; cur = cur->get_next_stm_top())
cur->fold_constants(symtab);
/*
* although nodes within our subtr... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r15
testq %r15, %r15
je 0xdd959
movq %rsi, %r14
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x78(%rax)
movq 0x28(%r15), %r15
testq %r15, %r15
jne 0xdd944
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
| /realnc[P]frobtads/tads3/tcprsprg.cpp |
CTcDictEntry::CTcDictEntry(CTcSymObj*) | CTcDictEntry::CTcDictEntry(CTcSymObj *sym)
{
const size_t hash_table_size = 128;
/* remember my object symbol and word truncation length */
sym_ = sym;
/* no object file index yet */
obj_idx_ = 0;
/* not in a list yet */
nxt_ = 0;
/* create my hash table */
hashtab_ = new (G_prsm... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rdi)
movl $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x15fde4(%rip), %r12 # 0x23d7b8
movq (%r12), %rdi
movl $0x20, %esi
callq 0xf6934
movq %rax, %r14
movq (%r12), %rdi
movl $0x8, %esi
callq 0xf6934
movq %rax, %r15
leaq 0x144e4b(%rip)... | /realnc[P]frobtads/tads3/tcprsprg.cpp |
CTcGenTarg::write_metadep_to_object_file(CVmFile*) | void CTcGenTarg::write_metadep_to_object_file(CVmFile *fp)
{
tc_meta_entry *cur;
/* write the count */
fp->write_uint2(meta_cnt_);
/* write the entries */
for (cur = meta_head_ ; cur != 0 ; cur = cur->nxt)
{
size_t len;
len = strlen(cur->nm);
fp->write_uint2(len);
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x30(%rdi), %eax
leaq 0xe(%rsp), %rsi
movw %ax, (%rsi)
movl $0x2, %edx
movq %rbx, %rdi
callq 0xcebfe
movq 0x20(%r14), %r13
testq %r13, %r13
je 0xde1d0
leaq 0xc(%rsp), %r14
leaq 0x10(%r13), %r15
movq %r15, %rdi... | /realnc[P]frobtads/tads3/tct3img.cpp |
CTcGenTarg::add_debug_line_table(unsigned long) | void CTcGenTarg::add_debug_line_table(ulong ofs)
{
size_t idx;
uchar *p;
/* calculate the index of the next free entry on its page */
idx = (size_t)(debug_line_cnt_ % TCT3_DEBUG_LINE_PAGE_SIZE);
/*
* if we've completely filled the last page, allocate a new one - we
* know we've exha... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x3ff, %r15d # imm = 0x3FF
andq 0xb0(%rdi), %r15
je 0xdedef
movq 0xa8(%rbx), %rax
jmp 0xdee1f
movl $0x1408, %edi # imm = 0x1408
callq 0xc8470
movq $0x0, (%rax)
movq 0xa8(%rbx), %rcx
leaq 0xa0(%rbx), %rdx
testq %rcx, %rcx
cmovneq ... | /realnc[P]frobtads/tads3/tct3img.cpp |
CTcGenTarg::build_multimethod_initializers() | void CTcGenTarg::build_multimethod_initializers()
{
tct3_method_gen_ctx genctx;
mminit_ctx ctx;
/* look up the _multiMethodRegister function */
ctx.mmr = (CTcSymFunc *)G_prs->get_global_symtab()->find(
"_multiMethodRegister", 20);
/*
* open the method - it's a static initializer, s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x18(%rsp), %r14
movl %r15d, 0x8(%r14)
leaq 0x15db2e(%rip), %r12 # 0x23d7b0
movq (%r12), %rax
movq 0x80(%rax), %rdi
leaq 0xb28e9(%rip), %rsi # 0x19257d
movl $0x14, %edx
xorl %ecx, %ecx
callq ... | /realnc[P]frobtads/tads3/tct3img.cpp |
CTcGenTarg::build_local_symbol_records(CTcCodeStream*, CVmHashTable*) | void CTcGenTarg::build_local_symbol_records(CTcCodeStream *cs,
CVmHashTable *tab)
{
CTcStreamAnchor *anchor;
/* this only applies for debug format 2+ */
if (G_sizes.dbg_fmt_vsn < 2)
return;
/* go through the list of anchors in the code stream */
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, 0x10(%rsp)
leaq 0x15d793(%rip), %r10 # 0x23d878
cmpl $0x2, 0x18(%r10)
jl 0xe04ec
movq %rsi, %r12
movq 0x48(%rsi), %rax
testq %rax, %rax
je 0xe04ec
movabsq $0x20438d7022c8d47d, %r11 # imm = 0x20438D7022C8D47D
movq %r12, 0x28... | /realnc[P]frobtads/tads3/tct3img.cpp |
CTcGenTarg::write_nontads_objs_to_image(CTcDataStream*, CVmImageWriter*, int, int) | void CTcGenTarg::write_nontads_objs_to_image(CTcDataStream *os,
CVmImageWriter *image_writer,
int meta_idx, int large_objs)
{
/* keep going until we've written the whole file */
for (ulong start_ofs = 0 ; start_ofs < os->g... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, 0xc(%rsp)
movl %ecx, 0x10(%rsp)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0xe0a54
movq %rdx, %r14
movq %rsi, %r15
xorl %r13d, %r13d
leaq 0x20(%rsp), %r12
cmpq %rax, %r13
jae 0xe0a4b
xorl %ebx, %ebx
leaq 0x4(%r13), %rsi
cmpl $0x... | /realnc[P]frobtads/tads3/tct3img.cpp |
CTcGenTarg::linker_ensure_mod_obj(CTcSymMetaclass*) | void CTcGenTarg::linker_ensure_mod_obj(CTcSymMetaclass *mc)
{
/* if there's no modifier object, create one */
if (mc->get_mod_obj() == 0)
{
/* create a modifier object */
CTcSymObj *mod_sym = CTcSymObj::synthesize_modified_obj_sym(FALSE);
/* set it to be an IntrinsicClassModifier ob... | cmpq $0x0, 0x48(%rsi)
je 0xe0fd4
retq
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
xorl %r14d, %r14d
xorl %edi, %edi
callq 0xdc05a
movl $0x3, 0x90(%rax)
movq %rax, 0x48(%rbx)
leaq 0x15c823(%rip), %rcx # 0x23d820
movq (%rcx), %rdx
movl 0x28(%rax), %ecx
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
xorl %r8d, %r8d
xo... | /realnc[P]frobtads/tads3/tct3img.cpp |
CVmConstMapper::alloc_pool_space(unsigned int, unsigned long) | ulong CVmConstMapper::alloc_pool_space(vm_obj_id_t obj_id, size_t len)
{
ulong ret;
/*
* if the data block is too large to fit on a constant pool page, we
* can't store it
*/
if (len > page_size_)
return 0;
/* if the translation page isn't mapped yet, map it */
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq %rdx, 0x8(%rdi)
jae 0xe37ac
xorl %eax, %eax
jmp 0xe382f
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
movq 0x28(%rdi), %r13
movl %esi, %r12d
shrl $0xa, %r12d
cmpq $0x0, (%r13,%r12,8)
jne 0xe37f8
movl $0x2000, %edi # imm = 0x2000
callq 0xc8470
leal... | /realnc[P]frobtads/tads3/vmimgrb.cpp |
prop_compare(void const*, void const*) | static int prop_compare(const void *p1, const void *p2)
{
uint id1, id2;
/* get the ID's */
id1 = osrp2(p1);
id2 = osrp2(p2);
/* compare them and return the result */
return (id1 < id2 ? -1 : id1 == id2 ? 0 : 1);
} | movzwl (%rdi), %eax
xorl %ecx, %ecx
cmpw (%rsi), %ax
setne %cl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovael %ecx, %eax
retq
nop
| /realnc[P]frobtads/tads3/vmimgrb.cpp |
CVmObjDict::rebuild_image(char*, unsigned long) | ulong CVmObjDict::rebuild_image(VMG_ char *buf, ulong buflen)
{
rebuild_ctx ctx;
/*
* calculate the amount of space we need - start with the comparator
* object, which needs four bytes, and the entry count, which needs two
* bytes
*/
ctx.space_needed = 6;
/* enumerate t... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r12
movq $0x6, (%r12)
movq $0x0, 0x8(%r12)
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rdi
leaq 0x59(%rip), %rsi # 0xe3c64
movq %r12, %rdx
callq 0x1619ca
movq (%r12), %rax
cmpq %r15, %rax
ja 0xe3c5... | /realnc[P]frobtads/tads3/vmimgrb.cpp |
CVmObjDict::cvt_const_cb(void*, CVmHashEntry*) | void CVmObjDict::cvt_const_cb(void *ctx0, class CVmHashEntry *entry0)
{
cvt_const_ctx *ctx = (cvt_const_ctx *)ctx0;
CVmHashEntryDict *entry = (CVmHashEntryDict *)entry0;
vm_dict_entry *cur;
/* inspect the items in this entry's list */
for (cur = entry->get_head() ; cur != 0 ; cur = cur->nxt_)
{... | pushq %rax
movq 0x28(%rsi), %rax
testq %rax, %rax
je 0xe3de5
movq (%rdi), %rcx
movq 0x28(%rcx), %rcx
movl (%rax), %edx
movl %edx, %edi
shrl $0xa, %edi
movq (%rcx,%rdi,8), %rdi
testq %rdi, %rdi
je 0xe3ddc
andl $0x3ff, %edx # imm = 0x3FF
cmpq $0x0, (%rdi,%rdx,8)
jne 0xe3de7
movq 0x8(%rax), %rax
testq %rax, %ra... | /realnc[P]frobtads/tads3/vmimgrb.cpp |
CVmObjIterIdx::rebuild_image(char*, unsigned long) | ulong CVmObjIterIdx::rebuild_image(VMG_ char *buf, ulong buflen)
{
/* calculate our data size - just store our entire extension */
size_t copy_size = VMOBJITERIDX_EXT_SIZE;
/* make sure we have room for our data */
if (copy_size > buflen)
return copy_size;
/* copy the data */
memcpy(bu... | cmpq $0x15, %rdx
jb 0xe42ba
movq 0x8(%rdi), %rax
movq 0xd(%rax), %rcx
movq %rcx, 0xd(%rsi)
movups (%rax), %xmm0
movups %xmm0, (%rsi)
movl $0x15, %eax
retq
| /realnc[P]frobtads/tads3/vmimgrb.cpp |
CVmObjHTTPRequest::rebuild_image(char*, unsigned long) | ulong CVmObjHTTPRequest::rebuild_image(VMG_ char *buf, ulong buflen)
{
/* we don't store anything in the image file */
ulong needlen = 0;
/* make sure there's room */
if (needlen > buflen)
return needlen;
/* return the length */
return needlen;
} | xorl %eax, %eax
retq
nop
| /realnc[P]frobtads/tads3/vmimgrb.cpp |
vm_run_preinit(CVmFile*, char const*, CVmFile*, CVmHostIfc*, CVmMainClientIfc*, char const* const*, int, CVmRuntimeSymbols*, CVmRuntimeSymbols*) | void vm_run_preinit(CVmFile *origfp, const char *image_fname,
CVmFile *newfp, class CVmHostIfc *hostifc,
class CVmMainClientIfc *clientifc,
const char *const *argv, int argc,
class CVmRuntimeSymbols *runtime_symtab,
cla... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %r9, 0x10(%rsp)
movq %r8, %rbx
movq %rdx, 0x18(%rsp)
movq %rsi, %r13
movq %rdi, %r15
xorl %ebp, %ebp
movl %ebp, %r14d
movq %r14, (%rsp)
movq %r14, 0x8(%rsp)
leaq 0x108(%rsp), %rsi
movq %rcx, (%rsi)
movq %r8... | /realnc[P]frobtads/tads3/vmpreini.cpp |
CVmImageWriter::finish() | void CVmImageWriter::finish()
{
/* if there's a block open, close it */
end_block();
/*
* write the EOF block - the block contains no data, so simply begin
* and end it
*/
begin_block("EOF ", TRUE);
end_block();
} | pushq %rbx
movq %rdi, %rbx
callq 0xe52da
leaq 0xad32b(%rip), %rsi # 0x1926dd
movq %rbx, %rdi
movl $0x1, %edx
callq 0xe5278
movq %rbx, %rdi
popq %rbx
jmp 0xe52da
| /realnc[P]frobtads/tads3/vmwrtimg.cpp |
CVmImageWriter::write_meta_dep_item(char const*) | void CVmImageWriter::write_meta_dep_item(const char *metaclass_name)
{
/* if we didn't end the previous item's property list, end it now */
end_meta_prop_list();
/* write a placeholder next record offset */
mcld_ofs_pos_ = fp_->get_pos();
fp_->write_uint2(0);
/* write the metaclass name */... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xe55ca
movq (%rbx), %r15
movq (%r15), %rdi
callq 0xc8030
subq 0x8(%r15), %rax
movq %rax, 0x18(%rbx)
movq (%rbx), %rdi
xorl %ebp, %ebp
leaq 0x2(%rsp), %rsi
movw %bp, (%rsi)
movl $0x2, %edx
callq 0xcebfe
movq %rbx, %rdi
movq %r1... | /realnc[P]frobtads/tads3/vmwrtimg.cpp |
CVmImageWriter::fix_pool_def(long, unsigned int) | void CVmImageWriter::fix_pool_def(long def_seek_ofs, uint32_t page_count)
{
long old_pos;
char buf[4];
/* note the file position at entry */
old_pos = fp_->get_pos();
/*
* seek to the original definition block location, plus the size of
* the block header (10 bytes), plus the of... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %r12
movq (%r12), %rdi
callq 0xc8030
movq %rax, %r14
subq 0x8(%r12), %r14
movq (%rbx), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rax
leaq (%r15,%rax), %rsi
addq $0xc, %rsi
xorl %edx, %edx
c... | /realnc[P]frobtads/tads3/vmwrtimg.cpp |
CVmImageWriter::begin_pool_page(unsigned int, unsigned int, int, unsigned char) | void CVmImageWriter::begin_pool_page(uint pool_id, uint32_t page_index,
int mandatory, uchar xor_mask)
{
char buf[16];
/* begin the block */
begin_block("CPPG", mandatory);
/* prepare the prefix */
oswp2(buf, pool_id);
oswp4(buf+2, page_index);
buf[6] =... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
leaq 0xace01(%rip), %rsi # 0x1926f1
movl %ecx, %edx
callq 0xe5278
movq %rsp, %rsi
movw %r14w, (%rsi)
movl %ebp, 0x2(%rsi)
movb %bl, 0x6(%rsi)
movq (%r15), %rdi
movl $0x7, %edx
callq 0xcebfe
... | /realnc[P]frobtads/tads3/vmwrtimg.cpp |
CVmImageWriter::begin_objs_block(unsigned int, int, int) | void CVmImageWriter::begin_objs_block(uint metaclass_idx, int large_objects,
int trans)
{
char buf[16];
uint flags;
/* begin the block */
begin_block("OBJS", TRUE);
/* prepare the flags */
flags = 0;
if (large_objects)
flags |= 1;
if (trans... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xacc31(%rip), %rsi # 0x1926fb
movl $0x1, %edx
callq 0xe5278
xorl %eax, %eax
testl %r15d, %r15d
setne %al
leal 0x2(%rax), %r15d
testl %r14d, %r14d
cmovel %eax, %r15d
movq (%rbx), %r14
... | /realnc[P]frobtads/tads3/vmwrtimg.cpp |
CVmImageWriter::begin_srcf_block(int) | void CVmImageWriter::begin_srcf_block(int count)
{
/*
* begin the block - SRCF blocks are always optional, since they're
* purely for debugging purposes
*/
begin_block("SRCF", FALSE);
/* write the number of entries */
fp_->write_uint2(count);
/* each source line record is 8 by... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0xacb52(%rip), %rsi # 0x192700
xorl %edx, %edx
callq 0xe5278
movq (%r14), %rdi
leaq 0x4(%rsp), %rsi
movw %bx, (%rsi)
movl $0x2, %edx
callq 0xcebfe
movq (%r14), %rdi
leaq 0x6(%rsp), %rsi
movw $0x8, (%rsi)
movl $0x2, %edx
callq 0xcebfe
addq $0x8, %... | /realnc[P]frobtads/tads3/vmwrtimg.cpp |
CVmImageWriter::begin_mhls_block() | void CVmImageWriter::begin_mhls_block()
{
/*
* begin the block - MHLS blocks are always optional, since they're
* purely for debugging purposes
*/
begin_block("MHLS", FALSE);
/* remember where the count goes so we can fix it up later */
mhls_cnt_pos_ = fp_->get_pos();
/* write... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xac81f(%rip), %rsi # 0x19270f
xorl %edx, %edx
callq 0xe5278
movq (%rbx), %r14
movq (%r14), %rdi
callq 0xc8030
subq 0x8(%r14), %rax
movq %rax, 0x60(%rbx)
movq (%rbx), %rdi
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
movl $0x4, %edx
callq 0xcebfe
movq $0x0, 0x68(%rbx)... | /realnc[P]frobtads/tads3/vmwrtimg.cpp |
CVmRun::terminate() | void CVmRun::terminate()
{
/*
* If we're including the profiler in the build, delete its memory
* structures.
*/
#ifdef VM_PROFILER
/* delete the profiler stack */
if (prof_stack_ != 0)
{
t3free(prof_stack_);
prof_stack_ = 0;
}
/* delete the profiler master... | retq
nop
| /realnc[P]frobtads/tads3/vmrun.cpp |
CVmRun::compute_sum(vm_val_t*, vm_val_t const*) | int CVmRun::compute_sum(VMG_ vm_val_t *val1, const vm_val_t *val2)
{
/* the meaning of "add" depends on the type of the first operand */
check_type:
switch(val1->typ)
{
case VM_SSTRING:
/*
* string constant - add the second value to the string, using
* the static string ad... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl (%r14), %eax
cmpl $0x7, %eax
jne 0xe6128
cmpl $0x7, (%rbx)
je 0xe611b
movq %rbx, %rdi
callq 0x18b39c
testl %eax, %eax
je 0xe61cd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18b62e
jmp 0xe60fe
cmpl $0x5, %eax
je 0xe614b
cmpl $0xa, %eax
je 0xe618c
cmpl $0x... | /realnc[P]frobtads/tads3/vmrun.cpp |
CVmRun::compute_sum_lcl_imm(vm_val_t*, vm_val_t const*, int, unsigned char const*) | const uchar *CVmRun::compute_sum_lcl_imm(VMG_ vm_val_t *lclp,
const vm_val_t *ival,
int lclidx, const uchar *p)
{
/* compute the sum, leaving the result in the local */
if (compute_sum(vmg_ lclp, ival))
{
/* success */... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
callq 0xe60f4
testl %eax, %eax
je 0xe650c
movq %rbx, %rax
jmp 0xe6554
movq 0x15625d(%rip), %rax # 0x23c770
leaq 0x10(%rax), %rcx
movq %rcx, 0x156252(%rip) # 0x23c7... | /realnc[P]frobtads/tads3/vmrun.cpp |
CVmRun::do_call(unsigned int, unsigned char const*, unsigned int, vm_rcdesc const*) | const uchar *CVmRun::compute_sum_inc(VMG_ const uchar *p)
{
/* add 1 to the value at TOS, leaving it on the stack */
vm_val_t val2;
val2.set_int(1);
if (compute_sum(vmg_ get(0), &val2))
{
return p;
}
else
{
/* no native implementation - check for an overload */
vm... | pushq %rbx
movl $0x1, 0x151b93(%rip) # 0x23c780
movzwl 0x4(%rdx), %r9d
movq 0x151b77(%rip), %rax # 0x23c770
movq %rax, %r10
subq (%rdi), %r10
sarq $0x4, %r10
addq %r10, %r9
addq $0xb, %r9
cmpq 0x8(%rdi), %r9
ja 0xeadd6
movzwl 0x2(%rdx), %r9d
movl %r9d, %r10d
shll $0x4, %r10d
addq %rax, %r10
addq $0x60, %r10
movq ... | /realnc[P]frobtads/tads3/vmrun.cpp |
vm_rcdesc::init(char const*, vm_val_t const*, unsigned short, vm_val_t*, int) | void vm_rcdesc::init(VMG_ const char *name,
const vm_val_t *self, unsigned short method_idx,
vm_val_t *argp, int argc)
{
this->name = name;
this->bifptr.set_nil();
this->self = *self;
this->method_idx = method_idx;
this->argp = argp;
this->argc = argc;
... | movq %rsi, 0x10(%rdi)
movl $0x1, 0x18(%rdi)
movups (%rdx), %xmm0
movups %xmm0, 0x28(%rdi)
movw %cx, 0x38(%rdi)
movq %r8, (%rdi)
movl %r9d, 0x8(%rdi)
movq 0x1518b6(%rip), %rax # 0x23c798
testq %rax, %rax
je 0xeaeec
movq (%rax), %rax
jmp 0xeaeee
xorl %eax, %eax
movq %rax, 0x40(%rdi)
retq
nop
| /realnc[P]frobtads/tads3/vmrun.cpp |
CVmRun::check_prop_spec_eval(unsigned int, unsigned short) | void CVmRun::check_prop_spec_eval(VMG_ vm_obj_id_t obj, vm_prop_id_t prop)
{
vm_val_t val;
vm_obj_id_t srcobj;
/* get the property value */
if (vm_objp(vmg_ obj)->get_prop(vmg_ prop, &val, obj, &srcobj, 0))
{
/* check the type of the value */
switch(val.typ)
{
case V... | subq $0x18, %rsp
movl %esi, %ecx
leaq 0x1544f1(%rip), %rax # 0x23f828
movq 0x18(%rax), %rax
shrl $0xc, %esi
movq (%rax,%rsi,8), %rax
movl %ecx, %esi
andl $0xfff, %esi # imm = 0xFFF
leaq (%rsi,%rsi,2), %rsi
leaq (%rax,%rsi,8), %rdi
movq (%rdi), %r10
leaq 0x8(%rsp), %rax
leaq 0x4(%rsp), %r8
movl %edx, %esi
... | /realnc[P]frobtads/tads3/vmrun.cpp |
CVmRun::get_fp_at_level(int) | vm_val_t *CVmRun::get_fp_at_level(VMG_ int level) VM_REG_CONST
{
vm_val_t *fp;
const vm_rcdesc *rc;
/* walk up the stack to the desired level */
for (fp = frame_ptr_, rc = 0 ; fp != 0 && level != 0 ; --level)
{
/* if this is a recursive level, count it */
if (rc != 0 && rc->has_... | pushq %rax
movq 0x1513ca(%rip), %rax # 0x23c778
testq %rax, %rax
sete %cl
testl %edi, %edi
sete %dl
orb %cl, %dl
jne 0xeb3fb
xorl %ecx, %ecx
testq %rcx, %rcx
je 0xeb3cf
cmpq $0x0, 0x40(%rcx)
je 0xeb3cf
decl %edi
je 0xeb400
movq -0x48(%rax), %rcx
movq -0x8(%rax), %rax
testq %rax, %rax
je 0xeb3e0
decl %edi
jne 0xeb3bf... | /realnc[P]frobtads/tads3/vmrun.cpp |
CVmRun::push_string(char const*) | void push_string(VMG_ const char *str)
{ push_string(vmg_ str, strlen(str)); } | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsi, %rdi
callq 0xc8160
movq 0x150e48(%rip), %r14 # 0x23c770
leaq 0x10(%r14), %rcx
movq %rcx, 0x150e3d(%rip) # 0x23c770
testq %rbx, %rbx
je 0xeb950
xorl %edi, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x18377c
movl %eax, 0x8(%r14)
movl $0x5, %eax
jmp 0xeb955... | /realnc[P]frobtads/tads3/vmrun.h |
bignum_t<10>::operator-() | bignum_t<prec> operator -()
{
bignum_t<prec> result(this);
CVmObjBigNum::negate(result.ext);
return result;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movw $0xa, (%rbx)
movb $0x0, 0x4(%rbx)
movq %rbx, %rdi
movl $0x1, %edx
callq 0x135ca8
movb 0x4(%rbx), %al
testb $0x8, %al
jne 0xebe20
xorb $0x1, %al
movb %al, 0x4(%rsp)
movq (%rsp), %rax
movzwl 0x8(%rsp), %edx
addq $0x10, %rsp
popq %rbx
retq
nop
| /realnc[P]frobtads/tads3/vmbignum.h |
bignum_t<10>::operator/(long) const | bignum_t operator /(long l) const
{
bignum_t<prec> bl(l);
return *this / bl;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movw $0xa, %bp
leaq 0x16(%rsp), %r14
movw %bp, (%r14)
xorl %r12d, %r12d
movb %r12b, 0x4(%r14)
movq %r14, %rdi
callq 0x135a78
leaq 0x8(%rsp), %r15
movw %bp, (%r15)
movb %r12b, 0x4(%r15)
movq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rdx... | /realnc[P]frobtads/tads3/vmbignum.h |
CVmMetaclassHTTPRequest::create_for_image_load(unsigned int) | void create_for_image_load(VMG_ vm_obj_id_t id)
{
new (vmg_ id) CVmObjHTTPRequest();
G_obj_table->set_obj_gc_characteristics(id, FALSE, FALSE);
G_obj_table->set_obj_transient(id);
} | pushq %rbx
movl %esi, %ebx
movl $0x10, %edi
callq 0x1721a0
leaq 0x11dcd2(%rip), %rcx # 0x20a060
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x153488(%rip), %rax # 0x23f828
movq 0x18(%rax), %rcx
movl %ebx, %edx
shrl $0xc, %edx
movq (%rcx,%rdx,8), %rcx
andl $0xfff, %ebx # imm = 0xFFF
shll $0x3, %ebx
leaq... | /realnc[P]frobtads/tads3/vmhttpreq.h |
memicmp | int
memicmp( const void* s1, const void* s2, size_t len )
{
const auto x1 = std::make_unique<char[]>(len);
const auto x2 = std::make_unique<char[]>(len);
for (size_t i = 0; i < len; ++i) {
x1[i] = tolower(static_cast<const char*>(s1)[i]);
x2[i] = tolower(static_cast<const char*>(s2)[i]);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rdi
callq 0xc8040
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0xc81d0
movq %r14, %rdi
callq 0xc8040
movq %rax, %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r14... | /realnc[P]frobtads/src/missing.cc |
os_remext | void os_remext(char *fn)
{
char *p;
/* scan backwards from the end of the string, looking for a dot */
p = fn + strlen(fn);
while ( p>fn )
{
/* move to the previous character */
p--;
/* if it's a period, we've found the extension */
if ( *p=='.' )
{
... | pushq %rbx
movq %rdi, %rbx
callq 0xc8160
addq %rbx, %rax
cmpq %rbx, %rax
jbe 0xec670
movzbl -0x1(%rax), %ecx
cmpl $0x2f, %ecx
je 0xec670
decq %rax
cmpl $0x2e, %ecx
jne 0xec657
movb $0x0, (%rax)
popq %rbx
retq
| /realnc[P]frobtads/tads2/osnoui.c |
os_get_path_name | void os_get_path_name(char *pathbuf, size_t pathbuflen, const char *fname)
{
const char *lastsep;
const char *p;
size_t len;
int root_path;
#ifdef MSDOS
/*
* Special case for DOS/Windows: If we have a bare drive letter, or an
* explicit current directory path on a drive letter (X... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rdx), %rcx
movq %rdx, %rax
movq %rdx, %rsi
movzbl (%rsi), %edi
cmpl $0x2f, %edi
je 0xec6b3
testl %edi, %edi
jne 0xec6c9
jmp 0xec6d1
movq %rcx, %rdi
movb (%rdi), %r8b
incq %rdi
cmpb $0x2f, %r8b
je 0xec6b6
testb %r8b, %r8b
cmovneq %rsi, %rax
incq ... | /realnc[P]frobtads/tads2/osnoui.c |
build_path | static void build_path(char *fullpathbuf, size_t fullpathbuflen,
const char *path, const char *filename, int canon)
{
size_t plen, flen;
int add_sep;
/* presume we'll copy the entire path */
plen = strlen(path);
#ifdef MSDOS
/*
* On DOS, there's a special case involvi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, 0x4(%rsp)
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rdi
callq 0xc8160
xorl %ebp, %ebp
cmpb $0x2f, (%r14)
movl $0x0, %ecx
cmovneq %rax, %rcx
testq %rcx, %rcx
je 0xec8a1
cmpb $0x0, (%r13,%rcx)
je 0xec... | /realnc[P]frobtads/tads2/osnoui.c |
os_file_names_equal | int os_file_names_equal(const char *a, const char *b)
{
/* start at the end of each name and work backwards */
const char *pa = a + strlen(a), *pb = b + strlen(b);
/* keep going until we reach the start of one or the other path */
for (;;)
{
size_t lena, lenb;
/* get the next earli... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xc8160
movq %rax, %r15
addq %r14, %r15
movq %rbx, %rdi
callq 0xc8160
movq %rax, %r12
addq %rbx, %r12
leaq 0x10(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq ... | /realnc[P]frobtads/tads2/osnoui.c |
oss_parse_posix_tz | int oss_parse_posix_tz(struct os_tzinfo_t *info, const char *tz, size_t len,
int west_is_positive)
{
const char *p;
const char *std_name = 0, *dst_name = 0;
size_t std_name_len = 0, dst_name_len = 0;
int std_ofs = 0, dst_ofs = 0;
struct os_tzrule_t dst_start, dst_end;
/* ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
xorl %r15d, %r15d
movl %r15d, 0x4(%rsp)
movl %r15d, (%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movq %r15, 0x60(%rsp)
movaps %xmm0, 0x30(%rsp)
movq %r15, 0x40(%rsp)
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %... | /realnc[P]frobtads/tads2/osstzprs.c |
CCharmapToLocal::map_utf8_alo(char**, char const*, unsigned long) const | size_t CCharmapToLocal::map_utf8_alo(
char **buf, const char *src, size_t srclen) const
{
/* figure out how much space we need */
size_t buflen = map_utf8(0, 0, src, srclen, 0);
/* allocate the buffer, adding space for null termination */
*buf = (char *)t3malloc(buflen + 1);
/* if that fai... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq (%rdi), %rax
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
movq %r14, %r8
xorl %r9d, %r9d
callq *0x18(%rax)
movq %rax, %r13
leaq 0x1(%rax), %rdi
callq 0xc8470
movq %rax, (%rbx)
movq (%r12), %r10... | /realnc[P]frobtads/tads3/charmap.cpp |
CCharmapToLocal::load_table(_IO_FILE*) | void CCharmapToLocal::load_table(osfildef *fp)
{
ulong startpos;
ulong ofs;
uchar buf[256];
uint cnt;
ulong xbytes;
ulong xchars;
uint next_ofs;
/* note the initial seek position */
startpos = osfpos(fp);
/* read the first entry, which gives the offset of the to-local table... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xc8030
movq %rax, %r15
leaq 0x10(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0xc8530
cmpq $0x1, %rax
jne 0xee6ec
leaq 0x10(%rsp), %r12... | /realnc[P]frobtads/tads3/charmap.cpp |
CCharmapToLocalSB::map(wchar_t, char**, unsigned long*) const | size_t CCharmapToLocalSB::map(wchar_t unicode_char, char **output_ptr,
size_t *output_len) const
{
/* get the mapping */
size_t map_len;
const unsigned char *mapping = get_xlation(unicode_char, &map_len);
/* if we don't have room for one more character, abort */
if... | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %eax
movzbl %ah, %ecx
movq 0x10(%rdi,%rcx,8), %rcx
testq %rcx, %rcx
je 0xee984
movzbl %al, %eax
movl (%rcx,%rax,4), %eax
jmp 0xee986
xorl %eax, %eax
movq 0x1010(%rdi), %rsi
movzbl (%rsi,%rax), %r15d
cmpq %r15, (%rbx)
jae 0xee99b
xorl %eax, %eax... | /realnc[P]frobtads/tads3/charmap.cpp |
CCharmapToLocalWideUnicode::map_utf8(char*, unsigned long, utf8_ptr, unsigned long, unsigned long*) const | size_t CCharmapToLocalWideUnicode::
map_utf8(char *dest, size_t dest_len,
utf8_ptr src, size_t src_byte_len,
size_t *src_bytes_used) const
{
utf8_ptr src_start;
size_t cur_total;
char *srcend;
wchar_t *destw;
/* remember where we started */
src_start = src;
/* co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %rcx, %r12
xorl %r15d, %r15d
testq %r8, %r8
movq %rcx, 0x8(%rsp)
jle 0xeebf1
movq %r8, %r13
movq %rdx, %rbp
movq %rsi, %r14
addq %r12, %r13
movq %rsi, %rbx
testq %r14, %r14
je 0xeebc7
cmpq $0x4, %rbp
jb 0xeebf1
... | /realnc[P]frobtads/tads3/charmap.cpp |
CCharmapToLocalUcs2Big::map(wchar_t, char**, unsigned long*) const | size_t CCharmapToLocalUcs2Big::map(wchar_t unicode_char, char **output_ptr,
size_t *output_len) const
{
/*
* If we don't have room for another byte pair, abort. Note that we
* really do want to store exactly two bytes, not sizeof(anything),
* since we're sto... | cmpq $0x2, (%rcx)
jae 0xeeca8
xorl %eax, %eax
jmp 0xeecc0
movl %esi, %eax
movq (%rdx), %rsi
movb %ah, (%rsi)
movq (%rdx), %rsi
movb %al, 0x1(%rsi)
addq $0x2, (%rdx)
movq (%rcx), %rax
addq $-0x2, %rax
movq %rax, (%rcx)
movl $0x2, %eax
retq
nop
| /realnc[P]frobtads/tads3/charmap.cpp |
CCharmapToLocalUcs2Little::map_utf8(char*, unsigned long, utf8_ptr, unsigned long, unsigned long*) const | size_t CCharmapToLocalUcs2Little::
map_utf8(char *dest, size_t dest_len,
utf8_ptr src, size_t src_byte_len,
size_t *src_bytes_used) const
{
utf8_ptr src_start;
size_t cur_total;
char *srcend;
/* remember where we started */
src_start = src;
/* compute where the sourc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %rcx, %r14
xorl %r15d, %r15d
testq %r8, %r8
jle 0xeee8d
movq %r8, %r13
movq %rdx, %rbp
movq %rsi, %rbx
addq %r14, %r13
movq %r14, %r12
testq %rbx, %rbx
je 0xeee5f
cmpq $0x2, %rbp
jb 0xeee90
movq %r12, %rdi
callq 0xdde06
m... | /realnc[P]frobtads/tads3/charmap.cpp |
CCharmapToUniSB_basic::read_file(CVmDataSource*, char*, unsigned long) | size_t CCharmapToUniSB_basic::read_file(CVmDataSource *fp,
char *buf, size_t bufl)
{
size_t inlen;
/*
* Compute how much to read from the file. The input file is
* composed of single-byte characters, so only read up to one third
* of the buffer len... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rax
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %rdx, (%r14)
leaq 0x8(%rsp), %r15
movq %rcx, (%r15)
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq %rdx
movl $0x200, %eax # imm = 0x200
cmpq %rax, %rdx
cmovaeq... | /realnc[P]frobtads/tads3/charmap.cpp |
CCharmapToUniSB::map(char**, unsigned long*, char const*, unsigned long) const | size_t CCharmapToUniSB::map(char **outp, size_t *outlen,
const char *inp, size_t inlen) const
{
size_t tot_outlen;
/* we haven't written any characters to the output buffer yet */
tot_outlen = 0;
/* scan each character (character == byte) in the input string */
for ( ; ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
testq %r8, %r8
je 0xef569
movq %r8, %r13
movq %rcx, %rbx
movq (%rdx), %rax
xorl %r14d, %r14d
movl $0x1, %r9d
xorl %ebp, %ebp
movq %rdx, 0x8(%rsp)
movq %rdi, (%rsp)
movq 0x10(%rsp), %r15
movzbl (%rbx,%r14), %esi
movl... | /realnc[P]frobtads/tads3/charmap.cpp |
CCharmapToUniMB::map2(char**, unsigned long*, char const*, unsigned long, unsigned long*) const | size_t CCharmapToUniMB::map2(char **output_ptr, size_t *output_buf_len,
const char *input_ptr, size_t input_len,
size_t *partial_len) const
{
size_t needed_out_len;
/* presume we won't have a partial last character */
*partial_len = 0;
/* we ha... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x18(%rsp)
movq $0x0, (%r9)
testq %r8, %r8
je 0xefa60
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbp
movq %r9, 0x8(%rsp)
addq $0x10, %rdi
xorl %r12d, %r12d
movl $0x1, %r8d
movq %rdi, 0x10(%rsp)
movq 0x18(%rsp), %r13
movzbl (%r... | /realnc[P]frobtads/tads3/charmap.cpp |
CCharmapToLocal::~CCharmapToLocal() | CCharmapToLocal::~CCharmapToLocal()
{
size_t i;
/* delete the translation array */
if (xlat_array_ != 0)
t3free(xlat_array_);
/* delete the expansion array */
if (exp_array_ != 0)
t3free(exp_array_);
/* delete any mapping tables we've allocated */
for (i = 0 ; i < sizeof(m... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x11a8e2(%rip), %rax # 0x20a448
movq %rax, (%rdi)
movq 0x1010(%rdi), %rdi
testq %rdi, %rdi
je 0xefb7a
callq 0xc8400
movq 0x1020(%rbx), %rdi
testq %rdi, %rdi
je 0xefb8b
callq 0xc8400
xorl %r14d, %r14d
movq 0x10(%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0xefb9d
callq ... | /realnc[P]frobtads/tads3/charmap.cpp |
CCharmapToUniUcs2Little::mapchar(wchar_t&, char const*&, unsigned long&) | virtual int mapchar(wchar_t &ch, const char *&p, size_t &len)
{
if (len >= 2)
{
/* map the character */
ch = (unsigned char)*p++;
ch |= ((unsigned char)*p++) << 8;
/* deduct it from the length */
len -= 2;
/* success */
... | xorl %eax, %eax
cmpq $0x2, (%rcx)
jb 0xf0200
movq (%rdx), %rax
leaq 0x1(%rax), %rdi
movq %rdi, (%rdx)
movzbl (%rax), %eax
movl %eax, (%rsi)
movq (%rdx), %rax
leaq 0x1(%rax), %rdi
movq %rdi, (%rdx)
movzbl (%rax), %eax
shll $0x8, %eax
orl %eax, (%rsi)
addq $-0x2, (%rcx)
movl $0x1, %eax
retq
nop
| /realnc[P]frobtads/tads3/charmap.h |
CCharmapToUniMB::is_complete_char(char const*, unsigned long) const | virtual int is_complete_char(const char *p, size_t len) const
{
/*
* Check the first byte to see if this is a leading byte or a
* stand-alone single byte.
*/
if (map_[(unsigned char)*p].sub == 0)
{
/*
* it's a stand-alone byte, so... | movzbl (%rsi), %eax
shll $0x4, %eax
cmpq $0x0, 0x10(%rdi,%rax)
sete %al
cmpq $0x2, %rdx
setae %cl
orb %al, %cl
movzbl %cl, %eax
retq
| /realnc[P]frobtads/tads3/charmap.h |
CVmImageLoaderMres_resload::add_resource(char const*, unsigned long, char const*, unsigned long) | void add_resource(const char *fname, size_t fnamelen,
const char *res_name, size_t res_name_len)
{
/*
* if we've already found a match, there's no need to consider
* anything else
*/
if (found_)
return;
/* check to see if th... | cmpl $0x0, 0x18(%rdi)
jne 0xf1714
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %r8, 0x10(%rdi)
jne 0xf170f
movq %rdx, %r14
movq %rsi, %r15
movq 0x8(%rbx), %rdi
movq %rcx, %rsi
movq %r8, %rdx
callq 0xec43c
testl %eax, %eax
jne 0xf170f
movl $0x1, 0x18(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0xf2aae
movq %rax... | /realnc[P]frobtads/tads3/resldexe.cpp |
sha256_end | void sha256_end(unsigned char hval[], sha256_ctx ctx[1])
{ sha2_32t i = (sha2_32t)(ctx->count[0] & SHA256_MASK);
bsw_32(ctx->wbuf, (i + 3) >> 2)
/* bytes in the buffer are now in an order in which references */
/* to 32-bit words will put bytes with lower addresses into the */
/* top of 32 bi... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %ecx
movl %ecx, %eax
andl $0x3f, %eax
je 0xf2691
movl %ecx, %edx
andl $0x3f, %edx
addl $0x3, %edx
shrl $0x2, %edx
movq %rdx, %rsi
movl 0x24(%rbx,%rdx,4), %edi
bswapl %edi
movl %edi, 0x24(%rbx,%rdx,4)
decq %rsi
movq %rsi, %rdx
jne 0xf267f
movl... | /realnc[P]frobtads/tads3/sha2.cpp |
t3_compare_case_fold(char const*, unsigned long, char const*, unsigned long, unsigned long*) | int t3_compare_case_fold(
const char *a, size_t alen,
const char *b, size_t blen, size_t *bmatchlen)
{
/* set up folded-case string readers for the two strings */
Utf8FoldStr ap(a, alen), bp(b, blen);
/* scan until we find a mismatch or run out of one string */
while(ap.more() && bp.more())
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r14
leaq 0x40(%rsp), %rbx
movq %rdi, 0x8(%rbx)
movq %rsi, 0x10(%rbx)
leaq 0x44(%rsp), %rax
xorl %esi, %esi
movl %esi, (%rax)
movq %rbx, -0xc(%rax)
movq %rax, -0x14(%rax)
leaq 0x18(%rsp), %r13
movq %rdx, (%rsp)
movq %rdx, 0x8(%... | /realnc[P]frobtads/tads3/std.cpp |
t3strlwr(char*) | void t3strlwr(char *p)
{
for ( ; *p != '\0' ; ++p)
*p = (char)to_lower(*p);
} | movb (%rdi), %al
testb %al, %al
je 0xf3e33
pushq %rbx
movq %rdi, %rbx
incq %rbx
testb %al, %al
js 0xf3e26
movzbl %al, %edi
callq 0xc8500
movb %al, -0x1(%rbx)
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0xf3e1a
popq %rbx
retq
| /realnc[P]frobtads/tads3/std.cpp |
CTcDataStream::CTcDataStream(char) | CTcDataStream::CTcDataStream(char stream_id)
{
/* remember my ID */
stream_id_ = stream_id;
/* nothing is allocated yet */
ofs_ = 0;
obj_file_start_ofs_ = 0;
pages_ = 0;
page_slots_ = 0;
page_cnt_ = 0;
page_cur_ = 0;
rem_ = 0;
wp_ = 0;
/* we have no anchors yet */
f... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x11a2e0(%rip), %rax # 0x20e628
movq %rax, (%rdi)
movb %sil, 0x60(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movl $0x20, %edi
callq 0xc8310
movq %rax, %r14
m... | /realnc[P]frobtads/tads3/tcgen.cpp |
CTcDataStream::dec_ofs(int) | void CTcDataStream::dec_ofs(int amount)
{
/* adjust the offset */
ofs_ -= amount;
/*
* calculate the new page we're on, since this may take us to a
* different page
*/
page_cur_ = ofs_ / TCCS_PAGE_SIZE;
/* calculate the remaining size in this page */
rem_ = TCCS_PAGE_SIZE ... | movslq %esi, %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
movq 0x30(%rdi), %rsi
movabsq $0x20438d7022c8d47d, %rdx # imm = 0x20438D7022C8D47D
movq %rcx, %rax
mulq %rdx
movq %rcx, 0x8(%rdi)
shrq $0xd, %rdx
movq %rdx, 0x28(%rdi)
imulq $0xfde8, %rdx, %rax # imm = 0xFDE8
subq %rax, %rcx
movl $0xfde8, %eax # imm =... | /realnc[P]frobtads/tads3/tcgen.cpp |
CTcDataStream::append_stream(CTcDataStream*) | void CTcDataStream::append_stream(CTcDataStream *stream)
{
ulong rem;
ulong ofs;
ulong start_ofs;
CTcStreamAnchor *anchor;
CTcStreamAnchor *nxt;
/* remember the starting offset of the copy in my stream */
start_ofs = get_ofs();
/* copy all data from the other stream */
for (ofs... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r13
movq 0x8(%rsi), %rbp
testq %rbp, %rbp
je 0xf4833
xorl %r15d, %r15d
movq %r15, %rax
movabsq $0x20438d7022c8d47d, %rcx # imm = 0x20438D7022C8D47D
mulq %rcx
shrq $0xd, %rdx
imulq $0xfde8, %rdx,... | /realnc[P]frobtads/tads3/tcgen.cpp |
CTcDataStream::find_anchor(unsigned long) const | CTcStreamAnchor *CTcDataStream::find_anchor(ulong ofs) const
{
CTcStreamAnchor *cur;
/* scan the anchor list */
for (cur = first_anchor_ ; cur != 0 ; cur = cur->nxt_)
{
/* if this one has the desired offset, return it */
if (cur->get_ofs() == ofs)
return cur;
}
/* d... | movq %rdi, %rax
addq $0x48, %rax
movq (%rax), %rax
testq %rax, %rax
je 0xf497f
cmpq %rsi, 0x18(%rax)
jne 0xf4971
retq
| /realnc[P]frobtads/tads3/tcgen.cpp |
CTcDataStream::write_prop_id(unsigned int) | void CTcDataStream::write_prop_id(uint prop_id)
{
/* if there's an object ID fixup list, add this reference */
if (G_keep_propfixups)
CTcIdFixup::add_fixup(&G_propfixup, this, get_ofs(), prop_id);
/* write the ID */
write2(prop_id);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x148dc5(%rip), %rax # 0x23d858
cmpl $0x0, (%rax)
je 0xf4acf
movq 0x8(%rbx), %r14
movl %ebp, %r15d
leaq 0x148d12(%rip), %rax # 0x23d7b8
movq (%rax), %rdi
movl $0x20, %esi
callq 0xf6934
movq %rbx, (%rax)
movq %r14, 0x8(%rax... | /realnc[P]frobtads/tads3/tcgen.cpp |
CTcCodeStream::~CTcCodeStream() | CTcCodeStream::~CTcCodeStream()
{
size_t i;
/* release all active labels */
release_labels();
/* delete the line records pages */
for (i = 0 ; i < line_pages_alloc_ ; ++i)
t3free(line_pages_[i]);
/* delete the master list of pages */
t3free(line_pages_);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x119964(%rip), %rax # 0x20e650
movq %rax, (%rdi)
callq 0xf4d40
cmpq $0x0, 0xb8(%rbx)
je 0xf4d1d
xorl %r14d, %r14d
movq 0xb0(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xc8400
incq %r14
cmpq 0xb8(%rbx), %r14
jb 0xf4d01
movq 0xb0(%rbx), %rdi
callq 0xc8400
movq %rb... | /realnc[P]frobtads/tads3/tcgen.cpp |
CTcCodeStream::add_local_frame(CTcPrsSymtab*) | void CTcCodeStream::add_local_frame(CTcPrsSymtab *symtab)
{
/*
* If this is the global symbol table, or it's null, or it's already
* in a list, ignore it. Note that we can tell if the item is in a
* list by checking its index value - a value of zero is never a
* valid index and thus in... | testq %rsi, %rsi
je 0xf4e68
leaq 0x14895a(%rip), %rax # 0x23d7b0
movq (%rax), %rax
cmpq %rsi, 0x80(%rax)
je 0xf4e68
cmpl $0x0, 0x28(%rsi)
je 0xf4e69
retq
movq $0x0, 0x20(%rsi)
movq 0xd8(%rdi), %rax
leaq 0x20(%rax), %rcx
leaq 0xd0(%rdi), %rdx
testq %rax, %rax
cmoveq %rdx, %rcx
movq %rsi, (%rcx)
movq %rsi, 0xd8(%rdi)
... | /realnc[P]frobtads/tads3/tcgen.cpp |
CTcCodeStream::new_label_here() | CTcCodeLabel *CTcCodeStream::new_label_here()
{
CTcCodeLabel *lbl;
/* allocate a new label */
lbl = alloc_label();
/* set the label's location to the current write position */
lbl->ofs = ofs_;
lbl->is_known = TRUE;
/* return the new label */
return lbl;
} | pushq %rbx
movq %rdi, %rbx
callq 0xf4eee
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
orb $0x1, 0x18(%rax)
popq %rbx
retq
nop
| /realnc[P]frobtads/tads3/tcgen.cpp |
CTcCodeStream::has_fixup_at_ofs(CTcCodeLabel*, unsigned long) | int CTcCodeStream::has_fixup_at_ofs(CTcCodeLabel *lbl, ulong ofs)
{
CTcLabelFixup *fixup;
/* scan for a match */
for (fixup = lbl->fhead ; fixup != 0 ; fixup = fixup->nxt)
{
/* if this is a match, indicate success */
if (fixup->ofs == ofs)
return TRUE;
}
/* we d... | addq $0x10, %rsi
movq (%rsi), %rsi
testq %rsi, %rsi
je 0xf503a
cmpq %rdx, 0x8(%rsi)
jne 0xf5026
movl $0x1, %eax
retq
xorl %eax, %eax
retq
nop
| /realnc[P]frobtads/tads3/tcgen.cpp |
CTcAbsFixup::fix_abs_fixup(CTcAbsFixup*, unsigned long) | void CTcAbsFixup::fix_abs_fixup(CTcAbsFixup *list_head, ulong final_ofs)
{
CTcAbsFixup *cur;
/* scan the list and fix up each entry */
for (cur = list_head ; cur != 0 ; cur = cur->nxt)
{
/*
* fix this entry by writing the final offset in UINT4 format to
* the target strea... | testq %rdi, %rdi
je 0xf5295
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rsi
movl %ebx, 0xc(%rsp)
movl $0x4, %ecx
movq %r15, %rdx
callq 0xf44e4
movq (%r14), %r14
testq %r14, %r14
jne 0xf526b
addq $0x10, %rsp
popq %rbx
popq ... | /realnc[P]frobtads/tads3/tcgen.cpp |
CTcLibParser::scan_resource(char const*) | void CTcLibParser::scan_resource(const char *val)
{
char rel_path[OSFNMAX];
char full_name[OSFNMAX];
/* convert the value from a URL-style path to a local path */
os_cvt_url_dir(rel_path, sizeof(rel_path), val);
/* build the full name */
os_build_full_path(full_name, sizeof(full_name), lib_pat... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2008, %rsp # imm = 0x2008
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1000(%rsp), %r15
movl $0x1000, %esi # imm = 0x1000
movq %r15, %rdi
movq %rbx, %rdx
callq 0xeccea
movq 0x10(%r14), %rdx
movq %rsp, %r12
movl $0x1000, %esi # imm = 0x1000
movq... | /realnc[P]frobtads/tads3/tclibprs.cpp |
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.