name string | code string | asm string | file string |
|---|---|---|---|
xmlXPathTrailing | xmlNodeSetPtr
xmlXPathTrailing (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
if (xmlXPathNodeSetIsEmpty(nodes2))
return(nodes1);
if (xmlXPathNodeSetIsEmpty(nodes1))
return(xmlXPathNodeSetCreate(NULL));
xmlXPathNodeSetSort(nodes1);
xmlXPathNodeSetSort(nodes2);
return(xmlXPathNodeTrailingSorted(nod... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0xce60c
movq %rsi, %r14
cmpl $0x0, (%rsi)
je 0xce60c
cmpq $0x0, 0x8(%r14)
je 0xce60c
testq %rbx, %rbx
je 0xce617
cmpl $0x0, (%rbx)
je 0xce617
cmpq $0x0, 0x8(%rbx)
je 0xce617
movq %rbx, %rdi
callq 0x35da0
movq %r14, %rdi
callq 0x35da0
cmpl $0x0, (%r14)... | /frida[P]libxml2/xpath.c |
xmlXPathFunctionLookupNS | xmlXPathFunction
xmlXPathFunctionLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
const xmlChar *ns_uri) {
xmlXPathFunction ret;
if (ctxt == NULL)
return(NULL);
if (name == NULL)
return(NULL);
if (ctxt->funcLookupFunc != NULL) {
xmlXPathFuncLookupFunc f;
f = ctxt->funcLookupFunc;
ret =... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0xce739
xorl %eax, %eax
jmp 0xce762
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0xb8(%rdi), %rax
testq %rax, %rax
je 0xce768
movq 0xc0(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%rax
testq %rax, %rax
je... | /frida[P]libxml2/xpath.c |
xmlXPathVariableLookup | xmlXPathObjectPtr
xmlXPathVariableLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
if (ctxt == NULL)
return(NULL);
if (ctxt->varLookupFunc != NULL) {
xmlXPathObjectPtr ret;
ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
(ctxt->varLookupData, name, NULL);
return(ret);
}
retu... | testq %rdi, %rdi
je 0xce86d
movq 0x90(%rdi), %rax
testq %rax, %rax
je 0xce870
movq 0x98(%rdi), %rdi
xorl %edx, %edx
jmpq *%rax
xorl %eax, %eax
retq
xorl %edx, %edx
jmp 0x352c0
| /frida[P]libxml2/xpath.c |
xmlXPathNewString | xmlXPathObjectPtr
xmlXPathNewString(const xmlChar *val) {
xmlXPathObjectPtr ret;
ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
if (ret == NULL) {
xmlXPathErrMemory(NULL, "creating string object\n");
return(NULL);
}
memset(ret, 0 , sizeof(xmlXPathObject));
ret->type = XPA... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x5e430(%rip), %rax # 0x12cfd0
pushq $0x48
popq %rdi
callq *(%rax)
movq %rax, %rbx
testq %rax, %rax
je 0xcebd4
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x30(%rbx)
andq $0x0, 0x40(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movl $0x4, (%r... | /frida[P]libxml2/xpath.c |
xmlXPathNewCString | xmlXPathObjectPtr
xmlXPathNewCString(const char *val) {
xmlXPathObjectPtr ret;
ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
if (ret == NULL) {
xmlXPathErrMemory(NULL, "creating string object\n");
return(NULL);
}
memset(ret, 0 , sizeof(xmlXPathObject));
ret->type = XPATH... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x5e36c(%rip), %rax # 0x12cfd0
pushq $0x48
popq %rdi
callq *(%rax)
movq %rax, %rbx
testq %rax, %rax
je 0xcec9c
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x40(%rbx)
movl $0x4, (%r... | /frida[P]libxml2/xpath.c |
xmlXPathFreeValueTree | static void
xmlXPathFreeValueTree(xmlNodeSetPtr obj) {
int i;
if (obj == NULL) return;
if (obj->nodeTab != NULL) {
for (i = 0;i < obj->nodeNr;i++) {
if (obj->nodeTab[i] != NULL) {
if (obj->nodeTab[i]->type == XML_NAMESPACE_DECL) {
xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
} else {... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xcee25
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0xcee12
xorl %r14d, %r14d
movslq (%rbx), %rax
cmpq %rax, %r14
jge 0xcee05
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0xcee00
cmpl $0x12, 0x8(%rdi)
jne 0xcedfb
callq 0x34ce0
jmp 0xcee00
callq 0x33c... | /frida[P]libxml2/xpath.c |
xmlXPathCastBooleanToString | xmlChar *
xmlXPathCastBooleanToString (int val) {
xmlChar *ret;
if (val)
ret = xmlStrdup((const xmlChar *) "true");
else
ret = xmlStrdup((const xmlChar *) "false");
return(ret);
} | testl %edi, %edi
leaq 0x20ba9(%rip), %rax # 0xef9df
leaq 0x20b9d(%rip), %rdi # 0xef9da
cmoveq %rax, %rdi
jmp 0x35fc0
| /frida[P]libxml2/xpath.c |
xmlXPathConvertBoolean | xmlXPathObjectPtr
xmlXPathConvertBoolean(xmlXPathObjectPtr val) {
xmlXPathObjectPtr ret;
if (val == NULL)
return(xmlXPathNewBoolean(0));
if (val->type == XPATH_BOOLEAN)
return(val);
ret = xmlXPathNewBoolean(xmlXPathCastToBoolean(val));
xmlXPathFreeObject(val);
return(ret);
} | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xcf4f5
movq %rdi, %rbx
cmpl $0x2, (%rdi)
jne 0xcf503
movq %rbx, %rax
jmp 0xcf520
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x32550
movq %rbx, %rdi
callq 0x32de0
movl %eax, %edi
callq 0x32550
movq %rax, %r14
movq %rbx, %rdi
callq 0x32390
movq %r14, %rax... | /frida[P]libxml2/xpath.c |
xmlXPathFreeParserContext | void
xmlXPathFreeParserContext(xmlXPathParserContextPtr ctxt) {
int i;
if (ctxt->valueTab != NULL) {
for (i = 0; i < ctxt->valueNr; i++) {
if (ctxt->context)
xmlXPathReleaseObject(ctxt->context, ctxt->valueTab[i]);
else
xmlXPathFreeObject(ctxt->va... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x30(%rdi)
je 0xcf9f1
xorl %r14d, %r14d
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jge 0xcf9e4
movq 0x18(%rbx), %rdi
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rsi
testq %rdi, %rdi
je 0xcf9d7
callq 0xcce80
jmp 0xcf9df
movq %rsi, %rdi
callq 0x32390
incq %r14
jmp 0... | /frida[P]libxml2/xpath.c |
xmlXPathEqualValuesCommon | static int
xmlXPathEqualValuesCommon(xmlXPathParserContextPtr ctxt,
xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
int ret = 0;
/*
*At this point we are assured neither arg1 nor arg2
*is a nodeset, so we can just pick the appropriate routine.
*/
switch (arg1->type) {
case XPATH_U... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl (%rsi), %eax
xorl %r12d, %r12d
addl $-0x2, %eax
cmpl $0x6, %eax
ja 0xd0379
leaq 0x29618(%rip), %rcx # 0xf972c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl (%r14), %eax
addl $-0x2, %eax
cmpl $0x6... | /frida[P]libxml2/xpath.c |
xmlXPathCompareNodeSets | static int
xmlXPathCompareNodeSets(int inf, int strict,
xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
int i, j, init = 0;
double val1;
double *values2;
int ret = 0;
xmlNodeSetPtr ns1;
xmlNodeSetPtr ns2;
if ((arg1 == NULL) ||
((arg1->type != XPATH_NODESET) && (arg1->typ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movl (%rdx), %eax
orl $0x8, %eax
cmpl $0x9, %eax
jne 0xd0a77
movq %rdx, %r14
movl (%rbx), %eax
orl $0x8, %eax
cmpl $0x9, %eax
jne 0xd0a6f
movq 0x8(%r14), %r13
testq %r13, %r13
je 0xd0a6f
cmpl $0x0, (%r13)
jle 0xd0a6f
movq... | /frida[P]libxml2/xpath.c |
xmlXPathNextDescendant | xmlNodePtr
xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
if (cur == NULL) {
if (ctxt->context->node == NULL)
return(NULL);
if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
(ctxt->context->node->type == XML... | testq %rdi, %rdi
je 0xd122d
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0xd122d
testq %rsi, %rsi
je 0xd1219
cmpl $0x12, 0x8(%rsi)
je 0xd122d
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0xd11d5
movl 0x8(%rax), %edx
cmpl $0x11, %edx
je 0xd11d5
cmpl $0xe, %edx
jne 0xd1218
movq %rax, %rsi
movq 0x8(%rcx), %rcx
cmpq %rcx, %rsi
j... | /frida[P]libxml2/xpath.c |
xmlXPathNextPrecedingSibling | xmlNodePtr
xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
(ctxt->context->node->type == XML_NAMESPACE_DECL))
return(NULL);
if (cur == (xmlNodePtr) ctxt->cont... | testq %rdi, %rdi
je 0xd1497
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0xd1497
movq 0x8(%rcx), %rax
movl 0x8(%rax), %edx
orl $0x10, %edx
cmpl $0x12, %edx
jne 0xd149a
xorl %eax, %eax
retq
cmpq %rsi, (%rcx)
je 0xd1497
testq %rsi, %rsi
je 0xd14b8
movq 0x38(%rsi), %rax
testq %rax, %rax
je 0xd1497
cmpl $0xe, 0x8(%rax)
cmoveq... | /frida[P]libxml2/xpath.c |
xmlXPathStringFunction | void
xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
xmlXPathObjectPtr cur;
if (ctxt == NULL) return;
if (nargs == 0) {
valuePush(ctxt,
xmlXPathCacheWrapString(ctxt->context,
xmlXPathCastNodeToString(ctxt->context->node)));
return;
}
CHECK_ARITY(1);
cur = valuePop... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd2023
movq %rdi, %rbx
cmpl $0x1, %esi
je 0xd202b
testl %esi, %esi
jne 0xd205e
movq 0x18(%rbx), %r14
movq 0x8(%r14), %rdi
callq 0x32a90
movq %r14, %rdi
movq %rax, %rsi
callq 0xd2078
jmp 0xd204c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x28(%rbx), %eax
cmpl 0x50... | /frida[P]libxml2/xpath.c |
xmlXPathSubstringAfterFunction | void
xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs) {
xmlXPathObjectPtr str;
xmlXPathObjectPtr find;
xmlBufPtr target;
const xmlChar *point;
int offset;
CHECK_ARITY(2);
CAST_TO_STRING;
find = valuePop(ctxt);
CAST_TO_STRING;
str = valuePop(ctxt);
target = xmlBufCreate();... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd2955
movq %rdi, %rbx
cmpl $0x2, %esi
jne 0xd2964
movl 0x50(%rbx), %eax
addl $0x2, %eax
cmpl %eax, 0x28(%rbx)
jge 0xd297d
pushq $0x17
jmp 0xd2966
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp... | /frida[P]libxml2/xpath.c |
xmlXPathCeilingFunction | void
xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs) {
CHECK_ARITY(1);
CAST_TO_NUMBER;
CHECK_TYPE(XPATH_NUMBER);
#ifdef _AIX
/* Work around buggy ceil() function on AIX */
ctxt->value->floatval = copysign(ceil(ctxt->value->floatval), ctxt->value->floatval);
#else
ctxt->value->... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd31a2
movq %rdi, %rbx
cmpl $0x1, %esi
jne 0xd31aa
movl 0x28(%rbx), %eax
cmpl 0x50(%rbx), %eax
jle 0xd31ae
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0xd31b2
cmpl $0x3, (%r14)
je 0xd3191
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x35f40
movq 0x20(%rbx), %r14
testq %... | /frida[P]libxml2/xpath.c |
xmlXPathParseNCName | xmlChar *
xmlXPathParseNCName(xmlXPathParserContextPtr ctxt) {
const xmlChar *in;
xmlChar *ret;
int count = 0;
if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
/*
* Accelerator for simple ASCII names
*/
in = ctxt->cur;
if (((*in >= 0x61) && (*in <= 0x7A)) ||
((*in >= 0x41... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd3327
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xd3327
movb (%rdi), %al
leal -0x61(%rax), %ecx
cmpb $0x1a, %cl
jb 0xd32cc
leal -0x41(%rax), %ecx
cmpb $0x1a, %cl
setae %cl
cmpb $0x5f, %al
setne %al
testb %cl, %al
jne 0xd3331
pushq $0x1
popq %rsi
movabsq... | /frida[P]libxml2/xpath.c |
xmlXPathEvaluatePredicateResult | int
xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt,
xmlXPathObjectPtr res) {
if ((ctxt == NULL) || (res == NULL)) return(0);
switch (res->type) {
case XPATH_BOOLEAN:
return(res->boolval);
case XPATH_NUMBER:
#if defined(__BORLANDC__) || (defined... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xd3a6f
movl (%rsi), %eax
decl %eax
cmpl $0x8, %eax
ja 0xd3a14
leaq 0x25e31(%rip), %rcx # 0xf982c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0xd3a... | /frida[P]libxml2/xpath.c |
xmlXPathOptimizeExpression | static void
xmlXPathOptimizeExpression(xmlXPathParserContextPtr pctxt,
xmlXPathStepOpPtr op)
{
xmlXPathCompExprPtr comp = pctxt->comp;
xmlXPathContextPtr ctxt;
/*
* Try to rewrite "descendant-or-self::node()/foo" to an optimized
* internal representation.
*/
if (... | movl (%rsi), %eax
cmpl $0xb, %eax
je 0xd3f3c
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %r15
cmpl $0xa, %eax
jne 0xd3ece
movslq 0x4(%r14), %rcx
cmpq $-0x1, %rcx
je 0xd3ece
cmpl $-0x1, 0x8(%r14)
jne 0xd3ece
movq 0x8(%r15), %rax
imulq $0x38, %rcx, %rcx
cmpl $0x... | /frida[P]libxml2/xpath.c |
xmlXPathEvalExpr | void
xmlXPathEvalExpr(xmlXPathParserContextPtr ctxt) {
#ifdef XPATH_STREAMING
xmlXPathCompExprPtr comp;
#endif
int oldDepth = 0;
if (ctxt == NULL) return;
#ifdef XPATH_STREAMING
comp = xmlXPathTryStreamCompile(ctxt->context, ctxt->base);
if (comp != NULL) {
if (ctxt->comp != NULL)
xml... | pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xd41b2
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq 0x18(%rdi), %rdi
callq 0xd3b6c
testq %rax, %rax
je 0xd417f
movq %rax, %r14
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xd416d
callq 0x32570
movq %r14, 0x38(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq... | /frida[P]libxml2/xpath.c |
xmlXPathSetContextNode | int
xmlXPathSetContextNode(xmlNodePtr node, xmlXPathContextPtr ctx) {
if ((node == NULL) || (ctx == NULL))
return(-1);
if (node->doc == ctx->doc) {
ctx->node = node;
return(0);
}
return(-1);
} | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
pushq $-0x1
popq %rax
jne 0xd44b9
movq 0x40(%rdi), %rcx
cmpq (%rsi), %rcx
je 0xd44ba
retq
movq %rdi, 0x8(%rsi)
xorl %eax, %eax
retq
| /frida[P]libxml2/xpath.c |
libxml_domnode_tim_sort_merge | static void TIM_SORT_MERGE(SORT_TYPE *dst, const TIM_SORT_RUN_T *stack, const int stack_curr,
TEMP_STORAGE_T *store) {
const size_t A = stack[stack_curr - 2].length;
const size_t B = stack[stack_curr - 1].length;
const size_t curr = stack[stack_curr - 2].start;
SORT_TYPE *storage;
s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdi, %rbp
movslq %edx, %rax
shlq $0x4, %rax
movq -0x18(%rsi,%rax), %r13
movq -0x8(%rsi,%rax), %rcx
cmpq %rcx, %r13
movq %rcx, %rbx
cmovbq %r13, %rbx
movq -0x20(%rsi,%rax), %r14
movq 0x8(%r15), %rax
cmpq %rbx, (%r15)... | /frida[P]libxml2/timsort.h |
xmlPointerListCreate | static xmlPointerListPtr
xmlPointerListCreate(int initialSize)
{
xmlPointerListPtr ret;
ret = xmlMalloc(sizeof(xmlPointerList));
if (ret == NULL) {
xmlXPathErrMemory(NULL,
"xmlPointerListCreate: allocating item\n");
return (NULL);
}
memset(ret, 0, sizeof(xmlPointerList));
if (initialSize... | pushq %rbx
movq 0x581d9(%rip), %rax # 0x12cfd0
pushq $0x10
popq %rdi
callq *(%rax)
movq %rax, %rbx
testq %rax, %rax
je 0xd4e1d
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
pushq $0xa
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xd4e30
andl $0x0, 0x8(%rbx)
jmp 0xd4e2b
leaq 0x25679(%rip), %rsi # 0xfa49d
xorl %edi,... | /frida[P]libxml2/xpath.c |
xmlXPathNodeValHash | static unsigned int
xmlXPathNodeValHash(xmlNodePtr node) {
int len = 2;
const xmlChar * string = NULL;
xmlNodePtr tmp = NULL;
unsigned int ret = 0;
if (node == NULL)
return(0);
if (node->type == XML_DOCUMENT_NODE) {
tmp = xmlDocGetRootElement((xmlDocPtr) node);
if (tmp == NULL)
node = ... | pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0xd5008
movq %rdi, %r14
cmpl $0x9, 0x8(%rdi)
jne 0xd4f1b
movq %r14, %rdi
callq 0x32870
testq %rax, %rax
jne 0xd4f1e
movq 0x18(%r14), %rax
testq %rax, %rax
jne 0xd4f1e
jmp 0xd5008
movq %r14, %rax
movl 0x8(%rax), %ecx
cmpl $0x12, %ecx
ja 0xd5008
movl $0... | /frida[P]libxml2/xpath.c |
xmlXPathCompExprAdd | static int
xmlXPathCompExprAdd(xmlXPathParserContextPtr ctxt, int ch1, int ch2,
xmlXPathOp op, int value,
int value2, int value3, void *value4, void *value5) {
xmlXPathCompExprPtr comp = ctxt->comp;
if (comp->nbStep >= comp->maxStep) {
xmlXPathStepOp *real;
if (comp->maxStep >= XPATH_MAX_STEPS) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r15d
movl %ecx, %ebp
movl %edx, %r12d
movl %esi, %r13d
movq 0x38(%rdi), %r14
movl (%r14), %eax
movslq 0x4(%r14), %rcx
cmpl %ecx, %eax
jge 0xd522a
movq 0x8(%r14), %rcx
jmp 0xd526e
movq %rdi, %rbx
cmpl $0xf4240, %ecx # imm =... | /frida[P]libxml2/xpath.c |
xmlXPathCompAdditiveExpr | static void
xmlXPathCompAdditiveExpr(xmlXPathParserContextPtr ctxt) {
xmlXPathCompMultiplicativeExpr(ctxt);
CHECK_ERROR;
SKIP_BLANKS;
while ((CUR == '+') || (CUR == '-')) {
int plus;
int op1 = ctxt->comp->last;
if (CUR == '+') plus = 1;
else plus = 0;
NEXT;
SKIP_BLANKS;
xmlXPathCo... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0xd564f
cmpl $0x0, 0x10(%rbx)
jne 0xd5644
movq (%rbx), %rax
movabsq $0x100002600, %r14 # imm = 0x100002600
movzbl (%rax), %r15d
cmpq $0x20, %r15
ja 0xd5607
btq %r15, %r14
jae 0xd5607
incq %rax
movq %rax, (%rbx)
jmp 0xd55a6
xorl %r8d... | /frida[P]libxml2/xpath.c |
xmlXPathCompPathExpr | static void
xmlXPathCompPathExpr(xmlXPathParserContextPtr ctxt) {
int lc = 1; /* Should we branch to LocationPath ? */
xmlChar *name = NULL; /* we may have to preparse a name to find out */
SKIP_BLANKS;
if ((CUR == '$') || (CUR == '(') ||
(IS_ASCII_DIGIT(CUR)) ||
(CUR == '\''... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rdi), %rbp
movq %rbp, %r14
incq %r14
movabsq $0x100002600, %r13 # imm = 0x100002600
movzbl -0x1(%r14), %edx
cmpq $0x28, %rdx
ja 0xd5933
btq %rdx, %r13
jae 0xd591b
movq %r14, (%rbx)
incl %ebp
incq %r14
jmp 0xd5... | /frida[P]libxml2/xpath.c |
xmlXPathCompPredicate | static void
xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter) {
int op1 = ctxt->comp->last;
SKIP_BLANKS;
if (CUR != '[') {
XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
}
NEXT;
SKIP_BLANKS;
ctxt->comp->last = -1;
/*
* This call to xmlXPathCompileExpr() will deactivate so... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x38(%rdi), %rax
movl 0x10(%rax), %ebp
incq %rcx
movabsq $0x100002600, %r15 # imm = 0x100002600
movzbl -0x1(%rcx), %edx
cmpq $0x20, %rdx
ja 0xd66ff
btq %rdx, %r15
jae 0xd66ff
movq %rcx, (%rbx)
incq ... | /frida[P]libxml2/xpath.c |
xmlXPathRunStreamEval | static int
xmlXPathRunStreamEval(xmlXPathContextPtr ctxt, xmlPatternPtr comp,
xmlXPathObjectPtr *resultSeq, int toBool)
{
int max_depth, min_depth;
int from_root;
int ret, depth;
int eval_all_nodes;
xmlNodePtr cur = NULL, limit = NULL;
xmlStreamCtxtPtr patstream = NULL;
if ((ctxt ==... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
pushq $-0x1
popq %r12
jne 0xd7289
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %r15
movq %rsi, %rdi
callq 0x34dd0
cmpl $-0x1, %eax
je 0xd7289
cmpl $-0x2, %eax... | /frida[P]libxml2/xpath.c |
xmlXPathNodeSetMergeAndClearNoDupls | static xmlNodeSetPtr
xmlXPathNodeSetMergeAndClearNoDupls(xmlNodeSetPtr set1, xmlNodeSetPtr set2)
{
{
int i;
xmlNodePtr n2;
for (i = 0;i < set2->nodeNr;i++) {
n2 = set2->nodeTab[i];
if (set1->nodeMax == 0) {
set1->nodeTab = (xmlNodePtr *) xmlMalloc(
XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r12d, %r12d
pushq $0x50
popq %r15
pushq $0xa
popq %rbp
movslq (%r14), %rax
cmpq %rax, %r12
jge 0xd8ca7
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %r13
movslq 0x4(%rbx), %rsi
testq %rsi, %rsi
je 0xd8c5f
cmpl ... | /frida[P]libxml2/xpath.c |
xmlXPathCompOpEvalPredicate | static void
xmlXPathCompOpEvalPredicate(xmlXPathParserContextPtr ctxt,
xmlXPathStepOpPtr op,
xmlNodeSetPtr set,
int minPos, int maxPos,
int hasNsNodes)
{
if (op->ch1 != -1) {
xmlXPathCompExprPtr comp = ctxt->comp;
/*
* Process inner predicates first.
*/
if (comp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movslq 0x4(%rsi), %rax
cmpq $-0x1, %rax
je 0xd8eac
movq 0x38(%rbx), %rcx
movq 0x8(%rcx), %rsi
imulq $0x38, %rax, %rax
cmpl $0xf, (%rsi,%rax)
jne ... | /frida[P]libxml2/xpath.c |
xmlXPathCompOpEvalFirst | static int
xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
xmlXPathStepOpPtr op, xmlNodePtr * first)
{
int total = 0, cur;
xmlXPathCompExprPtr comp;
xmlXPathObjectPtr arg1, arg2;
CHECK_ERROR0;
if (OP_LIMIT_EXCEEDED(ctxt, 1))
return(0);
if (ctxt->context->d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %ebp, %ebp
cmpl $0x0, 0x10(%rdi)
je 0xd91d9
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
cmpq $0x0, 0x160(%rd... | /frida[P]libxml2/xpath.c |
xmlXPathNodeSetKeepLast | static void
xmlXPathNodeSetKeepLast(xmlNodeSetPtr set)
{
int i;
xmlNodePtr node;
if ((set == NULL) || (set->nodeNr <= 1))
return;
for (i = 0; i < set->nodeNr - 1; i++) {
node = set->nodeTab[i];
if ((node != NULL) &&
(node->type == XML_NAMESPACE_DECL))
xmlXPathNo... | movl (%rdi), %eax
cmpl $0x2, %eax
jl 0xd9abf
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
leal -0x1(%rax), %ecx
movslq %ecx, %rdx
movq 0x8(%rbx), %rcx
cmpq %rdx, %r14
jge 0xd9aab
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0xd9aa6
cmpl $0x12, 0x8(%rdi)
jne 0xd9aa6
callq 0x34ce0
movl (%rbx), %eax
... | /frida[P]libxml2/xpath.c |
xmlXPtrEval | xmlXPathObjectPtr
xmlXPtrEval(const xmlChar *str, xmlXPathContextPtr ctx) {
xmlXPathParserContextPtr ctxt;
xmlXPathObjectPtr res = NULL, tmp;
xmlXPathObjectPtr init = NULL;
int stack = 0;
xmlInitParser();
if ((ctx == NULL) || (str == NULL))
return(NULL);
ctxt = xmlXPathNewParserContext(s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x32ce0
testq %r14, %r14
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0xd9b60
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32cc0
testq %rax, %rax
je 0xd9b60
movq %rax, %rbx
cmpq $0x0, 0x30(%rax)
jn... | /frida[P]libxml2/xpointer.c |
xmlXPtrEvalChildSeq | static void
xmlXPtrEvalChildSeq(xmlXPathParserContextPtr ctxt, xmlChar *name) {
/*
* XPointer don't allow by syntax to address in multirooted trees
* this might prove useful in some cases, warn about it.
*/
if ((name == NULL) && (CUR == '/') && (NXT(1) != '1')) {
xmlXPtrErr(ctxt, XML_XPTR... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0xda247
movq %rsi, %r14
movq %rsi, %rdi
callq 0x357e0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x35860
movq 0x52d8e(%rip), %rax # 0x12cfb0
movq %r14, %rdi
callq *(%rax)
pushq $0x1
popq %rsi
movq %rbx, %rdi
... | /frida[P]libxml2/xpointer.c |
_libxml2_xzread | int
__libxml2_xzread(xzFile file, void *buf, unsigned len)
{
unsigned got, n;
xz_statep state;
lzma_stream *strm;
/* get internal structure */
if (file == NULL)
return -1;
state = (xz_statep) file;
strm = &(state->strm);
/* check that we're reading and that there's no error */
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $-0x1
popq %r12
testq %rdi, %rdi
je 0xda533
movq %rdi, %rbx
cmpl $0x0, 0x64(%rdi)
je 0xda548
movl %r12d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edx, %ebp
testl %edx, ... | /frida[P]libxml2/xzlib.c |
xz_decomp | static int
xz_decomp(xz_statep state)
{
int ret;
unsigned had;
unsigned long crc, len;
lzma_stream *strm = &(state->strm);
lzma_action action = LZMA_RUN;
/* Avoid unused variable warning if features are disabled. */
(void) crc;
(void) len;
/* fill output buffer up to end of deflat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x78(%rdi), %r15
movq 0x98(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x120(%rdi), %r13
leaq 0x90(%rdi), %rax
movq %rax, 0x8(%rsp)
xorl %ebp, %ebp
pushq $0x3
popq %r12
movq 0x80(%r14), %rax
testq %rax, %rax
jne 0xdafc7
m... | /frida[P]libxml2/xzlib.c |
main | int main(int argc, char *argv[]) {
#ifdef NVTX
#ifdef PBRT_IS_WINDOWS
nvtxNameOsThread(GetCurrentThreadId(), "MAIN_THREAD");
#else
nvtxNameOsThread(syscall(SYS_gettid), "MAIN_THREAD");
#endif
#endif // NVTX
// Declare variables for parsed command line
PBRTOptions options;
std::vector<std::string> ... | subq $0x1a38, %rsp # imm = 0x1A38
movl $0x0, 0x1a34(%rsp)
movl %edi, 0x1a30(%rsp)
movq %rsi, 0x1a28(%rsp)
leaq 0x1938(%rsp), %rdi
callq 0x334080
leaq 0x1920(%rsp), %rdi
callq 0x334130
leaq 0x18ff(%rsp), %rdi
movq %rdi, 0x398(%rsp)
callq 0x3283e0
movq 0x398(%rsp), %rdx
leaq 0x51a14c(%rip), %rsi # 0x84a0db
l... | /anderslanglands[P]pbrt-v4/src/pbrt/cmd/pbrt.cpp |
pbrt::(anonymous namespace)::matchPrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool matchPrefix(const std::string &str, const std::string &prefix) {
if (prefix.size() > str.size())
return false;
for (size_t i = 0; i < prefix.size(); ++i)
if (prefix[i] != str[i])
return false;
return true;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x327650
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x327650
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jbe 0x3338db
movb $0x0, 0x37(%rsp)
jmp 0x333956
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/args.h |
pbrt::Bounds2<int>::Bounds2(pbrt::Point2<int> const&, pbrt::Point2<int> const&) | PBRT_CPU_GPU explicit Bounds2(const Bounds2<U> &b) {
if (b.IsEmpty())
// Be careful about overflowing float->int conversions and the
// like.
*this = Bounds2<T>();
else {
pMin = Point2<T>(b.pMin);
pMax = Point2<T>(b.pMax);
}
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x339850
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3398b0
movq %rax, %rcx
movq ... | /anderslanglands[P]pbrt-v4/src/pbrt/util/vecmath.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [4]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [4]) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x248, %rsp # imm = 0x248
movq %rdi, 0x240(%rsp)
movq %rsi, 0x238(%rsp)
movq %rdx, 0x230(%rsp)
movq 0x240(%rsp), %rdx
leaq 0x210(%rsp), %rdi
leaq 0x238(%rsp), %rsi
callq 0x4ccc90
leaq 0x210(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %rax
setne %al
andb $0x1,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, std::__cxx11::bas... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq 0x250(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x248, %rsp # imm = 0x248
movq %rdi, 0x240(%rsp)
movq %rsi, 0x238(%rsp)
movq %rdx, 0x230(%rsp)
movq 0x240(%rsp), %rdx
leaq 0x210(%rsp), %rdi
leaq 0x238(%rsp), %rsi
callq 0x4ccc90
leaq 0x210(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %rax
setne %al
andb $0x1,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x248, %rsp # imm = 0x248
movq %rdi, 0x240(%rsp)
movq %rsi, 0x238(%rsp)
movq %rdx, 0x230(%rsp)
movq 0x240(%rsp), %rdx
leaq 0x210(%rsp), %rdi
leaq 0x238(%rsp), %rsi
callq 0x4ccc90
leaq 0x210(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %rax
setne %al
andb $0x1,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<unsigned long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, unsigned long&&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x278, %rsp # imm = 0x278
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movq %rdx, 0x260(%rsp)
movq 0x270(%rsp), %rdx
leaq 0x240(%rsp), %rdi
leaq 0x268(%rsp), %rsi
callq 0x4ccc90
leaq 0x240(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %rax
setne %al
andb $0x1,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
pbrt::$_5::operator void (*)(pbrt::StatsAccumulator&)() const | const Transform *TransformCache::Lookup(const Transform &t) {
++nTransformCacheLookups;
if (!hashTable.empty()) {
size_t offset = t.Hash() % hashTable.bucket_count();
for (auto iter = hashTable.begin(offset); iter != hashTable.end(offset); ++iter) {
if (**iter == t) {
... | movq %rdi, -0x8(%rsp)
leaq 0x14674(%rip), %rax # 0x34f030
retq
nopl (%rax)
| /anderslanglands[P]pbrt-v4/src/pbrt/parsedscene.cpp |
pbrt::TransformCache::Lookup(pbrt::Transform const&) | const Transform *TransformCache::Lookup(const Transform &t) {
++nTransformCacheLookups;
if (!hashTable.empty()) {
size_t offset = t.Hash() % hashTable.bucket_count();
for (auto iter = hashTable.begin(offset); iter != hashTable.end(offset); ++iter) {
if (**iter == t) {
... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %fs:0x0, %rax
leaq -0x6f0(%rax), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x68, %rdi
callq 0x3514e0
testb $0x1, %al
jne 0x33aad3
movq 0x60(%rsp), %rdi
callq 0x351500
movq 0x8(%rsp), %rdi
mo... | /anderslanglands[P]pbrt-v4/src/pbrt/parsedscene.cpp |
pbrt::ParsedScene::AttributeEnd(pbrt::FileLoc) | void ParsedScene::AttributeEnd(FileLoc loc) {
VERIFY_WORLD("AttributeEnd");
if (pushedGraphicsStates.empty()) {
Error(&loc, "Unmatched AttributeEnd encountered. Ignoring it.");
return;
}
// NOTE: must keep the following consistent with code in ObjectEnd
*graphicsState = std::move(pu... | pushq %rbx
subq $0x40, %rsp
leaq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $0x2, 0x860(%rax)
jne 0x33bc14
movq 0x20(%rsp), %rdi
leaq 0x50f8ee(%rip), %rsi # 0x84b4f1
leaq 0x50fa7c(%rip), %rdx # 0x84b686
callq 0x352a50
jmp 0x33be31
jmp 0x33bc16
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/parsedscene.cpp |
pbrt::ParsedScene::LightSource(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::InlinedVector<pbrt::ParsedParameter*, 8, pstd::pmr::polymorphic_allocator<pbrt::ParsedParameter*>>, pbrt::FileLoc) | void ParsedScene::LightSource(const std::string &name, ParsedParameterVector params,
FileLoc loc) {
VERIFY_WORLD("LightSource");
ParameterDictionary dict(std::move(params), graphicsState->lightAttributes,
graphicsState->colorSpace);
AnimatedTransfor... | subq $0x8f8, %rsp # imm = 0x8F8
movq %rdx, 0x38(%rsp)
leaq 0x900(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x8f0(%rsp)
movq %rsi, 0x8e8(%rsp)
movq %rdx, 0x8e0(%rsp)
movq 0x8f0(%rsp), %rax
movq %rax, 0x48(%rsp)
cmpl $0x2, 0x860(%rax)
jne 0x33c0b4
movq 0x40(%rsp), %rdi
leaq 0x50f44e(%rip), %rsi # 0x84b4f... | /anderslanglands[P]pbrt-v4/src/pbrt/parsedscene.cpp |
pbrt::ParsedScene::ObjectInstance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::FileLoc) | void ParsedScene::ObjectInstance(const std::string &name, FileLoc loc) {
VERIFY_WORLD("ObjectInstance");
if (currentInstance != nullptr) {
ErrorExitDeferred(&loc,
"ObjectInstance can't be called inside instance definition");
return;
}
class Transform worldFrom... | subq $0x1138, %rsp # imm = 0x1138
leaq 0x1140(%rsp), %rax
movq %rax, 0x110(%rsp)
movq %rdi, 0x1130(%rsp)
movq %rsi, 0x1128(%rsp)
movq 0x1130(%rsp), %rax
movq %rax, 0x118(%rsp)
cmpl $0x2, 0x860(%rax)
jne 0x33d0e0
movq 0x110(%rsp), %rdi
leaq 0x50e422(%rip), %rsi # 0x84b4f1
leaq 0x50e868(%rip), %rdx # 0x84... | /anderslanglands[P]pbrt-v4/src/pbrt/parsedscene.cpp |
pbrt::ParsedScene::Option(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::FileLoc) | void ParsedScene::Option(const std::string &name, const std::string &value, FileLoc loc) {
std::string nName = normalizeArg(name);
VERIFY_INITIALIZED("Option");
if (nName == "disablepixeljitter") {
if (value == "true")
Options->disablePixelJitter = true;
else if (value == "false... | subq $0xc8, %rsp
leaq 0xd0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0xb8(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x33de00
movq 0x38(%rsp), %rax
cmpl $0x2, 0x860(%rax)
jne 0x33d8bc
movq 0x30(%rsp), %rdi
leaq 0x50d... | /anderslanglands[P]pbrt-v4/src/pbrt/parsedscene.cpp |
pbrt::ParsedScene::TransformEnd(pbrt::FileLoc) | void ParsedScene::TransformEnd(FileLoc loc) {
VERIFY_WORLD("TransformEnd");
if (pushedTransforms.empty()) {
Error(&loc, "Unmatched TransformEnd encountered. Ignoring it.");
return;
}
curTransform = pushedTransforms.back();
pushedTransforms.pop_back();
activeTransformBits = pushed... | pushq %rbx
subq $0x40, %rsp
leaq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $0x2, 0x860(%rax)
jne 0x33fdf4
movq 0x20(%rsp), %rdi
leaq 0x50b70e(%rip), %rsi # 0x84b4f1
leaq 0x50be61(%rip), %rdx # 0x84bc4b
callq 0x352a50
jmp 0x33ffdb
jmp 0x33fdf6
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/parsedscene.cpp |
pbrt::ParsedScene::MakeNamedMaterial(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::InlinedVector<pbrt::ParsedParameter*, 8, pstd::pmr::polymorphic_allocator<pbrt::ParsedParameter*>>, pbrt::FileLoc) | void ParsedScene::MakeNamedMaterial(const std::string &name, ParsedParameterVector params,
FileLoc loc) {
VERIFY_WORLD("MakeNamedMaterial");
ParameterDictionary dict(std::move(params), graphicsState->materialAttributes,
graphicsState->colorSpace)... | subq $0x378, %rsp # imm = 0x378
movq %rdx, 0x38(%rsp)
leaq 0x380(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x370(%rsp)
movq %rsi, 0x368(%rsp)
movq %rdx, 0x360(%rsp)
movq 0x370(%rsp), %rax
movq %rax, 0x48(%rsp)
cmpl $0x2, 0x860(%rax)
jne 0x340794
movq 0x40(%rsp), %rdi
leaq 0x50ad6e(%rip), %rsi # 0x84b4f... | /anderslanglands[P]pbrt-v4/src/pbrt/parsedscene.cpp |
pbrt::FormattingScene::Option(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::FileLoc) | void FormattingScene::Option(const std::string &name, const std::string &value,
FileLoc loc) {
std::string nName = normalizeArg(name);
if (nName == "msereferenceimage" || nName == "msereferenceout")
Printf("%sOption \"%s\" \"%s\"\n", indent(), name, value);
else
... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x98(%rsp), %rsi
leaq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x33de00
movq 0x10(%rsp), %rdi
leaq 0x50922f(%rip), %rsi # 0x84ba6e
callq 0x335dd0
movb %al, 0x1f(%rsp)
jmp 0x34284a
mo... | /anderslanglands[P]pbrt-v4/src/pbrt/parsedscene.cpp |
pbrt::FormattingScene::ConcatTransform(float*, pbrt::FileLoc) | void FormattingScene::ConcatTransform(Float transform[16], FileLoc loc) {
Printf("%sConcatTransform [ ", indent());
for (int i = 0; i < 16; ++i)
Printf("%f ", transform[i]);
Printf(" ]\n");
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
xorl %edx, %edx
callq 0x356400
movq (%rsp), %rsi
leaq 0x50927f(%rip), %rdi # 0x84bffd
callq 0x3564a0
jmp 0x342d85
leaq 0x18(%rsp), %rdi
callq 0x328990
movl $0x0, 0x8(%rsp)
cmpl $0x10, 0x8(%rsp)
... | /anderslanglands[P]pbrt-v4/src/pbrt/parsedscene.cpp |
pbrt::FormattingScene::PixelFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::InlinedVector<pbrt::ParsedParameter*, 8, pstd::pmr::polymorphic_allocator<pbrt::ParsedParameter*>>, pbrt::FileLoc) | void FormattingScene::PixelFilter(const std::string &name, ParsedParameterVector params,
FileLoc loc) {
ParameterDictionary dict(std::move(params), RGBColorSpace::sRGB);
std::string extra;
if (upgrade) {
std::vector<Float> xr = dict.GetFloatArray("xwidth");
... | subq $0x3b8, %rsp # imm = 0x3B8
movq %rdx, 0x50(%rsp)
movq %rsi, %rax
movq 0x50(%rsp), %rsi
movq %rdi, 0x3b0(%rsp)
movq %rax, 0x3a8(%rsp)
movq %rsi, 0x3a0(%rsp)
movq 0x3b0(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x2d8(%rsp), %rdi
movq %rdi, 0x60(%rsp)
callq 0x3530f0
movq 0x60(%rsp), %rsi
leaq 0x3110029(%rip),... | /anderslanglands[P]pbrt-v4/src/pbrt/parsedscene.cpp |
pbrt::FormattingScene::Integrator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::InlinedVector<pbrt::ParsedParameter*, 8, pstd::pmr::polymorphic_allocator<pbrt::ParsedParameter*>>, pbrt::FileLoc) | void FormattingScene::Integrator(const std::string &name, ParsedParameterVector params,
FileLoc loc) {
ParameterDictionary dict(std::move(params), RGBColorSpace::sRGB);
std::string extra;
if (upgrade) {
if (name == "sppm") {
dict.RemoveInt("imagewritefre... | subq $0x3e8, %rsp # imm = 0x3E8
movq %rdx, 0x58(%rsp)
movq %rsi, %rax
movq 0x58(%rsp), %rsi
movq %rdi, 0x3e0(%rsp)
movq %rax, 0x3d8(%rsp)
movq %rsi, 0x3d0(%rsp)
movq 0x3e0(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x308(%rsp), %rdi
movq %rdi, 0x68(%rsp)
callq 0x3530f0
movq 0x68(%rsp), %rsi
leaq 0x310ea79(%rip),... | /anderslanglands[P]pbrt-v4/src/pbrt/parsedscene.cpp |
pbrt::FormattingScene::MakeNamedMedium(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::InlinedVector<pbrt::ParsedParameter*, 8, pstd::pmr::polymorphic_allocator<pbrt::ParsedParameter*>>, pbrt::FileLoc) | void FormattingScene::MakeNamedMedium(const std::string &name,
ParsedParameterVector params, FileLoc loc) {
ParameterDictionary dict(params, RGBColorSpace::sRGB);
if (upgrade && name == "heterogeneous")
Printf("%sMakeNamedMedium \"%s\"\n%s\n", indent(), "uniformgrid... | subq $0x1a8, %rsp # imm = 0x1A8
movq %rdx, 0x18(%rsp)
movq %rdi, 0x1a0(%rsp)
movq %rsi, 0x198(%rsp)
movq %rdx, 0x190(%rsp)
movq 0x1a0(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xc0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x351420
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0xc8(%rsp), %rdi
movq %rdi, 0x28(... | /anderslanglands[P]pbrt-v4/src/pbrt/parsedscene.cpp |
pbrt::FormattingScene::upgradeMaterialIndex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::ParameterDictionary*, pbrt::FileLoc) const | std::string FormattingScene::upgradeMaterialIndex(const std::string &name,
ParameterDictionary *dict,
FileLoc loc) const {
if (name != "glass" && name != "uber")
return "";
std::string tex = dict->GetTex... | subq $0x2d8, %rsp # imm = 0x2D8
movq %rdi, 0xa0(%rsp)
movq %rdi, %rax
movq %rax, 0xa8(%rsp)
leaq 0x2e0(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq %rdi, 0x2d0(%rsp)
movq %rsi, 0x2c8(%rsp)
movq %rdx, 0x2c0(%rsp)
movq %rcx, 0x2b8(%rsp)
movq 0x2c8(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x2c0(%rsp), %rdi
leaq 0x5058a... | /anderslanglands[P]pbrt-v4/src/pbrt/parsedscene.cpp |
pbrt::FormattingScene::ObjectBegin(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::FileLoc) | void FormattingScene::ObjectBegin(const std::string &name, FileLoc loc) {
if (upgrade) {
if (definedObjectInstances.find(name) != definedObjectInstances.end()) {
static int count = 0;
Warning(&loc, "%s: renaming multiply-defined object instance", name);
definedObjectInsta... | subq $0xc8, %rsp
leaq 0xd0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x28(%rsp)
testb $0x1, 0x11(%rax)
je 0x34ebfa
movq 0x28(%rsp), %rdi
addq $0xa8, %rdi
movq 0xb8(%rsp), %rsi
callq 0x356fe0
movq 0x28(%rsp), %rdi
movq %rax, 0xb0(%rsp)
addq $0xa8, %rdi... | /anderslanglands[P]pbrt-v4/src/pbrt/parsedscene.cpp |
pbrt::TextureSceneEntity::TextureSceneEntity(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::ParameterDictionary, pbrt::FileLoc, pbrt::AnimatedTransform const&) | TextureSceneEntity(const std::string &texName, ParameterDictionary parameters,
FileLoc loc, const AnimatedTransform &renderFromObject)
: TransformedSceneEntity("", std::move(parameters), loc, renderFromObject),
texName(texName) {} | subq $0x118, %rsp # imm = 0x118
movq %rdx, 0x20(%rsp)
leaq 0x120(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
movq %rcx, 0xf8(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0xd7(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x3283e0
movq 0x38(%rsp)... | /anderslanglands[P]pbrt-v4/src/pbrt/parsedscene.h |
void pbrt::Log<unsigned long, unsigned long, unsigned long, unsigned long>(pbrt::LogLevel, char const*, int, char const*, unsigned long&&, unsigned long&&, unsigned long&&, unsigned long&&) | inline void Log(LogLevel level, const char *file, int line, const char *fmt,
Args &&... args) {
#ifdef PBRT_IS_GPU_CODE
Log(level, file, line, fmt); // just the format string #yolo
#else
std::string s = StringPrintf(fmt, std::forward<Args>(args)...);
Log(level, file, line, s.c_str());
#endi... | subq $0x78, %rsp
movq 0x88(%rsp), %rax
movq 0x80(%rsp), %rax
movl %edi, 0x74(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x48(%rsp)
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x80(%rsp), %r8
movq 0x88(%rsp), %r9
leaq 0x28(%rsp), %rdi... | /anderslanglands[P]pbrt-v4/src/pbrt/util/log.h |
pstd::pmr::monotonic_buffer_resource::monotonic_buffer_resource(pstd::pmr::memory_resource*) | explicit monotonic_buffer_resource(memory_resource *upstream)
: upstreamResource(upstream) {} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x3599d0
movq (%rsp), %rdi
leaq 0x30b2b19(%rip), %rax # 0x340c470
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rdi)
movq $0x40000, 0x10(%rdi) # imm = 0x40000
addq $0x18, %rdi
callq 0... | /anderslanglands[P]pbrt-v4/src/pbrt/util/pstd.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [2], int&, char const (&) [2], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [2], int&, char const (&) [2], int&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
m... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [2], char const (&) [14], char const (&) [2], int&, char const (&) [14], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [2], char const (&) [14], char const (&) [2], int&, char const (&) [14], int... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq 0x278(%rsp), %rax
movq 0x270(%rsp), %rax
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [14], char const (&) [2], int&, char const (&) [14], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [14], char const (&) [2], int&, char const (&) [14], int&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq 0x270(%rsp), %rax
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
pbrt::SquareMatrix<4> pbrt::Transpose<4>(pbrt::SquareMatrix<4> const&) | PBRT_CPU_GPU inline SquareMatrix<N> Transpose(const SquareMatrix<N> &m) {
SquareMatrix<N> r;
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j)
r[i][j] = m[j][i];
return r;
} | subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x40(%rsp)
callq 0x49b6f0
movl $0x0, 0x3c(%rsp)
cmpl $0x4, 0x3c(%rsp)
jge 0x35e53e
movl $0x0, 0x38(%rsp)
cmpl $0x4, 0x38(%rsp)
jge 0x35e52c
movq 0x40(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0x49bfe0
movq %rax, 0x28(%rsp)
movq %rdx, 0... | /anderslanglands[P]pbrt-v4/src/pbrt/util/math.h |
void pbrt::detail::stringPrintfRecursive<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::ParameterDictionary const&, pbrt::FileLoc const&, pbrt::CameraTransform const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq 0x270(%rsp), %rax
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<std::vector<pbrt::SceneEntity, std::allocator<pbrt::SceneEntity>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, pbrt::TransformedSceneEntity, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | pushq %rbx
subq $0x280, %rsp # imm = 0x280
movq 0x2a8(%rsp), %rax
movq 0x2a0(%rsp), %rax
movq 0x298(%rsp), %rax
movq 0x290(%rsp), %rax
movq %rdi, 0x278(%rsp)
movq %rsi, 0x270(%rsp)
movq %rdx, 0x268(%rsp)
movq %rcx, 0x260(%rsp)
movq %r8, 0x258(%rsp)
movq %r9, 0x250(%rsp)
movq 0x278(%rsp), %rdx
leaq 0x230(%rsp... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::TransformedSceneEntity const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std:... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq 0x250(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<pbrt::FileLoc const&, pbrt::Transform const&, pbrt::Transform const&, bool const&, int const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | pushq %r14
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq 0x2c0(%rsp), %rax
movq 0x2b8(%rsp), %rax
movq 0x2b0(%rsp), %rax
movq 0x2a8(%rsp), %rax
movq 0x2a0(%rsp), %rax
movq %rdi, 0x280(%rsp)
movq %rsi, 0x278(%rsp)
movq %rdx, 0x270(%rsp)
movq %rcx, 0x268(%rsp)
movq %r8, 0x260(%rsp)
movq %r9, 0x258(%rsp)
movq... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::ParameterDictionary const&, pbrt::FileLoc const&, pbrt::AnimatedTransform const&, bool const&, int const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> ... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | pushq %r14
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq 0x2c0(%rsp), %rax
movq 0x2b8(%rsp), %rax
movq 0x2b0(%rsp), %rax
movq 0x2a8(%rsp), %rax
movq 0x2a0(%rsp), %rax
movq %rdi, 0x280(%rsp)
movq %rsi, 0x278(%rsp)
movq %rdx, 0x270(%rsp)
movq %rcx, 0x268(%rsp)
movq %r8, 0x260(%rsp)
movq %r9, 0x258(%rsp)
movq... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<pbrt::FileLoc const&, pbrt::AnimatedTransform const&, bool const&, int const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x278, %rsp # imm = 0x278
movq 0x290(%rsp), %rax
movq 0x288(%rsp), %rax
movq 0x280(%rsp), %rax
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movq %rdx, 0x260(%rsp)
movq %rcx, 0x258(%rsp)
movq %r8, 0x250(%rsp)
movq %r9, 0x248(%rsp)
movq 0x270(%rsp), %rdx
leaq 0x228(%rsp), %rdi
leaq 0x268(%rsp), %rsi
cal... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<std::vector<pbrt::ShapeSceneEntity, std::allocator<pbrt::ShapeSceneEntity>> const&, std::vector<pbrt::InstanceSceneEntity, std::allocator<pbrt::InstanceSceneEntity>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, std::vector... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq 0x250(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<pbrt::AnimatedTransform const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::AnimatedTransform const&, std::__cxx11::basic_string<char, std::cha... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq 0x250(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [15]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [15]) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x248, %rsp # imm = 0x248
movq %rdi, 0x240(%rsp)
movq %rsi, 0x238(%rsp)
movq %rdx, 0x230(%rsp)
movq 0x240(%rsp), %rdx
leaq 0x210(%rsp), %rdi
leaq 0x238(%rsp), %rsi
callq 0x4ccc90
leaq 0x210(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %rax
setne %al
andb $0x1,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [23], char&, char const (&) [4], char&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [23], char&, char const (&) [4], char&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
m... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [4], char&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [4], char&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq 0x250(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<unsigned long, unsigned long, unsigned long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, unsigned long&&, unsigned long&&, unsigned long&&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x288, %rsp # imm = 0x288
movq %rdi, 0x280(%rsp)
movq %rsi, 0x278(%rsp)
movq %rdx, 0x270(%rsp)
movq %rcx, 0x268(%rsp)
movq %r8, 0x260(%rsp)
movq 0x280(%rsp), %rdx
leaq 0x240(%rsp), %rdi
leaq 0x278(%rsp), %rsi
callq 0x4ccc90
leaq 0x240(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<float&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, float&, float&, float&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, float&, float&, float&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::a... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | pushq %r14
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq 0x2e0(%rsp), %rax
movq 0x2d8(%rsp), %rax
movq 0x2d0(%rsp), %rax
movq 0x2c8(%rsp), %rax
movq 0x2c0(%rsp), %rax
movq %rdi, 0x2a0(%rsp)
movq %rsi, 0x298(%rsp)
movq %rdx, 0x290(%rsp)
movq %rcx, 0x288(%rsp)
movq %r8, 0x280(%rsp)
movq %r9, 0x278(%rsp)
movq... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<float&, float&, float&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, float&, float&, float&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, float&, float&, float&, std::__cxx11::basic_string<char, ... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x298, %rsp # imm = 0x298
movq 0x2b0(%rsp), %rax
movq 0x2a8(%rsp), %rax
movq 0x2a0(%rsp), %rax
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
movq %rdx, 0x280(%rsp)
movq %rcx, 0x278(%rsp)
movq %r8, 0x270(%rsp)
movq %r9, 0x268(%rsp)
movq 0x290(%rsp), %rdx
leaq 0x248(%rsp), %rdi
leaq 0x288(%rsp), %rsi
cal... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, float>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, float&&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq 0x250(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, std::__cxx11::basi... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq 0x250(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq 0x250(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_stri... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq %r8, 0x230(%rsp)
movq 0x250(%rsp), %rdx
leaq 0x210(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x4ccc90
leaq 0x210(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_strin... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
m... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char cons... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq 0x250(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
pstd::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, pstd::pmr::polymorphic_allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::reserve(unsigned long) | void reserve(size_t n) {
if (nAlloc >= n)
return;
T *ra = alloc.template allocate_object<T>(n);
for (int i = 0; i < nStored; ++i) {
alloc.template construct<T>(ra + i, std::move(begin()[i]));
alloc.destroy(begin() + i);
}
alloc.deallocate_obj... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rax), %rax
cmpq 0x28(%rsp), %rax
jb 0x3aace8
jmp 0x3aadab
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3aade0
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movslq 0x1c(%rsp), %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/pstd.h |
pstd::vector<unsigned char, pstd::pmr::polymorphic_allocator<unsigned char>>::reserve(unsigned long) | void reserve(size_t n) {
if (nAlloc >= n)
return;
T *ra = alloc.template allocate_object<T>(n);
for (int i = 0; i < nStored; ++i) {
alloc.template construct<T>(ra + i, std::move(begin()[i]));
alloc.destroy(begin() + i);
}
alloc.deallocate_obj... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rax), %rax
cmpq 0x28(%rsp), %rax
jb 0x3ab358
jmp 0x3ab40f
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3ab440
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movslq 0x1c(%rsp), %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/pstd.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [2], char const*&, char const (&) [4], char const*&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [2], char const*&, char const (&) [4], char const*&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
m... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
pbrt::Disk::ToString[abi:cxx11]() const | std::string Disk::ToString() const {
return StringPrintf(
"[ Disk renderFromObject: %s objectFromRender: %s "
"reverseOrientation: %s "
"transformSwapsHandedness: %s height: %f radius: %f innerRadius: %f "
"phiMax: %f ]",
*renderFromObject, *objectFromRender, reverseOrientati... | pushq %rbx
subq $0x40, %rsp
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %rax, %r8
addq $0x10, %r8
movq %rax, %r9
addq $0x11, %r9
movq %rax, %rbx
addq $0x14, %rbx
movq %rax, %r11
addq $0x18, %r11
movq %rax, %r10
addq ... | /anderslanglands[P]pbrt-v4/src/pbrt/shapes.cpp |
pbrt::Triangle::CreateTriangles(pbrt::TriangleMesh const*, pstd::pmr::polymorphic_allocator<std::byte>) | pstd::vector<ShapeHandle> Triangle::CreateTriangles(const TriangleMesh *mesh,
Allocator alloc) {
CHECK_LT(allMeshes->size(), 1 << 31);
int meshIndex = int(allMeshes->size());
allMeshes->push_back(mesh);
pstd::vector<ShapeHandle> tris(mesh->nTriangles,... | pushq %rbx
subq $0xb0, %rsp
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0x30a26cc(%rip), %rdi # 0x3452fa0
callq 0x3c2280
movq %rax, 0x90(%rsp)
movl $0x80000000, 0x8c(%rsp) # imm = 0x80000000
movq 0x90(%rsp), %rax
movslq 0x8c(%rsp),... | /anderslanglands[P]pbrt-v4/src/pbrt/shapes.cpp |
pbrt::$_8::operator void (*)(pbrt::StatsAccumulator&)() const | std::string ToString(CurveType type) {
switch (type) {
case CurveType::Flat:
return "Flat";
case CurveType::Cylinder:
return "Cylinder";
case CurveType::Ribbon:
return "Ribbon";
default:
LOG_FATAL("Unhandled case");
return "";
}
} | movq %rdi, -0x8(%rsp)
leaq 0xc174(%rip), %rax # 0x3be2b0
retq
nopl (%rax)
| /anderslanglands[P]pbrt-v4/src/pbrt/shapes.cpp |
pbrt::Curve::Area() const | Float Curve::Area() const {
pstd::array<Point3f, 4> cpObj =
CubicBezierControlPoints(pstd::MakeConstSpan(common->cpObj), uMin, uMax);
Float width0 = Lerp(uMin, common->width[0], common->width[1]);
Float width1 = Lerp(uMax, common->width[0], common->width[1]);
Float avgWidth = (width0 + width1) *... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%rax), %rdi
addq $0x4, %rdi
callq 0x3c5b20
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
vmovss 0x8(%rax), %xmm0
vmovss 0xc(%rax), %xmm1
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0x40(%rsp... | /anderslanglands[P]pbrt-v4/src/pbrt/shapes.cpp |
pbrt::Curve::RecursiveIntersect(pbrt::Ray const&, float, pstd::span<pbrt::Point3<float> const>, pbrt::Transform const&, float, float, int, pstd::optional<pbrt::ShapeIntersection>*) const | bool Curve::RecursiveIntersect(const Ray &ray, Float tMax, pstd::span<const Point3f> cp,
const Transform &ObjectFromRay, Float u0, Float u1,
int depth, pstd::optional<ShapeIntersection> *si) const {
Float rayLength = Length(ray.d);
if (depth > 0) {
... | pushq %rbx
subq $0x8d0, %rsp # imm = 0x8D0
movq 0x8e0(%rsp), %rax
movq %rdx, 0x8b8(%rsp)
movq %rcx, 0x8c0(%rsp)
movq %rdi, 0x8b0(%rsp)
movq %rsi, 0x8a8(%rsp)
vmovss %xmm0, 0x8a4(%rsp)
movq %r8, 0x898(%rsp)
vmovss %xmm1, 0x894(%rsp)
vmovss %xmm2, 0x890(%rsp)
movl %r9d, 0x88c(%rsp)
movq 0x8b0(%rsp), %rax
movq ... | /anderslanglands[P]pbrt-v4/src/pbrt/shapes.cpp |
pbrt::$_12::operator void (*)(pbrt::StatsAccumulator&)() const | BilinearPatch::BilinearPatch(int meshIndex, int blpIndex)
: meshIndex(meshIndex), blpIndex(blpIndex) {
blpBytes += sizeof(*this);
// Store area of bilinear patch in _area_
// Get bilinear patch vertices in _p00_, _p01_, _p10_, and _p11_
const BilinearPatchMesh *mesh = GetMesh();
const int *v = &... | movq %rdi, -0x8(%rsp)
leaq 0x73a4(%rip), %rax # 0x3be590
retq
nopl (%rax)
| /anderslanglands[P]pbrt-v4/src/pbrt/shapes.cpp |
pbrt::BilinearPatch::Bounds() const | Bounds3f BilinearPatch::Bounds() const {
// Get bilinear patch vertices in _p00_, _p01_, _p10_, and _p11_
const BilinearPatchMesh *mesh = GetMesh();
const int *v = &mesh->vertexIndices[4 * blpIndex];
const Point3f &p00 = mesh->p[v[0]], &p10 = mesh->p[v[1]];
const Point3f &p01 = mesh->p[v[2]], &p11 =... | subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3c9740
movq 0x8(%rsp), %rcx
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rcx), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq ... | /anderslanglands[P]pbrt-v4/src/pbrt/shapes.cpp |
pbrt::$_9::operator()(pbrt::StatsAccumulator&) const | std::string ToString(CurveType type) {
switch (type) {
case CurveType::Flat:
return "Flat";
case CurveType::Cylinder:
return "Cylinder";
case CurveType::Ribbon:
return "Ribbon";
default:
LOG_FATAL("Unhandled case");
return "";
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %fs:0x0, %rax
leaq -0x660(%rax), %rax
movq (%rax), %rdx
leaq 0x490e78(%rip), %rsi # 0x84f1e5
callq 0x4f0b60
movq %fs:0x0, %rax
leaq -0x660(%rax), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
nop
| /anderslanglands[P]pbrt-v4/src/pbrt/shapes.cpp |
pbrt::$_12::operator()(pbrt::StatsAccumulator&) const | BilinearPatch::BilinearPatch(int meshIndex, int blpIndex)
: meshIndex(meshIndex), blpIndex(blpIndex) {
blpBytes += sizeof(*this);
// Store area of bilinear patch in _area_
// Get bilinear patch vertices in _p00_, _p01_, _p10_, and _p11_
const BilinearPatchMesh *mesh = GetMesh();
const int *v = &... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %fs:0x0, %rax
leaq -0x640(%rax), %rax
movq (%rax), %rdx
leaq 0x490c52(%rip), %rsi # 0x84f22f
callq 0x4f0cb0
movq %fs:0x0, %rax
leaq -0x640(%rax), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
nop
| /anderslanglands[P]pbrt-v4/src/pbrt/shapes.cpp |
pbrt::Log2Int(float) | PBRT_CPU_GPU
inline int Log2Int(float v) {
DCHECK_GT(v, 0);
if (v < 1)
return -Log2Int(1 / v);
// https://graphics.stanford.edu/~seander/bithacks.html#IntegerLog
// (With an additional check of the significant to get round-to-nearest
// rather than round down.)
// midsignif = Significand... | subq $0x18, %rsp
vmovss %xmm0, 0x10(%rsp)
vmovss 0x484982(%rip), %xmm0 # 0x84b154
vucomiss 0x10(%rsp), %xmm0
jbe 0x3c67f9
vmovss 0x484972(%rip), %xmm0 # 0x84b154
vdivss 0x10(%rsp), %xmm0, %xmm0
callq 0x3c67c0
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, 0x14(%rsp)
jmp 0x3c6837
movl $0x3504f3, 0xc(%rsp... | /anderslanglands[P]pbrt-v4/src/pbrt/util/math.h |
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.