name string | code string | asm string | file string |
|---|---|---|---|
CTcMain::tc_err_init(unsigned long, CResLoader*) | void CTcMain::tc_err_init(size_t param_stack_size,
CResLoader *res_loader)
{
/* initialize the error stack */
err_init(1024);
/* if this is the first initializer, set things up */
if (err_refs_ == 0)
{
/* if we haven't loaded external compiler messages, load them *... | pushq %rbx
movq %rsi, %rbx
movl $0x400, %edi # imm = 0x400
callq 0x148adc
cmpl $0x0, 0x147d4f(%rip) # 0x23d8a0
je 0xf5b5b
incl 0x147d47(%rip) # 0x23d8a0
popq %rbx
retq
cmpl $0x0, 0x147d42(%rip) # 0x23d8a4
jne 0xf5b53
leaq 0x13fb9d(%rip), %rax # 0x235708
movq (%rax), %rax
cmpq 0x13142b(%rip)... | /realnc[P]frobtads/tads3/tcmain.cpp |
format_message(char const*, unsigned long) | static void format_message(const char *msg, unsigned long options)
{
/*
* if we're in verbose mode, word-wrap to 80 columns; otherwise just
* print it as-is
*/
if ((options & TCMAIN_ERR_VERBOSE) != 0)
{
const char *p;
const int line_wid = 79;
/* start on a new li... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x147241(%rip), %r15 # 0x23d7a0
movq (%r15), %rdi
testb $0x1, %sil
jne 0xf6582
leaq 0xc1a50(%rip), %rsi # 0x1b7fbf
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd095e
leaq 0x9bace(%rip), %rsi ... | /realnc[P]frobtads/tads3/tcmain.cpp |
CTcParser::CTcParser() | CTcParser::CTcParser()
{
size_t i;
/* we don't have any module information yet */
module_name_ = 0;
module_seqno_ = 0;
/* start out in normal mode */
pp_expr_mode_ = FALSE;
src_group_mode_ = FALSE;
/* create the global symbol table */
global_symtab_ = new CTcPrsSymtab(0);
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq $0x0, 0x258(%rdi)
movl $0x0, 0x260(%rdi)
andb $-0x4, 0xec(%rdi)
leaq 0x147041(%rip), %r15 # 0x23d7b8
movq (%r15), %rdi
movl $0x30, %esi
callq 0xf6934
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
callq 0xfd506
movq %r14, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xm... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcParser::add_nested_stm(CTPNStmTop*) | void CTcParser::add_nested_stm(CTPNStmTop *stm)
{
/* link it into our list */
if (nested_stm_tail_ != 0)
nested_stm_tail_->set_next_stm_top(stm);
else
nested_stm_head_ = stm;
nested_stm_tail_ = stm;
} | movq 0x180(%rdi), %rax
leaq 0x178(%rdi), %rcx
leaq 0x28(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq %rsi, (%rdx)
movq %rsi, 0x180(%rdi)
retq
| /realnc[P]frobtads/tads3/tcprs.cpp |
CTcConstVal::set_float(vbignum_t const*, int) | void CTcConstVal::set_float(const vbignum_t *val, int promoted)
{
/* format the value */
CBigNumStringBufPrsAlo alo;
const char *buf = val->format(&alo);
/*
* read the length from the buffer - vbignum_t::format() fills in the
* buffer using the TADS String format, with a two-byte little-... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rdi, %r14
leaq 0x11a00f(%rip), %rax # 0x2119b0
leaq 0x20(%rsp), %rdi
movq %rax, (%rdi)
movq (%rsi), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsp)
movq $0x10, (%rsp)
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl $0xffffffff, %ecx # imm = 0xFF... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcPrsOpBinGroup::parse() const | CTcPrsNode *CTcPrsOpBinGroup::parse() const
{
/* parse our left side - if that fails, return failure */
CTcPrsNode *lhs = left_->parse();
if (lhs == 0)
return 0;
/* keep going as long as we find one of our operators */
while (find_and_apply_op(&lhs)) ;
/* return the expression tree */
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, (%rsp)
testq %rax, %rax
je 0xf7e99
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf7ea4
testl %eax, %eax
jne 0xf7e84
movq (%rsp), %rax
jmp 0xf7e9b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcPrsOpBinGroupCompare::parse_inlist() const | CTPNArglist *CTcPrsOpBinGroupCompare::parse_inlist() const
{
int argc;
CTPNArg *arg_head;
CTPNArg *arg_tail;
/* skip the second keyword token, and check for an open paren */
if (G_tok->next() == TOKT_LPAR)
{
/* skip the paren */
G_tok->next();
}
else
{
/*
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1456a6(%rip), %rbx # 0x23d7c0
movq (%rbx), %rdi
callq 0x11835a
movq (%rbx), %rdi
cmpl $0x13, %eax
jne 0xf8131
callq 0x11835a
jmp 0xf813b
movl $0x2ba3, %esi # imm = 0x2BA3
callq 0x11a73a
movq (%rbx), %rdi
cmpl $0x14, 0xcc8(%... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTPNIsInBase::fold_binop() | CTcPrsNode *CTPNIsInBase::fold_binop()
{
CTPNArglist *lst;
CTPNArg *arg;
CTPNArg *prv;
CTPNArg *nxt;
/* if the left-hand side isn't constant, there's nothing to do */
if (!left_->is_const())
return this;
/* the right side is always an argument list */
lst = (CTPNArglist *)r... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testq %rax, %rax
je 0xf8aa2
movq 0x10(%rbx), %r12
movq 0x10(%r12), %r14
testq %r14, %r14
je 0xf8a89
movq (%r14), %rax
movq 0x10(%r14), %r13
movq %r14, %rdi
callq *0x8(%rax)
testq %rax, %rax
je ... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcPrsOpMod::calc_result(long, long, int&) const | long CTcPrsOpMod::calc_result(long a, long b, int &ov) const
{
/* there's no way for integer modulo to overflow */
ov = FALSE;
/* check for divide-by-zero */
if (b == 0)
{
/* log a divide-by-zero error */
G_tok->log_error(TCERR_CONST_DIV_ZERO);
/* the result isn't reall... | movl $0x0, (%rcx)
testq %rdx, %rdx
je 0xf922c
movq %rdx, %rdi
movq %rsi, %rax
cqto
idivq %rdi
movq %rdx, %rax
retq
pushq %rax
movl $0x2af9, %edi # imm = 0x2AF9
xorl %eax, %eax
callq 0x117408
movl $0x1, %eax
addq $0x8, %rsp
retq
nop
| /realnc[P]frobtads/tads3/tcprs.cpp |
CTPNListBase::add_element(CTcPrsNode*) | void CTPNListBase::add_element(CTcPrsNode *expr)
{
CTPNListEle *ele;
/* create a list element object for the new element */
ele = new CTPNListEle(expr);
/* count the new entry */
++cnt_;
/* add the element to our linked list */
ele->set_prev(tail_);
if (tail_ != 0)
tail_->... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x144103(%rip), %rax # 0x23d7b8
movq (%rax), %rdi
movl $0x20, %esi
callq 0xf6934
movq %r14, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
leaq 0x11ed5c(%rip), %rcx # 0x218430
addq $0x10, %rcx
movq %rcx, (%rax)
incl 0x8(%rbx)
movq 0x18(%... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcPrsOpUnary::parse_embedded_end_tok(CTcEmbedBuilder*, CTcEmbedLevel*, char const**) | int CTcPrsOpUnary::parse_embedded_end_tok(CTcEmbedBuilder *b,
CTcEmbedLevel *parent,
const char **open_kw)
{
/* capture the current expression's token list */
CTcEmbedTokenList *tl = G_prs->embed_toks_;
tl->reset();
capt... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x143878(%rip), %rax # 0x23d7b0
movq (%rax), %rax
movq 0x78(%rax), %r15
movq (%r15), %rax
movq %rax, 0x8(%r15)
movl $0x0, 0x10(%r15)
movq %r15, %rsi
callq 0xf9f7a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xfa5c8
movl %eax, %ebx
movq %... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcPrsOpUnary::parse_embedded_end_tok(CTcEmbedTokenList*, CTcEmbedLevel*, char const**) | int CTcPrsOpUnary::parse_embedded_end_tok(CTcEmbedTokenList *tl,
CTcEmbedLevel *parent,
const char **open_kw)
{
/* presume we won't find a closing keyword */
*open_kw = "unknown";
/*
* consider ending keywords to al... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x97c45(%rip), %rax # 0x192228
movq %rax, (%rdx)
leaq 0xbe110(%rip), %rsi # 0x1b86fd
callq 0xfefde
testl %eax, %eax
jne 0xfa61c
leaq 0xbe105(%rip), %rsi # 0x1b8702
movq %r15, %rd... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcPrsOpUnary::parse() const | CTcPrsNode *CTcPrsOpUnary::parse() const
{
/* get the current token, which may be a prefix operator */
tc_toktyp_t op = G_tok->cur();
/* check for prefix operators */
switch(op)
{
case TOKT_AND:
/* skip the '&' */
G_tok->next();
/* parse the address expression *... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x142d34(%rip), %rax # 0x23d7c0
movq (%rax), %rdi
movl 0xcc8(%rdi), %r14d
leal -0x2b(%r14), %eax
cmpl $0x3f, %eax
ja 0xfaac8
movabsq $-0x7fffffffff9ffd00, %rcx # imm = 0x8000000000600300
btq %rax, %rcx
jb 0xfaad5
testq %rax, %rax
jne 0xfaac8
callq 0x11835a
movq %... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcPrsOpUnary::parse_pos(CTcPrsNode*) | CTcPrsNode *CTcPrsOpUnary::parse_pos(CTcPrsNode *subexpr)
{
/*
* if the underlying expression is a constant value, apply the
* operator
*/
if (subexpr->is_const())
{
/* if it's a float, a unary '+' has no effect at all */
if (subexpr->get_const_val()->get_type() == TC_CV... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x8(%rax)
testq %rax, %rax
je 0xfadfa
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
cmpl $0xd, (%rax)
je 0xfae23
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
cmpl $0x3, (%rax)
je 0xfae23
movl $0x1e, %edi
callq 0x117d5a
movl $0x2b01, %edi # imm = 0... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcPrsOpUnary::eval_const_not(CTcPrsNode*) | CTcPrsNode *CTcPrsOpUnary::eval_const_not(CTcPrsNode *subexpr)
{
/*
* if the underlying expression is a constant value, apply the
* operator
*/
if (subexpr->is_const())
{
/* set the new value */
subexpr->get_const_val()
->set_bool(!subexpr->get_const_val()->g... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x8(%rax)
testq %rax, %rax
je 0xfb1ad
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movl $0x2, %ecx
cmpl $0x1, (%rax)
je 0xfb1a8
movq %rax, %rdi
callq 0xf7bba
cmpl $0x1, %eax... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcPrsOpUnary::parse_member(CTcPrsNode*) | CTcPrsNode *CTcPrsOpUnary::parse_member(CTcPrsNode *lhs)
{
CTcPrsNode *rhs;
int rhs_is_expr;
/*
* If a '.' is present, skip it; otherwise, '.targetprop' is implied.
*/
if (G_tok->cur() == TOKT_DOT)
{
/* we have an explicit property expression - skip the '.' */
G_tok->ne... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1417ad(%rip), %r15 # 0x23d7c0
movq (%r15), %rdi
cmpl $0x16, 0xcc8(%rdi)
jne 0xfc0c1
callq 0x11835a
movq (%r15), %rdi
movl 0xcc8(%rdi), %eax
cmpl $0x78, %eax
je 0xfc0bc
cmpl $0x13, %eax
je 0xfc088
cmpl $0x8, %eax
jne 0xfc18a
leaq 0x141769(%... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcPrsOpUnary::parse_inherited() | CTcPrsNode *CTcPrsOpUnary::parse_inherited()
{
CTcPrsNode *lhs;
/* skip the "inherited" keyword and check what follows */
switch(G_tok->next())
{
case TOKT_SYM:
/*
* it's an "inherited superclass..." expression - set up the
* "inherited superclass" node
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x140f1d(%rip), %r15 # 0x23d7c0
movq (%r15), %rdi
callq 0x11835a
leaq 0x140f06(%rip), %r14 # 0x23d7b8
movq (%r14), %rdi
cmpl $0x24, %eax
je 0xfc90e
cmpl $0x8, %eax
jne 0xfca0b
movl $0x18, %esi
callq 0xf6934
movq %rax, %r14
movq (%r15), %rax
movups 0xcd0(... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcFormalTypeList::add_typed_param(CTcToken const*) | void CTcFormalTypeList::add_typed_param(const CTcToken *tok)
{
add(new (G_prsmem) CTcFormalTypeEle(tok->get_text(), tok->get_text_len()));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x140c32(%rip), %r13 # 0x23d7b8
movq (%r13), %rdi
movl $0x18, %esi
callq 0xf6934
movq %rax, %r15
movq 0x8(%r14), %r12
movq 0x10(%r14), %r14
leaq 0x1(%r14), %rsi
movq (%r13), %rdi
callq 0xf6934
movq %rax, 0x8(%r15)
movq %rax, ... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcPrsMem::alloc_block() | void CTcPrsMem::alloc_block()
{
tcprsmem_blk_t *blk;
/*
* block size - pick a size that's large enough that we won't be
* unduly inefficient (in terms of having tons of blocks), but still
* friendly to 16-bit platforms (i.e., under 64k)
*/
const size_t BLOCK_SIZE = 65000;
/... | pushq %rbx
movq %rdi, %rbx
movl $0xfdf7, %edi # imm = 0xFDF7
callq 0xc8470
testq %rax, %rax
je 0xfcc6f
movq $0x0, (%rax)
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
cmoveq %rbx, %rcx
movq %rax, (%rcx)
movq %rax, 0x8(%rbx)
leaq 0xf(%rax), %rcx
andq $-0x8, %rcx
movq %rcx, 0x10(%rbx)
subq %rcx, %rax
addq $0xfdf0, %rax... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcPrsMem::delete_all() | void CTcPrsMem::delete_all()
{
/* free all blocks */
while (head_ != 0)
{
tcprsmem_blk_t *nxt;
/* remember the next block after this one */
nxt = head_->next_;
/* free this block */
t3free(head_);
/* move on to the next one */
head_ = nxt;
}
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xfccce
movq (%rdi), %r14
callq 0xc8400
movq %r14, (%rbx)
movq %r14, %rdi
testq %r14, %r14
jne 0xfccbb
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /realnc[P]frobtads/tads3/tcprs.cpp |
CTPNListBase::fold_constants(CTcPrsSymtab*) | CTcPrsNode *CTPNListBase::fold_constants(CTcPrsSymtab *symtab)
{
CTPNListEle *cur;
int all_const;
/*
* if the list is already constant, there's nothing extra we need to
* do
*/
if (is_const_)
return this;
/* presume the result will be all constants */
all_const = T... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testb $0x1, 0x48(%rdi)
jne 0xfce4b
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0xfce47
movq %rsi, %r14
movl $0x1, %ebp
xorl %r12d, %r12d
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x78(%rax)
movq 0x8(%r15), %rdi
movq (%rdi), %rax
callq *... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTPNIfnilBase::fold_constants(CTcPrsSymtab*) | CTcPrsNode *CTPNIfnilBase::fold_constants(CTcPrsSymtab *symtab)
{
/* fold constants in the subnodes */
first_ = first_->fold_constants(symtab);
second_ = second_->fold_constants(symtab);
/*
* if the first is now a constant, we can fold this entire expression
* node by choosing the first ... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x78(%rax)
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testq %rax, %rax
je 0xfce... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTPNAddrBase::fold_constants(CTcPrsSymtab*) | CTcPrsNode *CTPNAddrBase::fold_constants(CTcPrsSymtab *symtab)
{
CTcPrsNode *ret;
/* ask the symbol to generate a constant expression for its address */
ret = get_sub_expr()->fold_addr_const(symtab);
/*
* if we got a constant value, return it; otherwise, return myself
* unchanged
... | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
testq %rax, %rax
cmoveq %rbx, %rax
popq %rbx
retq
| /realnc[P]frobtads/tads3/tcprs.cpp |
CTPNSymBase::fold_addr_const(CTcPrsSymtab*) | CTcPrsNode *CTPNSymBase::fold_addr_const(CTcPrsSymtab *symtab)
{
CTcSymbol *sym;
/* look up my symbol; if we don't find it, don't define it */
sym = symtab->find(get_sym_text(), get_sym_text_len());
if (sym != 0)
{
/* we got a symbol - ask it to do the folding */
return sym->fold_ad... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rax
callq *0x60(%rax)
movq %rax, %r14
movq (%r15), %rax
movq %r15, %rdi
callq *0x68(%rax)
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x10(%rax)
testq %rax, %rax
jne 0xfd0f0
... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTPNSymDebugLocalBase::CTPNSymDebugLocalBase(tcprsdbg_sym_info const*) | CTPNSymDebugLocalBase::CTPNSymDebugLocalBase(const tcprsdbg_sym_info *info)
{
/* save the type information */
switch(info->sym_type)
{
case TC_SYM_LOCAL:
var_id_ = info->var_id;
ctx_arr_idx_ = info->ctx_arr_idx;
frame_idx_ = info->frame_idx;
is_param_ = FALSE;
bre... | leaq 0x114491(%rip), %rax # 0x211738
movq %rax, (%rdi)
movl (%rsi), %eax
cmpl $0x5, %eax
je 0xfd2cd
cmpl $0x4, %eax
jne 0xfd2e4
movl 0x4(%rsi), %eax
movl %eax, 0x8(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0xc(%rdi)
movl 0xc(%rsi), %eax
movl %eax, 0x10(%rdi)
andb $-0x2, 0x14(%rdi)
retq
movl 0x4(%rsi), %eax
movl %eax, 0x... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTPNArglistBase::adjust_for_dyn(tcpn_dyncomp_info const*) | CTcPrsNode *CTPNArglistBase::adjust_for_dyn(const tcpn_dyncomp_info *info)
{
/* adjust each argument list member */
CTPNArg *arg;
for (arg = list_ ; arg != 0 ; arg = arg->get_next_arg())
{
/*
* adjust this argument; assume the argument node itself isn't
* affected
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0xfd344
movq %rsi, %r14
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x88(%rax)
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0xfd32c
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
| /realnc[P]frobtads/tads3/tcprs.cpp |
CTPNMemArgBase::adjust_for_dyn(tcpn_dyncomp_info const*) | CTcPrsNode *CTPNMemArgBase::adjust_for_dyn(const tcpn_dyncomp_info *info)
{
/* don't allow in speculative mode due to possible side effects */
if (info->speculative)
err_throw(VMERR_BAD_SPEC_EVAL);
/*
* adjust my object expression, property expression, and argument
* list
*/
... | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x4(%rsi)
jne 0xfd432
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x88(%rax)
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x88(%rax)
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
movq %r1... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcPrsSymtab::add_formal(char const*, unsigned long, int, int) | CTcSymLocal *CTcPrsSymtab::add_formal(const textchar_t *sym, size_t len,
int formal_num, int copy_str)
{
CTcSymLocal *lcl;
/*
* Make sure it's not already defined in our own symbol table - if
* it is, log an error and ignore the redundant definition. (W... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r13d
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rax
callq *0x10(%rax)
testq %rax, %rax
je 0xfd67e
xorl %ebx, %ebx
movl $0x2b1f, %edi # imm = 0x2B1F
movl %r15d, %esi
movq %r12, %rdx
xorl ... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcSymLocalBase::convert_to_ctx_var(int, int) | void CTcSymLocalBase::convert_to_ctx_var(int val_used, int val_assigned)
{
/* if I'm not already a context local, mark me as a context local */
if (!is_ctx_local_)
{
/* mark myself as a context local */
is_ctx_local_ = TRUE;
/*
* we haven't yet assigned our local context... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
xorl %r15d, %r15d
movzwl 0x64(%r14), %eax
testb $0x10, %al
jne 0xfdee8
orl $0x10, %eax
movw %ax, 0x64(%r14)
movl %r15d, 0x40(%r14)
movl %r15d, 0x48(%r14)
movq (%r14), %rax
movq %r14, %rdi
callq *0x78(%rax)
testl %ebp,... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcSymObjBase::fold_constant() | CTcPrsNode *CTcSymObjBase::fold_constant()
{
/* if it's not a TadsObject symbol, we can't fold it into a constant */
if (get_metaclass() != TC_META_TADSOBJ)
return 0;
/* set up the object constant */
CTcConstVal cval;
cval.set_obj(get_obj_id(), get_metaclass());
/* return a constant no... | cmpl $0x0, 0x90(%rdi)
je 0xfe050
xorl %eax, %eax
retq
pushq %rbx
movq 0x28(%rdi), %rbx
leaq 0x13f75c(%rip), %rax # 0x23d7b8
movq (%rax), %rdi
movl $0x30, %esi
callq 0xf6934
movl $0x7, 0x8(%rax)
movq %rbx, 0x10(%rax)
movl $0x0, 0x18(%rax)
movb $0x0, 0x28(%rax)
leaq 0x1167a2(%rip), %rcx # 0x214828
addq $0x10, %rcx
... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcSymObjBase::set_mod_base_sym(CTcSymObj*) | void CTcSymObjBase::set_mod_base_sym(CTcSymObj *sym)
{
/* remember the object I'm modifying */
mod_base_sym_ = sym;
/*
* set the other object's link back to me, so it knows that I'm the
* object that's modifying it
*/
if (sym != 0)
sym->set_modifying_sym((CTcSymObj *)this);... | movq %rsi, 0x50(%rdi)
testq %rsi, %rsi
je 0xfe331
movq %rdi, 0x58(%rsi)
retq
| /realnc[P]frobtads/tads3/tcprs.cpp |
CTcSymMetaclassBase::add_prop(CTcSymProp*, int) | void CTcSymMetaclassBase::add_prop(class CTcSymProp *prop, int is_static)
{
/* create a new list entry for the property */
CTcSymMetaProp *entry = new (G_prsmem) CTcSymMetaProp(prop, is_static);
/* link it at the end of our list */
if (prop_tail_ != 0)
prop_tail_->nxt_ = entry;
else
... | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x13f2ac(%rip), %rax # 0x23d7b8
movq (%rax), %rdi
movl $0x18, %esi
callq 0xf6934
movq %r14, (%rax)
movb 0x10(%rax), %cl
andb $0x1, %bl
andb $-0x2, %cl
orb %bl, %cl
movb %cl, 0x10(%rax)
movq $0x0, 0x8(%rax)
movq 0x40(%r15), %rcx
lea... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTPNCodeBodyBase::get_replaced_func() const | class CTcSymFunc *CTPNCodeBodyBase::get_replaced_func() const
{
CTcSymFunc *b;
CTPNCodeBody *enc;
/* if we have an associated function symbol, it's the base function */
if ((b = get_func_sym()) != 0)
return b->get_mod_base();
/*
* if we have an enclosing code body, then 'replaced' ... | xorl %eax, %eax
movq 0x70(%rdi), %rcx
testq %rcx, %rcx
jne 0xfe914
movq 0x80(%rdi), %rcx
testq %rcx, %rcx
je 0xfe913
movq (%rcx), %rdi
testq %rdi, %rdi
jne 0xfe8f6
retq
movq 0x48(%rcx), %rax
retq
nop
| /realnc[P]frobtads/tads3/tcprs.cpp |
CTcEmbedTokenList::unget(int, int) | void unget(int n = 0, int m = 0)
{
/* skip the last 'm' tokens */
CTcTokenEle *ele;
int i;
for (ele = wrt->getprv(), i = cnt ; m != 0 && ele != 0 ;
ele = ele->getprv(), --m, --i) ;
/* unget tokens until we're down to the first 'n' */
for ( ; ele != 0 && ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x8(%rdi), %rax
movl 0x10(%rdi), %r15d
movq 0x30(%rax), %r14
testl %edx, %edx
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0xff16c
decl %edx
xorl %eax, %eax
movl %eax, %ecx
movq 0x30(%r14), %r14
leal 0x1(%rcx), %eax
cmpl %ecx, %edx
je 0x... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcEmbedTokenList::add_tok(CTcToken const*) | void add_tok(const CTcToken *tok)
{
/* fill in the write token */
G_tok->copytok(wrt, tok);
/* if this is the last item in the list, add another */
if (wrt->getnxt() == 0)
{
CTcTokenEle *ele = new CTcTokenEle();
ele->setprv(wrt);
wrt->setn... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x13e453(%rip), %rax # 0x23d7c0
movq (%rax), %rdi
movq 0x8(%rbx), %rsi
callq 0x118bf8
movq 0x8(%rbx), %r14
movq 0x28(%r14), %rax
testq %rax, %rax
jne 0xff3a8
movl $0x38, %edi
callq 0xc8310
movq $0x0, 0x28(%rax)
movq %r14, 0x30(%rax)
movq %rax, 0x2... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTPNUnaryBase::adjust_for_dyn(tcpn_dyncomp_info const*) | class CTcPrsNode *adjust_for_dyn(const tcpn_dyncomp_info *info)
{
/*
* if this expression has side effects, don't allow it to be
* evaluated speculatively
*/
if (info->speculative && has_side_effects())
err_throw(VMERR_BAD_SPEC_EVAL);
/* ... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x4(%rsi)
je 0xff80e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xd8(%rax)
testl %eax, %eax
jne 0xff82d
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x88(%rax)
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %... | /realnc[P]frobtads/tads3/tcpnint.h |
CTcSymFuncBase::~CTcSymFuncBase() | CTcSymFuncBase(const char *str, size_t len, int copy,
int argc, int opt_argc, int varargs, int has_retval,
int is_multimethod, int is_multimethod_base,
int is_extern, int has_proto)
: CTcSymbol(str, len, copy, TC_SYM_FUNC)
{
/* remember the in... | pushq %rbx
movq %rdi, %rbx
leaq 0x1116e9(%rip), %rax # 0x211010
movq %rax, (%rdi)
leaq 0x1095f7(%rip), %rax # 0x208f28
movq %rax, 0x58(%rdi)
movq 0x60(%rdi), %rdi
callq 0xc8400
movq %rbx, %rdi
popq %rbx
jmp 0x161b32
nop
| /realnc[P]frobtads/tads3/tcpndrv.h |
CTcEmbedBuilderDbl::finish_tree(CTcPrsNode*) | virtual CTcPrsNode *finish_tree(CTcPrsNode *cur)
{
return (cur != 0 ? cur : new CTPNDstr("", 0));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rsi, %rsi
jne 0xffb8b
leaq 0x13dc79(%rip), %rax # 0x23d7b8
movq (%rax), %rdi
movl $0x18, %esi
callq 0xf6934
movq %rax, %rbx
leaq 0x10f2da(%rip), %rax # 0x20ee30
movq %rax, (%rbx)
leaq 0xb8255(%rip), %rax # 0x1b7db5
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%r... | /realnc[P]frobtads/tads3/tcprs.cpp |
CTcParser::parse_formal_list(int, int, int*, int*, int*, int*, CTcSymLocal**, int*, int, int, CTcFormalTypeList**) | void CTcParser::parse_formal_list(
int count_only, int opt_allowed,
int *argc, int *opt_argc, int *varargs,
int *varargs_list, CTcSymLocal **varargs_list_local,
int *err, int base_formal_num, int for_short_anon_func,
CTcFormalTypeList **type_list)
{
CTcSymLocal *lcl = 0;
CTcToken varname;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, %r13
movq %r8, %r12
movq %rcx, %rbp
movl %edx, 0x5c(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdi, 0x30(%rsp)
movq 0xe0(%rsp), %rax
movq 0xd0(%rsp), %rsi
cmpl $0x0, 0xf0(%rsp)
movl $0x14, %ecx
movl $0x29, %ebx
cmovel %ecx, %ebx
movl $0... | /realnc[P]frobtads/tads3/tcprsstm.cpp |
CTcParser::parse_return(int*) | CTPNStm *CTcParser::parse_return(int *err)
{
CTPNStm *stm;
/* skip the 'return' keyword and see what we have */
switch(G_tok->next())
{
case TOKT_SEM:
/*
* end of the statement - this is a void return; skip the
* semicolon, and return a void return statement node ... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x13b6aa(%rip), %rbx # 0x23d7c0
movq (%rbx), %rdi
callq 0x11835a
leal -0x17(%rax), %ecx
cmpl $0x2, %ecx
jae 0x102135
movq (%rbx), %rdi
movl $0x2b2d, %esi # imm = 0x2B2D
callq 0x11a73a
jmp 0x1021b1
cmpl $0x2a, %eax
jne 0x10216f
movq (%rbx... | /realnc[P]frobtads/tads3/tcprsstm.cpp |
CTcParser::parse_goto(int*) | CTPNStm *CTcParser::parse_goto(int *err)
{
CTPNStmGoto *goto_stm;
/* skip the 'goto' keyword, and demand that a symbol follows */
if (G_tok->next() == TOKT_SYM)
{
/* create the parse node for the 'goto' statement */
goto_stm = new CTPNStmGoto(G_tok->getcur()->get_text(),
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
leaq 0x13aa0b(%rip), %r15 # 0x23d7c0
movq (%r15), %rdi
callq 0x11835a
cmpl $0x8, %eax
jne 0x102e08
movl $0x30, %edi
callq 0xf747a
movq %rax, %r14
movq (%r15), %rax
movq 0xcd0(%rax), %r12
movq 0xcd8(%rax), %r13
movq %r14, %rdi
callq 0xfe93a
movq %... | /realnc[P]frobtads/tads3/tcprsstm.cpp |
CTcParser::parse_throw(int*) | CTPNStm *CTcParser::parse_throw(int *err)
{
CTcPrsNode *expr;
CTPNStmThrow *throw_stm;
/* skip the 'throw' keyword */
G_tok->next();
/* parse the expression to be thrown */
expr = parse_expr();
if (expr == 0)
{
*err = TRUE;
return 0;
}
/* create the stateme... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x13a344(%rip), %rax # 0x23d7c0
movq (%rax), %rdi
callq 0x11835a
movq %r14, %rdi
callq 0xf6eec
testq %rax, %rax
je 0x1034c4
movq %rax, %r15
movl $0x28, %edi
callq 0xf747a
movq %rax, %r14
movq %rax, %rdi
callq 0xfe93a
movq %r15, 0x20(%r14)
leaq 0x1... | /realnc[P]frobtads/tads3/tcprsstm.cpp |
CTPNInlineObjectBase::adjust_for_dyn(tcpn_dyncomp_info const*) | CTcPrsNode *CTPNInlineObjectBase::adjust_for_dyn(const tcpn_dyncomp_info *info)
{
/* adjust each property expression */
for (CTPNObjProp *prop = proplist_.first_ ; prop != 0 ;
prop = prop->get_next_prop())
prop->adjust_for_dyn(info);
/* we did our updates in-place */
return this;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r15
testq %r15, %r15
je 0x106004
movq %rsi, %r14
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x88(%rax)
movq 0x30(%r15), %r15
testq %r15, %r15
jne 0x105fec
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
| /realnc[P]frobtads/tads3/tcprsstm.cpp |
CTPNObjPropBase::adjust_for_dyn(tcpn_dyncomp_info const*) | CTcPrsNode *CTPNObjPropBase::adjust_for_dyn(const tcpn_dyncomp_info *info)
{
/* adjust my various elements */
if (code_body_ != 0)
code_body_->adjust_for_dyn(info);
if (inline_method_ != 0)
inline_method_->adjust_for_dyn(info);
if (expr_ != 0)
expr_ = expr_->adjust_for_dyn(info);... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x1062b3
movq (%rdi), %rax
movq %r14, %rsi
callq *0x88(%rax)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x1062c8
movq (%rdi), %rax
movq %r14, %rsi
callq *0x88(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x1062e... | /realnc[P]frobtads/tads3/tcprsstm.cpp |
CTPNStmExprBase::gen_code(int, int) | void CTPNStmExprBase::gen_code(int, int)
{
/* set our location for any errors that occur */
G_tok->set_line_info(get_source_desc(), get_source_linenum());
/* add a debug line record for the statement */
add_debug_line_rec();
/*
* generate code in our expression - the result will not be use... | pushq %rbx
movq %rdi, %rbx
leaq 0x137259(%rip), %rax # 0x23d7c0
movq (%rax), %rax
movups 0x10(%rdi), %xmm0
movups %xmm0, 0x38(%rax)
callq 0xdd67c
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movl $0x1, %esi
movl $0x1, %edx
popq %rbx
jmpq *%rax
| /realnc[P]frobtads/tads3/tcprsstm.cpp |
CTPNStmForBase::get_control_flow(int) const | unsigned long CTPNStmForBase::get_control_flow(int warn) const
{
unsigned long flags;
/*
* If we have a condition with a constant false value, and there's
* either a reinitialization expression or a loop body, warn about the
* unreachable code. If the body is directly reachable via a code... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x1067d0
movq (%rdi), %rax
callq *0x8(%rax)
testq %rax, %rax
je 0x1067d0
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
cmpl $0x1, (%rax)
je 0x106771
movq %rax, %rdi
callq 0xf7bba
t... | /realnc[P]frobtads/tads3/tcprsstm.cpp |
CTPNStmWhileBase::get_control_flow(int) const | unsigned long CTPNStmWhileBase::get_control_flow(int warn) const
{
unsigned long flags;
/*
* If we have a condition with a constant false value, and we have a
* non-empty body, and the body isn't reachable via a label, warn
* about the unreachable code
*/
if (cond_expr_->is_const... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testq %rax, %rax
je 0x1069a1
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
cmpl $0x1, (%rax)
je 0x106978
movq %rax, %rdi
callq 0xf7bba
testl %eax, %eax
je 0x1069a1
m... | /realnc[P]frobtads/tads3/tcprsstm.cpp |
CTPNStmLabelBase::fold_constants(CTcPrsSymtab*) | CTcPrsNode *CTPNStmLabelBase::fold_constants(CTcPrsSymtab *symtab)
{
/* set our location for any errors that occur */
G_tok->set_line_info(get_source_desc(), get_source_linenum());
/* fold constants in our labeled statement */
if (stm_ != 0)
stm_ = (CTPNStm *)stm_->fold_constants(symtab);
... | pushq %rbx
movq %rdi, %rbx
leaq 0x136c11(%rip), %rax # 0x23d7c0
movq (%rax), %rax
movups 0x10(%rdi), %xmm0
movups %xmm0, 0x38(%rax)
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x106bcd
movq (%rdi), %rax
callq *0x78(%rax)
movq %rax, 0x30(%rbx)
movq %rbx, %rax
popq %rbx
retq
| /realnc[P]frobtads/tads3/tcprsstm.cpp |
CTPNStmTryBase::get_control_flow(int) const | unsigned long CTPNStmTryBase::get_control_flow(int warn) const
{
unsigned long flags;
unsigned long fin_flags;
CTPNStmCatch *cur_catch;
/*
* First, determine the control flow through the protected code. If
* it exits, we either exit or proceed to the 'finally' clause.
*/
f... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x106e07
movq (%rdi), %rax
movl %ebp, %esi
callq *0xe0(%rax)
movq %rax, %rbx
jmp 0x106e0c
movl $0x1, %ebx
movq 0x30(%r14), %r15
testq %r15, %r15
je 0x106e2c
movq (%r15), %rax
movq %r15, %rdi
... | /realnc[P]frobtads/tads3/tcprsstm.cpp |
CTcPrsGramNodeCat::consolidate_or() | CTcPrsGramNode *CTcPrsGramNodeCat::consolidate_or()
{
CTcPrsGramNode *old_head;
CTcPrsGramNodeOr *new_or;
CTcPrsGramNode *cur;
CTcPrsGramNode *nxt;
int or_cnt;
/*
* Consolidate OR's in all subtrees. Before we do, stash away our
* entire subtree, since we'll rebuild the tree from... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
testq %rdi, %rdi
je 0x10714e
leaq 0x40(%rbx), %r12
movq (%rdi), %rax
movq 0x38(%rdi), %r14
callq *0x18(%rax)
movq 0x48(%rbx), %rcx
leaq 0x38(%rcx), %rdx
testq %r... | /realnc[P]frobtads/tads3/tcprsstm.cpp |
CTcPrsGramNodeCat::clone_expansion() const | virtual CTcPrsGramNode *clone_expansion() const
{
/* create a new 'cat' node */
CTcPrsGramNodeCat *new_cat = new (G_prsmem) CTcPrsGramNodeCat();
/* add a clone of each of my children and add it to my replica */
for (CTcPrsGramNode *cur = sub_head_ ; cur != 0 ; cur = cur->next_)
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x135335(%rip), %rax # 0x23d7b8
movq (%rax), %rdi
movl $0x58, %esi
callq 0xf6934
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x48(%rax)
leaq 0x10b647(%rip), %r... | /realnc[P]frobtads/tads3/tcprsstm.cpp |
CTcPrsGramNodeOr::consolidate_or() | virtual CTcPrsGramNode *consolidate_or()
{
CTcPrsGramNode *cur;
CTcPrsGramNode *nxt;
CTcPrsGramNode *old_head;
/*
* Consolidate OR's in all subtrees. If any of our immediate
* children turn into OR's, simply pull their children into our OR
* list di... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
testq %r15, %r15
je 0x10873f
leaq 0x40(%rbx), %r12
movq %r15, %rdi
movq (%r15), %rax
movq 0x38(%r15), %r15
callq *0x18(%rax)
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0... | /realnc[P]frobtads/tads3/tcprsstm.cpp |
CTcPrsGramNodeOr::advance_expansion() | virtual int advance_expansion()
{
/* advance to the next state */
cur_alt_ = cur_alt_->next_;
/*
* if that was the last state, wrap back to the first state and
* indicate a 'carry'; otherwise, indicate no carry
*/
if (cur_alt_ == 0)
{
... | pushq %rbx
movq %rdi, %rax
movq 0x50(%rdi), %rcx
movq 0x38(%rcx), %rdi
movq %rdi, 0x50(%rax)
xorl %ebx, %ebx
testq %rdi, %rdi
jne 0x1087c0
movq 0x40(%rax), %rdi
movq %rdi, 0x50(%rax)
movl $0x1, %ebx
movq (%rdi), %rax
callq *0x40(%rax)
movl %ebx, %eax
popq %rbx
retq
| /realnc[P]frobtads/tads3/tcprsstm.cpp |
CVmFileSource::get_size() | virtual long get_size()
{
/* remember the current seek location */
long oldpos = osfpos(fp);
/* seek to the end */
osfseek(fp, 0, OSFSK_END);
/* the current position is the file size */
long siz = osfpos(fp);
/* seek back to where we started */
osfs... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xc8030
movq %rax, %r14
movq 0x8(%rbx), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xc83a0
movq 0x8(%rbx), %rdi
callq 0xc8030
movq %rax, %r15
movq 0x8(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xc83a0
movq %r15, %rax
popq %rbx
popq %r14... | /realnc[P]frobtads/tads3/vmdatasrc.h |
CTcGenTarg::gen_rexpat_obj(char const*, unsigned long) | vm_obj_id_t CTcGenTarg::gen_rexpat_obj(const char *txt, size_t len)
{
/* write to RexPattern object stream */
CTcDataStream *rs = G_rexpat_stream;
/* generate a new object ID for the RexPattern object */
vm_obj_id_t id = new_obj_id();
/* add the object ID to the non-symbol object list */
G_prs... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x13289c(%rip), %rax # 0x23d810
movq (%rax), %r14
movl 0x50(%rdi), %ebx
leal 0x1(%rbx), %eax
movl %eax, 0x50(%rdi)
leaq 0x132829(%rip), %rax # 0x23d7b0
movq (%rax), %rdi
movl %eb... | /realnc[P]frobtads/tads3/tct3.cpp |
CTcGenTarg::close_method(int, CTcPrsSymtab*, CTcTokFileDesc*, long, tct3_method_gen_ctx*, CTcNamedArgTab*) | void CTcGenTarg::close_method(int local_cnt,
CTcPrsSymtab *local_symtab,
CTcTokFileDesc *end_desc, long end_linenum,
tct3_method_gen_ctx *ctx,
CTcNamedArgTab *named_arg_tab_head)
{
/* get the outp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movq %r8, 0x8(%rsp)
movq %rcx, %r14
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq 0x50(%rsp), %r13
movq (%r9), %rax
movq %rax, 0x10(%rsp)
callq 0x10a0aa
testl %eax, %eax
jne 0x10b32a
movq 0x8(%rsp), %rdx
leaq 0x1325... | /realnc[P]frobtads/tads3/tct3.cpp |
CTPNCodeBody::add_named_arg_tab(CTcNamedArgs const*) | CTcCodeLabel *CTPNCodeBody::add_named_arg_tab(const CTcNamedArgs *named_args)
{
/* allocate the tracking object */
CTcNamedArgTab *tab = new (G_prsmem) CTcNamedArgTab(named_args);
/* link it into our list */
tab->nxt = named_arg_tables_;
named_arg_tables_ = tab;
/* return the code label for th... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x131a0c(%rip), %rax # 0x23d7b8
movq (%rax), %rdi
movl $0x20, %esi
callq 0xf6934
movq %rax, %r15
movq 0x8(%rbx), %rax
movq %rax, (%r15)
movl (%rbx), %eax
movl %eax, 0x8(%r15)
leaq 0x1319f8(%rip), %rax # 0x23d7c8
movq (%rax), %rdi
callq 0xf4f80
... | /realnc[P]frobtads/tads3/tct3.cpp |
CTPNInh::gen_code_member(int, CTcPrsNode*, int, int, int, CTcNamedArgs*) | void CTPNInh::gen_code_member(int discard,
CTcPrsNode *prop_expr, int prop_is_expr,
int argc, int varargs, CTcNamedArgs *named_args)
{
vm_prop_id_t prop;
/* don't allow 'inherited' in speculative evaluation mode */
if (G_cg->is_speculative())
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, 0x4(%rsp)
leaq 0x130f90(%rip), %rax # 0x23d830
movq (%rax), %rax
movb 0xd0(%rax), %al
notb %al
testb $0x18, %al
je 0x10ca3b
movl %r9d, %r15d
movl %r8d, %ebp
movl %ecx, %r12d
movq %rdx, %r13
movq %rdi, %r14
leaq 0x130eff(%rip), %r... | /realnc[P]frobtads/tads3/tct3.cpp |
CTPNInhClass::gen_code_member(int, CTcPrsNode*, int, int, int, CTcNamedArgs*) | void CTPNInhClass::gen_code_member(int discard,
CTcPrsNode *prop_expr, int prop_is_expr,
int argc, int varargs,
CTcNamedArgs *named_args)
{
vm_prop_id_t prop;
CTcSymbol *objsym;
vm_obj_id_t obj;
/* ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r12d
movl %r8d, %ebp
movl %ecx, %r13d
movq %rdx, %rbx
movl %esi, 0xc(%rsp)
movq %rdi, %r14
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x130bc8(%rip), %r15 # 0x23d7c8
movq (%r15), %rax
testb $0x1, 0xa8(%rax)
jne 0x10c... | /realnc[P]frobtads/tads3/tct3.cpp |
CTPNConst::gen_code_obj_predot(int*) | vm_obj_id_t CTPNConst::gen_code_obj_predot(int *is_self)
{
/* we're certainly not "self" */
*is_self = FALSE;
/* if I don't have an object value, this is illegal */
if (val_.get_type() != TC_CVT_OBJ)
{
G_tok->log_error(TCERR_INVAL_OBJ_EXPR);
return VM_INVALID_OBJ;
}
/* repo... | pushq %rbx
movl $0x0, (%rsi)
cmpl $0x7, 0x8(%rdi)
jne 0x10d92e
movl 0x10(%rdi), %ebx
jmp 0x10d93c
xorl %ebx, %ebx
movl $0x2cff, %edi # imm = 0x2CFF
xorl %eax, %eax
callq 0x117408
movl %ebx, %eax
popq %rbx
retq
| /realnc[P]frobtads/tads3/tct3.cpp |
CTPNBin::gen_binary(unsigned char, int, int) | void CTPNBin::gen_binary(uchar opc, int discard, int for_condition)
{
/*
* generate the operands, passing through the discard and
* conditional status
*/
left_->gen_code(discard, for_condition);
right_->gen_code(discard, for_condition);
/* generate our operand if we're not discardi... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %ebx
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
movl %edx, %esi
movl %ecx, %edx
callq *(%rax)
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movl %r14d, %esi
movl %ebp, %edx
callq *(%rax)
testl %r14d, %r14d
jne 0x10d... | /realnc[P]frobtads/tads3/tct3.cpp |
CTPNNot::gen_code(int, int) | void CTPNNot::gen_code(int discard, int)
{
/*
* Generate the subexpression and apply the NOT opcode. Note that
* we can compute the subexpression as though we were applying a
* condition, because the NOT opcode takes exactly the same kind of
* input as any condition opcode; we can thus ... | pushq %rbx
movl %esi, %ebx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
movl $0x1, %edx
callq *(%rax)
testl %ebx, %ebx
je 0x10dd9f
popq %rbx
retq
leaq 0x12fa8a(%rip), %rax # 0x23d830
movq (%rax), %rdi
movl $0x2c, %esi
popq %rbx
jmp 0x10a114
| /realnc[P]frobtads/tads3/tct3.cpp |
CTPNIsIn::gen_code(int, int) | void CTPNIsIn::gen_code(int discard, int)
{
CTPNArglist *lst;
CTPNArg *arg;
CTcCodeLabel *lbl_found;
CTcCodeLabel *lbl_done;
/* allocate our 'found' label */
lbl_found = G_cs->new_label_fwd();
/*
* allocate our 'done' label - we only need to do this if we don't
* have a cons... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x12f399(%rip), %r13 # 0x23d7c8
movq (%r13), %rdi
callq 0xf4f80
movq %rax, %r15
testl %ebp, %ebp
jne 0x10e453
movb 0x18(%rbx), %al
andb $0x1, %al
jne 0x10e453
movq (%r13), %rdi
callq 0xf4f80
movq %rax, (... | /realnc[P]frobtads/tads3/tct3.cpp |
CTPNDivAsi::gen_code(int, int) | void CTPNDivAsi::gen_code(int discard, int)
{
/*
* ask the left subnode to generate a divide-and-assign; if it
* can't, handle it generically
*/
void *ctx;
if (!left_->gen_code_asi(discard, 1, TC_ASI_DIV, "/=",
right_, FALSE, TRUE, &ctx))
{
/*
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %r9
movq (%rdi), %rax
subq $0x8, %rsp
leaq 0x8(%rsp), %r15
leaq 0xaa98d(%rip), %r8 # 0x1b959f
movl $0x1, %edx
movl $0x4, %ecx
pushq %r15
pushq $0x1
pushq $0x0
callq *0x90(%rax)
addq $0x20, %... | /realnc[P]frobtads/tads3/tct3.cpp |
CTPNStrOneOf::gen_code(int, int) | void CTPNStrOneOf::gen_code(int discard, int for_condition)
{
/*
* There are two components to the <<one of>> list. First, there's the
* list of strings. Second, there's an anonymous OneOfIndexGen object
* that we create; this object holds our state and generates our index
* values.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, 0x3c(%rsp)
movl %esi, %ebx
movq %rdi, %r12
leaq 0x12d904(%rip), %rax # 0x23d7b0
movq (%rax), %rax
movq 0x80(%rax), %rdi
leaq 0xa96fa(%rip), %rsi # 0x1b95b7
movl $0xc, %edx
xorl %ecx, %ecx
movl $0x2, %r8d
callq 0xfd94e
c... | /realnc[P]frobtads/tads3/tct3.cpp |
CTPNMemArg::gen_code(int, int) | void CTPNMemArg::gen_code(int discard, int)
{
/* push the argument list */
int varargs;
CTcNamedArgs named_args;
get_arg_list()->gen_code_arglist(&varargs, named_args);
/* ask the object expression to generate the code */
get_obj_expr()->gen_code_member(discard, get_prop_expr(), prop_is_expr_,
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0x14(%rsp), %r15
leaq 0x18(%rsp), %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x1101c2
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rdx
movzbl 0x20(%r14), %ecx
andl $0x1, %ecx
movq 0x18(%r14), %rax
movl 0x8(... | /realnc[P]frobtads/tads3/tct3.cpp |
CTcSymProp::gen_code(int) | void CTcSymProp::gen_code(int discard)
{
/*
* Evaluating a property is equivalent to calling the property on
* the "self" object with no arguments. If there's no "self"
* object, an unqualified property evaluation is not possible, so
* log an error if this is the case.
*/
if... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x12c332(%rip), %r12 # 0x23d7c8
movq (%r12), %rax
testb $0x1, 0xa8(%rax)
jne 0x1114c2
movl 0x18(%r14), %esi
movq 0x10(%r14), %rdx
movl $0x2cf5, %edi # imm = 0x2CF5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq ... | /realnc[P]frobtads/tads3/tct3.cpp |
CTcSymProp::gen_code_addr() | void CTcSymProp::gen_code_addr()
{
/* write code to push the property ID */
G_cg->write_op(OPC_PUSHPROPID);
G_cs->write_prop_id(prop_);
/* note the push */
G_cg->note_push();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x12c256(%rip), %r14 # 0x23d830
movq (%r14), %rdi
movl $0xa, %esi
callq 0x10a114
leaq 0x12c1da(%rip), %rax # 0x23d7c8
movq (%rax), %rdi
movzwl 0x28(%rbx), %esi
callq 0xf4a80
movq (%r14), %rax
movl 0x54(%rax), %edx
leal 0x1(%rdx), %ecx
movl %ecx, 0x54(%rax)
cmp... | /realnc[P]frobtads/tads3/tct3.cpp |
CTcSymLocal::s_gen_code_setlcl_stk(int, int) | void CTcSymLocal::s_gen_code_setlcl_stk(int var_num, int is_param)
{
/* use the shortest form that will fit our variable index */
if (var_num <= 255)
{
/* use the one-byte instruction */
G_cg->write_op(is_param ? OPC_SETARG1 : OPC_SETLCL1);
G_cs->write((char)var_num);
}
else
... | pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x12b70d(%rip), %r14 # 0x23d830
movq (%r14), %rdi
xorl %eax, %eax
cmpl $0xff, %ebx
jg 0x112159
testl %esi, %esi
setne %al
leal 0xe0(,%rax,2), %esi
callq 0x10a114
leaq 0x12b680(%rip), %rax # 0x23d7c8
movq (%rax), %rdi
leaq 0x5(%rsp), %rsi
movb %bl, (%rsi)
movl ... | /realnc[P]frobtads/tads3/tct3.cpp |
CTcSymLocal::write_to_debug_frame(int) | int CTcSymLocal::write_to_debug_frame(int test_only)
{
/* if this is test-only mode, just note that we will write it */
if (test_only)
return TRUE;
/*
* For version 2+ static compilation, write the symbol name
* out-of-line, to the separate stream for local variable names. This
... | testl %esi, %esi
jne 0x11248a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x3, 0x18(%rdi)
leaq 0x12b574(%rip), %r13 # 0x23d878
movb $0x1, %bpl
jb 0x112329
cmpl $0x2, 0x18(%r13)
jl 0x112329
leaq 0x12b519(%rip), %rax # 0x23d830
movq (%rax), %rax
movb 0xd0(%rax)... | /realnc[P]frobtads/tads3/tct3.cpp |
CTcSymMetaclass::gen_code(int) | void CTcSymMetaclass::gen_code(int discard)
{
/*
* mark it as referenced - if the metaclass wasn't defined in this file
* but was merely imported from a symbol file, we now need to write it
* to the object file anyway, since its class object ID has been
* referenced
*/
ref_ = ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
orb $0x2, 0x58(%rdi)
leaq 0x12af40(%rip), %r14 # 0x23d830
movq (%r14), %rdi
movl $0x7, %esi
callq 0x10a114
leaq 0x12aec4(%rip), %rax # 0x23d7c8
movq (%rax), %rdi
movl 0x54(%rbx), %esi
callq 0xf4980
movq (%r14), %rax
movl 0x54(%rax), %edx
leal 0x1(%rdx), %ecx
movl %... | /realnc[P]frobtads/tads3/tct3.cpp |
CTcT3ExcTable::add_catch(unsigned long, unsigned long, unsigned long, unsigned long) | void CTcT3ExcTable::add_catch(ulong protected_start_ofs,
ulong protected_end_ofs,
ulong exc_obj_id, ulong catch_block_ofs)
{
CTcT3ExcEntry *entry;
/* if necessary, expand our table */
if (exc_used_ == exc_alloced_)
{
/* expand the tabl... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq 0x10(%rdi), %rsi
cmpq 0x18(%rdi), %rsi
jne 0x112bb6
addq $0x400, %rsi # imm = 0x400
movq %rsi, 0x18(%r14)
movq 0x8(%r14), %rdi
shlq $0x5, %rsi
callq 0xc8600
movq %rax, 0x... | /realnc[P]frobtads/tads3/tct3.cpp |
CTPNStmFor::gen_code(int, int) | void CTPNStmFor::gen_code(int, int)
{
CTcCodeLabel *top_lbl;
CTcCodeLabel *end_lbl;
CTcCodeLabel *cont_lbl;
CTPNStmEnclosing *old_enclosing;
CTcPrsSymtab *old_frame;
/* set my local frame if necessary */
old_frame = G_cs->set_local_frame(symtab_);
/*
* add a line record - note ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x128dc6(%rip), %rbx # 0x23d7c8
movq (%rbx), %rdi
movq 0x50(%r14), %rsi
callq 0xf4dc6
movq %rax, 0x10(%rsp)
movq %r14, %rdi
callq 0xdd67c
movq (%rbx), %rax
movq 0x98(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq %r14, 0x9... | /realnc[P]frobtads/tads3/tct3stm.cpp |
CTPNStmSwitch::gen_code(int, int) | void CTPNStmSwitch::gen_code(int, int)
{
CTPNStmSwitch *enclosing_switch;
int i;
char buf[VMB_DATAHOLDER + VMB_UINT2];
CTcCodeLabel *end_lbl;
CTPNStmEnclosing *old_enclosing;
/* add a line record */
add_debug_line_rec();
/* push the enclosing statement */
old_enclosing = G_cs->set_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0xdd67c
leaq 0x128507(%rip), %r13 # 0x23d7c8
movq (%r13), %rax
movq 0x98(%rax), %rbp
movq %rbx, 0x98(%rax)
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
xorl %r15d, %r15d
xorl %esi, %esi
xorl %edx, %edx
callq *(%rax)
m... | /realnc[P]frobtads/tads3/tct3stm.cpp |
CTPNStmTry::gen_jsr_finally() | void CTPNStmTry::gen_jsr_finally()
{
/* if we have a 'finally', call it */
if (finally_lbl_ != 0)
{
/* generate the local subroutine call */
G_cg->write_op(OPC_LJSR);
G_cs->write_ofs2(finally_lbl_, 0);
/*
* the LJSR pushes a value, which is then immediately poppe... | cmpq $0x0, 0x48(%rdi)
je 0x11595d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x127f3d(%rip), %r14 # 0x23d830
movq (%r14), %rdi
movl $0x9c, %esi
callq 0x10a114
leaq 0x127ec1(%rip), %rax # 0x23d7c8
movq (%rax), %rdi
movq 0x48(%rbx), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf5078
movq (%r14), %rax
mov... | /realnc[P]frobtads/tads3/tct3stm.cpp |
CTPNStmEnclosing::gen_code_continue_loop(CTcCodeLabel*, char const*, unsigned long) | int CTPNStmEnclosing::gen_code_continue_loop(CTcCodeLabel *code_label,
const textchar_t *lbl,
size_t lbl_len)
{
/*
* If the statement is labeled, let the enclosing statement handle
* it -- since it's labeled, we... | testq %rdx, %rdx
je 0x115e6a
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x115e9f
movq (%rdi), %rax
movq 0x100(%rax), %rax
movq %rdx, %rsi
movq %rcx, %rdx
jmpq *%rax
pushq %rbx
movq %rsi, %rbx
leaq 0x1279bb(%rip), %rax # 0x23d830
movq (%rax), %rdi
movl $0x91, %esi
callq 0x10a114
leaq 0x12793f(%rip), %rax # 0x23d7c8... | /realnc[P]frobtads/tads3/tct3stm.cpp |
CTPNObjProp::gen_code_inline_obj() | void CTPNObjProp::gen_code_inline_obj()
{
/* set the current source location for error reporting */
G_tok->set_line_info(file_, linenum_);
/* generate code for our expression or our code body, as appropriate */
if (inline_method_ != 0)
{
/*
* Code as an in-line method. This mea... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x127464(%rip), %rax # 0x23d7c0
movq (%rax), %rax
movups 0x10(%rdi), %xmm0
movups %xmm0, 0x38(%rax)
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0x116388
movq (%rdi), %rax
xorl %esi, %esi
xorl %edx, %edx
callq *(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %... | /realnc[P]frobtads/tads3/tct3stm.cpp |
CVmObjList::getp_last_index_of(vm_val_t*, vm_val_t const*, char const*, unsigned int*) | int CVmObjList::getp_last_index_of(VMG_ vm_val_t *retval,
const vm_val_t *self_val,
const char *lst, uint *argc)
{
vm_val_t subval;
size_t idx;
static CVmNativeCodeDesc desc(1);
/* check arguments */
if (get_prop_check_argc(retva... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movb 0xd4950(%rip), %al # 0x23fc30
testb %al, %al
je 0x16b34c
leaq 0xd4935(%rip), %rdx # 0x23fc20
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1349ea
testl %eax, %eax
jne 0x16b33d
leaq 0xd146f(%rip), %rax # 0x23c77... | /realnc[P]frobtads/tads3/vmlst.cpp |
CharConvUCS2B::pad(CVmDataSource*, char, long, CVmPackType const*) | virtual void pad(CVmDataSource *dst, char ch, long str_bytes,
const CVmPackType *t)
{ CVmPack::write_padding(dst, 0, ch, get_byte_count(t) - str_bytes); } | pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %rbx
cmpl $0x0, 0x28(%r8)
je 0x178803
movl 0x24(%r8), %ecx
testl %ecx, %ecx
movl $0x1, %eax
cmovnsl %ecx, %eax
jmp 0x17880c
movq (%rdi), %rax
movq %r8, %rsi
callq *0x18(%rax)
movslq %eax, %rcx
subq %r14, %rcx
movsbl %bpl, %edx
movq %rbx, %rdi
x... | /realnc[P]frobtads/tads3/vmpack.cpp |
CVmObjPattern::getp_get_str(unsigned int, vm_val_t*, unsigned int*) | int CVmObjPattern::getp_get_str(VMG_ vm_obj_id_t self,
vm_val_t *retval, uint *argc)
{
static CVmNativeCodeDesc desc(0);
/* check arguments */
if (get_prop_check_argc(retval, argc, &desc))
return TRUE;
/* retrieve my original string value */
*retval = *get_o... | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rdx, %rbx
movq %rdi, %r14
movb 0xc73a0(%rip), %al # 0x23fe70
testb %al, %al
je 0x178b00
leaq 0xc7385(%rip), %rdx # 0x23fe60
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1349ea
testl %eax, %eax
jne 0x178af5
movq 0x8(%r14), %rax
movups 0x8(%rax), %xmm0
movups %xm... | /realnc[P]frobtads/tads3/vmpat.cpp |
CVmObjPattern::create_from_stack(unsigned char const**, unsigned int) | vm_obj_id_t CVmObjPattern::create_from_stack(VMG_ const uchar **pc_ptr,
uint argc)
{
const char *strval;
re_status_t stat;
re_compiled_pattern *pat;
vm_obj_id_t id;
/* check arguments */
if (argc != 1)
err_throw(VMERR_WRONG_NUM_OF_ARGS);
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpl $0x1, %esi
jne 0x178c74
leaq 0xc3bb5(%rip), %r15 # 0x23c770
movq (%r15), %rdi
addq $-0x10, %rdi
callq 0x18b77c
testq %rax, %rax
je 0x178c7e
leaq 0xc5b79(%rip), %rcx # 0x23e750
movq (%rcx), %rcx
movq (%rcx), %rdi
movq %rax, %rsi
addq $0... | /realnc[P]frobtads/tads3/vmpat.cpp |
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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rdi
movq %rax, 0x10(%rbx)
movq $0x7, 0x18(%rbx)
movq %rdi, %rax
shrq $0x20, %rax
je 0x1ddb0
callq 0x1e3b0
movq 0x8(%rbx), %rdi
testl $0xe0000000, %edi # imm = 0xE0000000
jne 0x1ddc8
shlq $0x3, %rdi
movq %rdi, 0x20(%rbx)
addq $0x8,... | /qpdf[P]qpdf/libqpdf/BitStream.cc |
write_bits(unsigned char&, unsigned long&, unsigned long long, unsigned long, Pipeline*) | static void
write_bits(
unsigned char& ch, size_t& bit_offset, unsigned long long val, size_t bits, Pipeline* pipeline)
{
if (bits > 32) {
throw std::out_of_range("write_bits: too many bits requested");
}
// bit_offset + 1 is the number of bits left in ch
# ifdef BITS_TESTING
if (bits == 0)... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq $0x20, %rcx
ja 0x1e730
movq %rcx, %r14
testq %rcx, %rcx
je 0x1e726
movq %r8, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %r14, %rdx
movq (%r12), %rsi
incq %rsi
cmpq %r14, %rsi
movq %r14, %rax
cmovbq %rsi, %rax
subq %rax, %r14
movq %r15, %rdi
movl... | /qpdf[P]qpdf/libqpdf/qpdf/bits_functions.hh |
Buffer::Buffer() | Buffer::Buffer() :
m(new Members(0, nullptr, true))
{
} | pushq %rbx
movq %rdi, %rbx
movl $0x38, %edi
callq 0x19180
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %rax, (%rbx)
popq %rbx
retq
nop
| /qpdf[P]qpdf/libqpdf/Buffer.cc |
Buffer::copy(Buffer const&) | void
Buffer::copy(Buffer const& rhs)
{
if (this != &rhs) {
m = std::unique_ptr<Members>(new Members(rhs.m->size, nullptr, true));
if (m->size) {
memcpy(m->buf, rhs.m->buf, m->size);
}
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq %rsi, %rdi
je 0x1eaa0
movq %rsi, %rbx
movq %rdi, %r14
movl $0x38, %edi
callq 0x19180
movq %rax, %r15
movq (%rbx), %rax
movq 0x28(%rax), %rdi
leaq 0x10(%r15), %rax
movq %rax, (%r15)
xorl %eax, %eax
movq %rax, 0x8(%r15)
movb $0x0, 0x10(%r15)
movb $0x1, 0x20(%r15... | /qpdf[P]qpdf/libqpdf/Buffer.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 %r14
pushq %rbx
pushq %rax
movq 0xd8(%rdi), %rax
testq %rax, %rax
js 0x1ee4e
movq %rdi, %r14
movq 0xe0(%rdi), %rbx
cmpq %rbx, %rax
jge 0x1ee10
movq 0xd0(%r14), %rdi
callq 0x1ead4
movq 0xd8(%r14), %rcx
cmpq %rbx, %rcx
jge 0x1ee14
leaq (%rax,%rbx), %rdx
movzbl (%rax,%rcx), %esi
cmpl $0xa, %esi
je 0x1ee26
cmpl $0xd,... | /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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0xd8(%rdi), %rax
testq %rax, %rax
js 0x1f0a3
movq %rdi, %r14
movq 0xe0(%rdi), %rcx
movq %rcx, %r12
subq %rax, %r12
jle 0x1f08e
movq %rdx, %rbx
movq %rsi, %r15
movq %rax, 0x8(%r14)
jns 0x1f050
movq %r12, %rdi
callq 0x1f5b2
cmpq %rbx, %r12
cmovbq %r12, %rbx
movq... | /qpdf[P]qpdf/libqpdf/BufferInputSource.cc |
MD5::encodeString(char const*) | void
MD5::encodeString(char const* str)
{
size_t len = strlen(str);
crypto->MD5_init();
encodeDataIncrementally(str, len);
crypto->MD5_finalize();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x19420
movq %rax, %r15
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%r14), %r12
movq %rbx, %rdi
callq 0x13ec0b
movq (%r12), %rcx
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq *0x20(%rcx)
... | /qpdf[P]qpdf/libqpdf/MD5.cc |
MD5::print() | void
MD5::print()
{
Digest digest_val;
digest(digest_val);
unsigned int i;
for (i = 0; i < 16; ++i) {
printf("%02x", digest_val[i]);
}
printf("\n");
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq (%rbx), %rdi
movq (%rdi), %rax
movq %rsp, %rsi
callq *0x30(%rax)
leaq 0x134a80(%rip), %rbx # 0x15f4da
xorl %r14d, %r14d
movzbl (%rsp,%r14), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19070
incq %r14
cm... | /qpdf[P]qpdf/libqpdf/MD5.cc |
MD5::unparse[abi:cxx11]() | std::string
MD5::unparse()
{
this->crypto->MD5_finalize();
Digest digest_val;
digest(digest_val);
return QUtil::hex_encode(std::string(reinterpret_cast<char*>(digest_val), 16));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq (%r14), %rdi
movq (%rdi), %rax
leaq 0x30(%rsp), %r14
movq %r14, %rsi
callq *0x30(%rax)
leaq 0x18(%rsp),... | /qpdf[P]qpdf/libqpdf/MD5.cc |
MD5::getDataChecksum[abi:cxx11](char const*, unsigned long) | std::string
MD5::getDataChecksum(char const* buf, size_t len)
{
MD5 m;
m.encodeDataIncrementally(buf, len);
return m.unparse();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2a6cc
movq (%r15), %r15
movq %r12, %rdi
callq 0x13ec0b
movq (%r15), %rcx
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq *0x20(%rcx)
leaq 0x8(%rsp), %rsi
movq %... | /qpdf[P]qpdf/libqpdf/MD5.cc |
MD5::checkDataChecksum(char const*, char const*, unsigned long) | bool
MD5::checkDataChecksum(char const* const checksum, char const* buf, size_t len)
{
std::string actual_checksum = getDataChecksum(buf, len);
return (checksum == actual_checksum);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2ab5a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19a70
movl %eax, %ebx
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2ac8c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
testl %ebx, %ebx
sete %al
addq $0x28, %... | /qpdf[P]qpdf/libqpdf/MD5.cc |
NNTreeIterator::updateIValue(bool) | void
NNTreeIterator::updateIValue(bool allow_invalid)
{
// ivalue should never be used inside the class since we return a pointer/reference to it. Every
// bit of code that ever changes what object the iterator points to should take care to call
// updateIValue. Failure to do this means that any old referen... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x0, 0x38(%rdi)
js 0x2ae2a
leaq 0x28(%rbx), %r14
movq %r14, %rdi
callq 0xc302e
testb %al, %al
je 0x2ae2a
movq 0x8(%rbx), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r... | /qpdf[P]qpdf/libqpdf/NNTree.cc |
NNTreeIterator::increment(bool) | void
NNTreeIterator::increment(bool backward)
{
if (this->item_number < 0) {
QTC::TC("qpdf", "NNTree increment end()");
deepen(impl.oh, !backward, true);
return;
}
bool found_valid_key = false;
while (valid() && (!found_valid_key)) {
this->item_number += backward ? -2 : 2... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movl 0x38(%rdi), %eax
testl %eax, %eax
js 0x2b8f5
movl %esi, %ecx
xorb $0x1, %cl
movzbl %cl, %ecx
movq %rcx, 0xc0(%rsp)
leal -0x2(,%rcx,4), %ecx
movl %ecx, 0x4c(%rsp)
leaq 0x28(%rbx), %rcx
movq %rcx, 0x28(%rsp)
leaq 0x30(... | /qpdf[P]qpdf/libqpdf/NNTree.cc |
NNTreeIterator::deepen(QPDFObjectHandle, bool, bool) | bool
NNTreeIterator::deepen(QPDFObjectHandle node, bool first, bool allow_empty)
{
// Starting at this node, descend through the first or last kid until we reach a node with
// items. If we succeed, return true; otherwise return false and leave path alone.
auto opath = this->path;
bool failed = false;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %ecx, 0x94(%rsp)
movl %edx, 0x4c(%rsp)
movq %rsi, %r15
movq %rdi, 0x20(%rsp)
leaq 0x10(%rdi), %rbx
leaq 0xe0(%rsp), %rdi
movq %rbx, %rsi
callq 0x309fa
leaq 0x100(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ec... | /qpdf[P]qpdf/libqpdf/NNTree.cc |
QIntC::IntConverter<unsigned long, unsigned char, false, false>::error(unsigned 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 unsigned type to a " << sizeof(To) << "-byte unsigned type";
throw... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x19af0
movq (%r14), %rax
movq -0x18(%rax), %r14
callq 0x19130
leaq (%rsp,%r14), %rsi
addq $0x28, %rsi
movq %rsp, %rdi
movq %rax, %rdx
callq 0x195d0
movq %rsp, %rdi
callq 0x19b40
leaq ... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
Pl_ASCII85Decoder::write(unsigned char const*, unsigned long) | void
Pl_ASCII85Decoder::write(unsigned char const* buf, size_t len)
{
if (eod > 1) {
return;
}
for (size_t i = 0; i < len; ++i) {
switch (buf[i]) {
case ' ':
case '\f':
case '\v':
case '\t':
case '\r':
case '\n':
QTC::TC("libtests",... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpq $0x2, 0x40(%rdi)
setae %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x328e4
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
movb (%r15,%r13), %al
movzbl %al, %ecx
leal -0x9(%rcx), %edx
cmpl $0x5, %edx
j... | /qpdf[P]qpdf/libqpdf/Pl_ASCII85Decoder.cc |
Pl_ASCII85Decoder::~Pl_ASCII85Decoder() | ~Pl_ASCII85Decoder() final = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x1b8661(%rip), %rax # 0x1eb070
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x32a2a
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movl $0x50, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x190e0
| /qpdf[P]qpdf/libqpdf/qpdf/Pl_ASCII85Decoder.hh |
Pl_Base64::~Pl_Base64() | ~Pl_Base64() final = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x1b7ccb(%rip), %rax # 0x1eb070
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x333c0
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movl $0x48, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x190e0
| /qpdf[P]qpdf/libqpdf/qpdf/Pl_Base64.hh |
Pl_Count::write(unsigned char const*, unsigned long) | void
Pl_Count::write(unsigned char const* buf, size_t len)
{
if (len) {
m->count += QIntC::to_offset(len);
m->last_char = buf[len - 1];
next()->write(buf, len);
}
} | testq %rdx, %rdx
je 0x33c10
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
jns 0x33be9
movq %rbx, %rdi
callq 0x1f1ec
movq 0x30(%r15), %rax
addq %rbx, (%rax)
movb -0x1(%r14,%rbx), %cl
movb %cl, 0x8(%rax)
movq 0x28(%r15), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq %r14, %rsi
movq ... | /qpdf[P]qpdf/libqpdf/Pl_Count.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.