name string | code string | asm string | file string |
|---|---|---|---|
Catch::TestCaseTracking::operator==(Catch::TestCaseTracking::NameAndLocation const&, Catch::TestCaseTracking::NameAndLocationRef const&) | bool operator==( NameAndLocation const& lhs,
NameAndLocationRef const& rhs ) {
// This is a very cheap check that should have a very high hit rate.
// If we get to SourceLineInfo::operator==, we will redo it, but the
// cost of repeating is trivial at ... | movq 0x28(%rdi), %rax
cmpq 0x18(%rsi), %rax
jne 0x57dca
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rdi)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
callq 0x517ce
testb %al, %al
je 0x57dcd
addq $0x20, %r1... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Clara::Detail::ParserRefImpl<Catch::Clara::Opt>::ParserRefImpl<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, Catch::StringRef) | ParserRefImpl( T& ref, StringRef hint ):
m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
m_hint( hint ) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x49d11(%rip), %rax # 0xa74f0
movq %rax, (%rdi)
andl $0x0, 0x8(%rdi)
movq %rsp, %rdi
callq 0x51853
leaq 0x8(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, 0x10(%r15)
andq $0x0, -0x8(%rdi)
cal... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Clara::Detail::BasicResult<Catch::Clara::ParseResultType>::BasicResult(Catch::Clara::Detail::BasicResult<Catch::Clara::ParseResultType> const&) | explicit BasicResult( BasicResult<U> const& other ):
ResultValueBase<T>( other.type() ),
m_errorMessage( other.errorMessage() ) {
assert( type() != ResultType::Ok );
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
leaq 0x49d78(%rip), %r14 # 0xa75b8
movq %r14, (%rdi)
testl %eax, %eax
jne 0x5d84d
movl 0xc(%rsi), %eax
movl %eax, 0xc(%rbx)
leaq 0x49d0c(%rip), %rax # 0xa7560
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
addq $0x10, %rsi
callq... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Clara::Detail::BasicResult<Catch::Clara::ParseResultType> Catch::Clara::Detail::convertInto<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&) | ParserResult convertInto( std::string const& source, T& target ) {
std::stringstream ss( source );
ss >> target;
if ( ss.fail() ) {
return ParserResult::runtimeError(
"Unable to convert '" + source +
"' t... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %r12
pushq $0x18
popq %rdx
movq %r12, %rdi
callq 0x15980
movq %r12, %rdi
movq %r15, %rsi
callq 0x153d0
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x60(%rs... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Clara::Detail::ParserRefImpl<Catch::Clara::Opt>::ParserRefImpl<double, void>(double&, Catch::StringRef) | ParserRefImpl( T& ref, StringRef hint ):
m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
m_hint( hint ) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x49b67(%rip), %rax # 0xa74f0
movq %rax, (%rdi)
andl $0x0, 0x8(%rdi)
movq %rsp, %rdi
callq 0x5d9d6
leaq 0x8(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, 0x10(%r15)
andq $0x0, -0x8(%rdi)
cal... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Clara::Detail::BasicResult<Catch::Clara::ParseResultType> Catch::Clara::Detail::convertInto<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double&) | ParserResult convertInto( std::string const& source, T& target ) {
std::stringstream ss( source );
ss >> target;
if ( ss.fail() ) {
return ParserResult::runtimeError(
"Unable to convert '" + source +
"' t... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %r12
pushq $0x18
popq %rdx
movq %r12, %rdi
callq 0x15980
movq %r12, %rdi
movq %r15, %rsi
callq 0x15420
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x60(%rs... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Clara::Detail::BasicResult<Catch::Clara::ParseResultType> Catch::Clara::Detail::convertInto<unsigned int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int&) | ParserResult convertInto( std::string const& source, T& target ) {
std::stringstream ss( source );
ss >> target;
if ( ss.fail() ) {
return ParserResult::runtimeError(
"Unable to convert '" + source +
"' t... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %r12
pushq $0x18
popq %rdx
movq %r12, %rdi
callq 0x15980
movq %r12, %rdi
movq %r15, %rsi
callq 0x15a90
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x60(%rs... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Clara::Detail::ParserRefImpl<Catch::Clara::Opt>::ParserRefImpl<long, void>(long&, Catch::StringRef) | ParserRefImpl( T& ref, StringRef hint ):
m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
m_hint( hint ) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x4937b(%rip), %rax # 0xa74f0
movq %rax, (%rdi)
andl $0x0, 0x8(%rdi)
movq %rsp, %rdi
callq 0x5e1c2
leaq 0x8(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, 0x10(%r15)
andq $0x0, -0x8(%rdi)
cal... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::Clara::Detail::BasicResult<Catch::Clara::ParseResultType> Catch::Clara::Detail::convertInto<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long&) | ParserResult convertInto( std::string const& source, T& target ) {
std::stringstream ss( source );
ss >> target;
if ( ss.fail() ) {
return ParserResult::runtimeError(
"Unable to convert '" + source +
"' t... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %r12
pushq $0x18
popq %rdx
movq %r12, %rdi
callq 0x15980
movq %r12, %rdi
movq %r15, %rsi
callq 0x15680
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x60(%rs... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
unsigned long Catch::ulpDistance<double>(double, double) | uint64_t ulpDistance( FP lhs, FP rhs ) {
assert( std::numeric_limits<FP>::is_iec559 &&
"ulpDistance assumes IEEE-754 format for floating point types" );
assert( !Catch::isnan( lhs ) &&
"Distance between NaN and number is not meaningful" );
assert( !Catch::isnan( rhs )... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movapd %xmm1, %xmm3
xorl %ebx, %ebx
xorl %r14d, %r14d
ucomisd %xmm3, %xmm0
jne 0x62b3b
jnp 0x62bd7
movapd %xmm0, %xmm1
xorpd %xmm4, %xmm4
cmpeqsd %xmm4, %xmm1
andnpd %xmm0, %xmm1
movapd %xmm3, %xmm2
cmpeqsd %xmm4, %xmm2
andnpd %xmm3, %xmm2
movq %xmm1, %rax
movq %xmm2, %rcx
movq %r... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Catch::MatchExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Catch::Matchers::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&>::streamReconstructedExpression(std::ostream&) const | void streamReconstructedExpression( std::ostream& os ) const override {
os << Catch::Detail::stringify( m_arg )
<< ' '
<< m_matcher.toString();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x37a3e
movq %r14, %rdi
movq %r15, %rsi
callq 0x155a0
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x15770
movq %rax, %r14
movq 0x18(%rbx), %rsi
movq %rsp, %rdi
callq 0x4195... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
void Catch::JsonValueWriter::writeImpl<Catch::Version, void>(Catch::Version const&, bool) | void writeImpl( T const& value, bool quote_value ) {
m_sstream << value;
writeImpl( m_sstream.str(), quote_value );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movq %rdi, %r14
addq $0x18, %rdi
callq 0x354fd
leaq 0x20(%r14), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x15970
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
movl %ebx, %ecx
callq 0x3b602
movq %rsp, %rdi
callq 0x15c18
addq $0x20, %rsp
popq %r... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.hpp |
Datetime::parse_second(Pig&, int&) | bool Datetime::parse_second (Pig& pig, int& value)
{
auto checkpoint = pig.cursor ();
int second;
if (pig.getDigit2 (second) &&
second >= 0 &&
second < 60)
{
value = second;
return true;
}
pig.restoreTo (checkpoint);
return false;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x13348
movq %rax, %r15
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x129e2
movl (%r12), %ecx
cmpl $0x3c, %ecx
setb %bpl
andb %al, %bpl
cmpb $0x1, %bpl
jne 0xe6b8
movl %ecx, (%r14... | /GothenburgBitFactory[P]timewarrior/src/libshared/src/Datetime.cpp |
upperCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string upperCase (const std::string& input)
{
std::string output {input};
std::transform (output.begin (), output.end (), output.begin (), toupper);
return output;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x7630
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x15719
movq (%rbx), %r15
xorl %r12d, %r12d
movsbl (%r15,%r12), %edi
callq 0x35d0
mo... | /GothenburgBitFactory[P]timewarrior/src/libshared/src/shared.cpp |
lua_tonumberx | LUA_API lua_Number lua_tonumberx (lua_State *L, int idx, int *pisnum) {
lua_Number n = 0;
const TValue *o = index2value(L, idx);
int isnum = tonumber(o, &n);
if (pisnum)
*pisnum = isnum;
return n;
} | pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
andq $0x0, 0x8(%rsp)
callq 0x811d
cmpb $0x13, 0x8(%rax)
jne 0x83ff
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
pushq $0x1
popq %rax
jmp 0x840c
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x22568
testq %rbx, %rbx
je 0x8413
movl %eax, (%rbx)
movsd 0x8(%rsp), %xmm0
addq $0x10, %rs... | /NLua[P]lua/src/lapi.c |
lua_pushvfstring | LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt,
va_list argp) {
const char *ret;
lua_lock(L);
ret = luaO_pushvfstring(L, fmt, argp);
luaC_checkGC(L);
lua_unlock(L);
return ret;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1835d
movq %rax, %r14
movq 0x18(%rbx), %rax
cmpq $0x0, 0x18(%rax)
jle 0x86fa
movq %rbx, %rdi
callq 0x12a71
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /NLua[P]lua/src/lapi.c |
basicgetobjname | static const char *basicgetobjname (const Proto *p, int *ppc, int reg,
const char **name) {
int pc = *ppc;
*name = luaF_getlocalname(p, reg + 1, pc);
if (*name) /* is a local? */
return "local";
/* else try symbolic execution */
*ppc = pc = findsetreg(p, pc, reg);
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movl %edx, %r13d
movq %rsi, %r12
movq %rdi, %r15
movl (%rsi), %ebp
leaq 0x185e1(%rip), %r14 # 0x28b60
pushq $-0x1
popq %rbx
movq $0x0, 0x8(%rsp)
leal 0x1(%r13), %esi
movq %r15, %rdi
movl %ebp, %edx
callq 0x12393... | /NLua[P]lua/src/ldebug.c |
luaD_reallocstack | int luaD_reallocstack (lua_State *L, int newsize, int raiseerror) {
int oldsize = stacksize(L);
int i;
StkId newstack;
int oldgcstop = G(L)->gcstopem;
lua_assert(newsize <= LUAI_MAXSTACK || newsize == ERRORSTACKSIZE);
relstack(L); /* change pointers to offsets */
G(L)->gcstopem = 1; /* stop emergency co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, 0x4(%rsp)
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x28(%rdi), %rcx
movq 0x30(%rdi), %rdx
subq %rdx, %rcx
movb 0x67(%rax), %al
movb %al, 0x3(%rsp)
subq %rdx, 0x10(%rdi)
subq %rdx, 0x40(%rdi)
leaq 0x38(%rdi), %rax
movq (%rax), %rax... | /NLua[P]lua/src/ldo.c |
tryfuncTM | static StkId tryfuncTM (lua_State *L, StkId func) {
const TValue *tm;
StkId p;
checkstackGCp(L, 1, func); /* space for metamethod */
tm = luaT_gettmbyobj(L, s2v(func), TM_CALL); /* (after previous GC) */
if (l_unlikely(ttisnil(tm)))
luaG_callerror(L, s2v(func)); /* nothing to call */
for (p = L->top.... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rax
subq 0x10(%rdi), %rax
cmpq $0x10, %rax
jle 0x11267
pushq $0x17
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21144
testb $0xf, 0x8(%rax)
je 0x11291
movq 0x10(%r14), %rcx
cmpq %rbx, %rcx
jbe 0x1124b
movq -0x10(%rcx), %rdx
movq %rd... | /NLua[P]lua/src/ldo.c |
luaD_pcall | int luaD_pcall (lua_State *L, Pfunc func, void *u,
ptrdiff_t old_top, ptrdiff_t ef) {
int status;
CallInfo *old_ci = L->ci;
lu_byte old_allowhooks = L->allowhook;
ptrdiff_t old_errfunc = L->errfunc;
L->errfunc = ef;
status = luaD_rawrunprotected(L, func, u);
if (l_unlikely(status != LUA_OK... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %r12
movb 0xb(%rdi), %r13b
movq 0xa8(%rdi), %r15
movq %r8, 0xa8(%rdi)
callq 0x108f7
xorl %ebp, %ebp
testl %eax, %eax
jne 0x117e7
movq %r15, 0xa8(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
p... | /NLua[P]lua/src/ldo.c |
unroll | static void unroll (lua_State *L, void *ud) {
CallInfo *ci;
UNUSED(ud);
while ((ci = L->ci) != &L->base_ci) { /* something in the stack */
if (!isLua(ci)) /* C function? */
finishCcall(L, ci); /* complete its execution */
else { /* Lua function */
luaV_finishOp(L); /* finish interrupted i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x60(%rdi), %r12
pushq $0x1
popq %rbp
movq 0x20(%rbx), %r14
cmpq %r12, %r14
je 0x11a69
movzwl 0x3e(%r14), %eax
testb $0x2, %al
jne 0x119b7
movq %rbx, %rdi
callq 0x231e4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x232e9
jmp 0x1198c
movzwl %ax, %r15d... | /NLua[P]lua/src/ldo.c |
dumpFunction | static void dumpFunction (DumpState *D, const Proto *f, TString *psource) {
if (D->strip || f->source == psource)
dumpString(D, NULL); /* no debug info or same source as its parent */
else
dumpString(D, f->source);
dumpInt(D, f->linedefined);
dumpInt(D, f->lastlinedefined);
dumpByte(D, f->numparams);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x18(%rdi)
je 0x11bc7
movq %r14, %rdi
xorl %esi, %esi
callq 0x11f11
jmp 0x11bd8
movq 0x70(%rbx), %rsi
cmpq %rdx, %rsi
je 0x11bbb
movq %r14, %rdi
callq 0x11ebb
movl 0x2c(%rbx), %esi
movq %r14, %rdi
cal... | /NLua[P]lua/src/ldump.c |
luaF_freeproto | void luaF_freeproto (lua_State *L, Proto *f) {
luaM_freearray(L, f->code, f->sizecode);
luaM_freearray(L, f->p, f->sizep);
luaM_freearray(L, f->k, f->sizek);
luaM_freearray(L, f->lineinfo, f->sizelineinfo);
luaM_freearray(L, f->abslineinfo, f->sizeabslineinfo);
luaM_freearray(L, f->locvars, f->sizelocvars);... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x40(%rsi), %rsi
movslq 0x18(%rbx), %rdx
shlq $0x2, %rdx
callq 0x16f05
movq 0x48(%rbx), %rsi
movslq 0x20(%rbx), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
callq 0x16f05
movq 0x38(%rbx), %rsi
movslq 0x14(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
callq 0x1... | /NLua[P]lua/src/lfunc.c |
getgclist | static GCObject **getgclist (GCObject *o) {
switch (o->tt) {
case LUA_VTABLE: return &gco2t(o)->gclist;
case LUA_VLCL: return &gco2lcl(o)->gclist;
case LUA_VCCL: return &gco2ccl(o)->gclist;
case LUA_VTHREAD: return &gco2th(o)->gclist;
case LUA_VPROTO: return &gco2p(o)->gclist;
case LUA_VUSERDA... | movzbl 0x8(%rdi), %ecx
xorl %eax, %eax
leal -0x5(%rcx), %edx
cmpl $0x5, %edx
ja 0x1254a
leaq 0x15b6d(%rip), %rcx # 0x280a8
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
addq $0x30, %rdi
jmp 0x12565
cmpl $0x26, %ecx
jne 0x12568
addq $0x10, %rdi
jmp 0x12565
addq $0x78, %rdi
jmp 0x12565
addq $0x20, %rdi
jmp 0x... | /NLua[P]lua/src/lgc.c |
luaC_freeallobjects | void luaC_freeallobjects (lua_State *L) {
global_State *g = G(L);
g->gcstp = GCSTPCLS; /* no extra finalizers after here */
luaC_changemode(L, KGC_INC);
separatetobefnz(g, 1); /* separate all objects with finalizers */
lua_assert(g->finobj == NULL);
callallpendingfinalizers(L);
deletelist(L, g->allgc, o... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movb $0x4, 0x6a(%r14)
xorl %esi, %esi
callq 0x1270a
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1282d
movq %rbx, %rdi
callq 0x1288a
movq 0x70(%r14), %rsi
movq 0x108(%r14), %rdx
movq %rbx, %rdi
callq 0x128b1
movq 0xb8(%r14), %rsi
movq %rbx, %rdi
xor... | /NLua[P]lua/src/lgc.c |
testing::internal::ExecDeathTest::AssumeRole() (.cold.1) | static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
ExecDeathTestArgs args = { argv, close_fd };
pid_t child_pid = -1;
# if GTEST_OS_QNX
// Obtains the current directory and sets it to be closed in the child
// process.
const int cwd_fd = open(".", O_RDONLY);
GTEST_DEATH_TEST_CHECK_(cw... | pushq %rbx
subq $0x10, %rsp
leaq 0x9cdd1(%rip), %rdi # 0xace88
callq 0xfc00
testl %eax, %eax
je 0x100e9
leaq 0xc(%rsp), %rdi
andl $0x0, (%rdi)
leaq 0xb(%rsp), %rbx
movq %rbx, %rsi
callq 0x6e3f1
movb (%rbx), %al
movb %al, 0x9cda3(%rip) # 0xace80
leaq 0x9cda4(%rip), %rdi # 0xace88
callq 0xf3a0
addq $0x10, %r... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest-death-test.cc |
testing::internal::ParameterizedTestFactory<(anonymous namespace)::AcceptanceTests_Load_Test>::~ParameterizedTestFactory() | explicit ParameterizedTestFactory(ParamType parameter) :
parameter_(parameter) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x94f51(%rip), %rax # 0xa89d0
movq %rax, (%rdi)
addq $0x48, %rdi
callq 0x14288
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x13aa3
movq (%rax), %rsi
incq %rsi
callq 0xf5e0
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x13abb
movq (%rax), %rsi
incq ... | /hellige[P]ccs-cpp/external/googletest/googletest/include/gtest/internal/gtest-param-util.h |
CcsTest_TemplatedBool_Test::TestBody() | TEST(CcsTest, TemplatedBool) {
CcsDomain ccs;
std::istringstream input(
"a = true; b = 'true'; c = false; d = 'false'; e = '1'");
ccs.loadCcsStream(input, "<literal>", ImportResolver::None);
CcsContext ctx = ccs.build();
EXPECT_TRUE(ctx.get<bool>("a"));
EXPECT_TRUE(ctx.get<bool>("b"));
EXPECT_FALSE(... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
leaq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0x324d4
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5e2d7(%rip), %rsi # 0x7c3d3
leaq 0x5e305(%rip), %rdx # 0x7c408
leaq 0x18(%rsp), %rdi
callq 0x17d58
leaq 0x60(%rsp), %rdi
leaq 0x18(%... | /hellige[P]ccs-cpp/test/ccs_test.cpp |
(anonymous namespace)::StringImportResolver::~StringImportResolver() | explicit StringImportResolver(const std::string &ccs) : ccs(ccs) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x84f2b(%rip), %rax # 0xa93b0
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x244a0
movq (%rax), %rsi
incq %rsi
callq 0xf5e0
movl $0x28, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf5e0
| /hellige[P]ccs-cpp/test/ccs_test.cpp |
CcsTest_TemplatedBool_Test::~CcsTest_TemplatedBool_Test() | TEST(CcsTest, TemplatedBool) {
CcsDomain ccs;
std::istringstream input(
"a = true; b = 'true'; c = false; d = 'false'; e = '1'");
ccs.loadCcsStream(input, "<literal>", ImportResolver::None);
CcsContext ctx = ccs.build();
EXPECT_TRUE(ctx.get<bool>("a"));
EXPECT_TRUE(ctx.get<bool>("b"));
EXPECT_FALSE(... | pushq %rbx
movq %rdi, %rbx
callq 0x558e6
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf5e0
nop
| /hellige[P]ccs-cpp/test/ccs_test.cpp |
CcsTest_Escapes_Test::~CcsTest_Escapes_Test() | TEST(CcsTest, Escapes) {
CcsDomain ccs;
std::istringstream input(
"a = '\\\"\\t\\n\\'s'; b = '\\\\'; c = 'Hi \\\nthere'");
ccs.loadCcsStream(input, "<literal>", ImportResolver::None);
CcsContext ctx = ccs.build();
EXPECT_EQ("\"\t\n's", ctx.getString("a"));
EXPECT_EQ("\\", ctx.getString("b"));
EXPECT... | pushq %rbx
movq %rdi, %rbx
callq 0x558e6
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf5e0
nop
| /hellige[P]ccs-cpp/test/ccs_test.cpp |
CcsTest_DomainBuilderNestedSelect_Test::~CcsTest_DomainBuilderNestedSelect_Test() | TEST(CcsTest, DomainBuilderNestedSelect) {
CcsDomain ccs;
ccs.ruleBuilder()
.set("a", "base")
.select("a", v("b"))
.select("c", v("d"))
.set("a", "123");
CcsContext ctx = ccs.build();
EXPECT_EQ("base", ctx.getString("a"));
EXPECT_EQ("base", ctx.constrain("a", v("b")).getString("a... | pushq %rbx
movq %rdi, %rbx
callq 0x558e6
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf5e0
nop
| /hellige[P]ccs-cpp/test/ccs_test.cpp |
CcsTest_Graphviz_Test::~CcsTest_Graphviz_Test() | TEST(CcsTest, Graphviz) {
CcsDomain ccs(std::make_shared<FailingLogger>());
ccs.ruleBuilder()
.select("a").select("b").set("p1", "1").pop()
.select("b").set("p2", "2");
std::ostringstream out;
ccs.logRuleDag(out);
// TODO is there anything useful that can be done here? the graph
// itself is proba... | pushq %rbx
movq %rdi, %rbx
callq 0x558e6
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf5e0
nop
| /hellige[P]ccs-cpp/test/ccs_test.cpp |
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [5], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [5], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x254f0
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x17f66
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %... | /hellige[P]ccs-cpp/external/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [2], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [2], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x254f0
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x17f66
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %... | /hellige[P]ccs-cpp/external/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [4], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [4], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x254f0
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x17f66
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %... | /hellige[P]ccs-cpp/external/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [12]>(char const (&) [12]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x51f2e
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0xf260
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf700
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x26c82
movq 0x8(%r... | /hellige[P]ccs-cpp/external/googletest/googletest/include/gtest/gtest.h |
ContextTest_StringFormat_Test::TestBody() | TEST(ContextTest, StringFormat) {
CcsDomain ccs;
std::istringstream input("b c : @constrain d.e");
ccs.loadCcsStream(input, "<literal>", ImportResolver::None);
CcsContext root = ccs.build();
CcsContext ctx = root.constrain("c").constrain("b");
std::ostringstream os;
os << ctx;
EXPECT_EQ("c > b/d.e", os... | pushq %r15
pushq %r14
pushq %rbx
subq $0x380, %rsp # imm = 0x380
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x324d4
leaq 0x98(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x564e8(%rip), %rsi # 0x7d2b7
leaq 0x564f5(%rip), %rdx # 0x7d2cb
leaq 0x88(%rsp), %rdi
callq 0x17d58
leaq 0x200(%rsp), %rdi
leaq 0x88(... | /hellige[P]ccs-cpp/test/context_test.cpp |
ContextTest_StringFormatWithEmptyContext_Test::~ContextTest_StringFormatWithEmptyContext_Test() | TEST(ContextTest, StringFormatWithEmptyContext) {
CcsDomain ccs;
std::istringstream input("b c : @constrain d.e");
ccs.loadCcsStream(input, "<literal>", ImportResolver::None);
CcsContext root = ccs.build();
CcsContext ctx = root.constrain("c").builder().build().constrain("b");
std::ostringstream os;
os <<... | pushq %rbx
movq %rdi, %rbx
callq 0x558e6
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf5e0
nop
| /hellige[P]ccs-cpp/test/context_test.cpp |
(anonymous namespace)::P::P() | P() :
trace(CcsTracer::makeLoggingTracer(CcsLogger::makeStdErrLogger())),
parser(*trace) {} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x323ac
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x323ee
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2a4bb
callq 0x17590
leaq 0x10(%rbx), %rdi
movq (%rbx), %rsi
callq 0x398f8
addq $0x18, %rsp
popq %rbx
popq %r... | /hellige[P]ccs-cpp/test/parser/parser_test.cpp |
ParserTest_Comments_Test::TestBody() | TEST(ParserTest, Comments) {
P parser;
EXPECT_TRUE(parser.parse("// single line comment\n"));
EXPECT_TRUE(parser.parse("// single line comment nonl"));
EXPECT_TRUE(parser.parse("/* multi-line comment */"));
EXPECT_TRUE(parser.parse("prop = /* comment */ 'val'"));
EXPECT_TRUE(parser.parse("prop = /*/ comment... | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq 0x48(%rsp), %rdi
callq 0x2a488
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5370c(%rip), %rsi # 0x7dd6d
leaq 0x5371c(%rip), %rdx # 0x7dd84
leaq 0x28(%rsp), %rdi
callq 0x17d58
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2a4f2
movb %al, 0x18(%r... | /hellige[P]ccs-cpp/test/parser/parser_test.cpp |
ParserTest_UglyAbutments_Test::TestBody() | TEST(ParserTest, UglyAbutments) {
P parser;
EXPECT_FALSE(parser.parse("foo {p = 1x = 2}"));
EXPECT_TRUE(parser.parse("foo {p = 1x p2 = 2}"));
EXPECT_TRUE(parser.parse("foo {p = 'x'x = 2}"));
EXPECT_FALSE(parser.parse("value=12asdf.foo {}"));
EXPECT_TRUE(parser.parse("value=12asdf.foo nextsel {}"));
EXPECT... | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq 0x48(%rsp), %rdi
callq 0x2a488
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x52eec(%rip), %rsi # 0x7e085
leaq 0x52ef5(%rip), %rdx # 0x7e095
leaq 0x28(%rsp), %rdi
callq 0x17d58
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2a4f2
xorb $0x1, %al
mo... | /hellige[P]ccs-cpp/test/parser/parser_test.cpp |
ParserTest_SelectorSections_Test::TestBody() | TEST(ParserTest, SelectorSections) {
P parser;
EXPECT_TRUE(parser.parse("foo > { bar {}}"));
EXPECT_TRUE(parser.parse("foo > { bar > baz {}}"));
EXPECT_TRUE(parser.parse("bar > baz {}"));
EXPECT_TRUE(parser.parse("bar baz {}"));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq 0x48(%rsp), %rdi
callq 0x2a488
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x522d5(%rip), %rsi # 0x7e3f2
leaq 0x522dd(%rip), %rdx # 0x7e401
leaq 0x28(%rsp), %rdi
callq 0x17d58
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2a4f2
movb %al, 0x18(%r... | /hellige[P]ccs-cpp/test/parser/parser_test.cpp |
(anonymous namespace)::P::parseInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long&) | bool parseInt(const std::string &input, int64_t &out) {
auto pr = parseAndReturnValue(input);
if (!pr.first) return false;
try {
out = pr.second.asInt();
} catch (ccs::bad_coercion &) {
return false;
}
return true;
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2f1fa
cmpb $0x1, (%r14)
jne 0x2df6f
leaq 0x10(%rsp), %rdi
callq 0x31aca
cltq
movq %rax, (%rbx)
movb $0x1, %bl
jmp 0x2df71
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x2dfbe
movq %rbx, %rdi
callq ... | /hellige[P]ccs-cpp/test/parser/parser_test.cpp |
ParserTest_Comments_Test::~ParserTest_Comments_Test() | TEST(ParserTest, Comments) {
P parser;
EXPECT_TRUE(parser.parse("// single line comment\n"));
EXPECT_TRUE(parser.parse("// single line comment nonl"));
EXPECT_TRUE(parser.parse("/* multi-line comment */"));
EXPECT_TRUE(parser.parse("prop = /* comment */ 'val'"));
EXPECT_TRUE(parser.parse("prop = /*/ comment... | pushq %rbx
movq %rdi, %rbx
callq 0x558e6
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf5e0
nop
| /hellige[P]ccs-cpp/test/parser/parser_test.cpp |
ParserTest_StringsWithInterpolation_Test::~ParserTest_StringsWithInterpolation_Test() | TEST(ParserTest, StringsWithInterpolation) {
P parser;
EXPECT_TRUE(parser.parse("a = 'hi'"));
EXPECT_FALSE(parser.parse("a = 'hi"));
EXPECT_FALSE(parser.parse("a = 'hi\\"));
EXPECT_FALSE(parser.parse("a = 'hi\\4 there'"));
EXPECT_TRUE(parser.parse("a = 'h${there}i'"));
EXPECT_FALSE(parser.parse("a = 'h$th... | pushq %rbx
movq %rdi, %rbx
callq 0x558e6
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf5e0
nop
| /hellige[P]ccs-cpp/test/parser/parser_test.cpp |
ccs::CcsContext::CcsContext(ccs::CcsContext const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | CcsContext::CcsContext(const CcsContext &parent, const std::string &name)
: searchState(SearchState::newChild(parent.searchState, Key(name, {}))) {} | pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x3008a
movq 0x7bef4(%rip), %rcx # 0xabf70
cmpb $0x0, (%rcx)
je 0x30086
incl 0x8(%rax)
jmp 0x3008a
lock
incl 0x8(%rax)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, ... | /hellige[P]ccs-cpp/src/context.cpp |
ccs::CcsContext::CcsContext(ccs::CcsContext const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<ch... | CcsContext::CcsContext(const CcsContext &parent, const std::string &name,
const std::vector<std::string> &values)
: searchState(SearchState::newChild(parent.searchState, Key(name, values))) {} | pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x3014d
movq 0x7be31(%rip), %rsi # 0xabf70
cmpb $0x0, (%rsi)
je 0x30149
incl 0x8(%rax)
jmp 0x3014d
lock
incl 0x8(%rax)
leaq 0x18(%rsp), %rdi
movq %rdx, %rsi
movq %rcx, %r... | /hellige[P]ccs-cpp/src/context.cpp |
ccs::CcsContext::getBool(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool CcsContext::getBool(const std::string &propertyName) const {
const CcsProperty &prop(getProperty(propertyName));
if (!prop.exists()) throw no_such_property(propertyName, *this);
return prop.boolValue();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4b908
testq %rax, %rax
leaq 0x7bf0a(%rip), %rbx # 0xac6b8
cmovneq %rax, %rbx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x307d2
movq (%rbx... | /hellige[P]ccs-cpp/src/context.cpp |
ccs::Key::addName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool addName(const std::string &name) {
if (values_.find(name) == values_.end()) {
values_[name];
specificity_.names++;
return true;
}
return false;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3152a
movq %rax, %r15
leaq 0x8(%rbx), %r12
cmpq %r12, %rax
jne 0x30dbd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x314ae
incl 0x30(%rbx)
cmpq %r12, %r15
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /hellige[P]ccs-cpp/src/dag/key.h |
ccs::Value::asBool() const | bool Value::asBool() const
{ return accept<bool>(Caster<bool>(*this)); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
movl (%rdi), %eax
cmpq $0x3, %rax
ja 0x31f8e
leaq 0x4d055(%rip), %rcx # 0x7ef3c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x28(%rbx), %r14
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x2609e
testb... | /hellige[P]ccs-cpp/src/dag/property.cpp |
ccs::Value::str() | void Value::str()
{ strVal_ = accept<std::string>(ToString()); } | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, %rbx
movl (%rdi), %eax
cmpq $0x3, %rax
ja 0x321bd
leaq 0x4ce8b(%rip), %rcx # 0x7ef4c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x31a2e
jmp 0x32183
leaq 0x28(%rsp), %r14
... | /hellige[P]ccs-cpp/src/dag/property.cpp |
ccs::CcsDomain::CcsDomain(std::shared_ptr<ccs::CcsLogger>, bool) | CcsDomain::CcsDomain(std::shared_ptr<CcsLogger> log, bool logAccesses) :
dag(new DagBuilder(CcsTracer::makeLoggingTracer(
std::move(log), logAccesses))) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r15
movl $0x28, %edi
callq 0xf5b0
movq %rax, %rbx
movq (%r12), %r13
movq 0x8(%r12), %r14
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movl $0x30, %edi
callq 0xf5b0
movabsq $0x100000001, %rcx # ... | /hellige[P]ccs-cpp/src/domain.cpp |
ccs::CcsDomain::build() | CcsContext CcsDomain::build() {
return CcsContext(dag->root());
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rax), %rcx
movq %rcx, (%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x32794
movq 0x797ea(%rip), %rcx # 0xabf70
cmpb $0x0, (%rcx)
je 0x32790
incl 0x8(%rax)
jmp 0x32794
lock
incl 0x8(%rax)
movq %rsp, %rsi
movq %rbx, %rdi
c... | /hellige[P]ccs-cpp/src/domain.cpp |
ccs::Loader::loadCcsStream(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, ccs::DagBuilder&, ccs::ImportResolver&) | void loadCcsStream(std::istream &stream, const std::string &fileName,
DagBuilder &dag, ImportResolver &importResolver) {
ast::Nested ast;
std::vector<std::string> inProgress;
if (parseCcsStream(stream, fileName, importResolver, inProgress, ast)) {
// everything parsed, no errors. now it's safe t... | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %r8, %rax
movq %rcx, %rbx
leaq 0x77232(%rip), %r14 # 0xaa420
addq $0x10, %r14
leaq 0x38(%rsp), %r9
movq %r14, (%r9)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r9)
movups %xmm0, 0x18(%r9)
xorl %ecx, %ecx
movq %rcx, 0x28(%r9)
leaq 0x20(%rsp), %r8
movq %rcx, 0x10(%r8)
movaps %xmm... | /hellige[P]ccs-cpp/src/parser/loader.h |
ccs::(anonymous namespace)::operator<<(std::ostream&, ccs::(anonymous namespace)::Streamer const&) | std::ostream &operator<<(std::ostream &os, const Streamer &ss) {
if (!ss.style.empty()) {
bool first = true;
if (!ss.root) os << '[';
for (auto it = ss.style.cbegin(); it != ss.style.cend(); ++it) {
if (!first && !ss.root) os << ", ";
first = false;
os << it->first;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
cmpq $0x0, 0x28(%rax)
je 0x3449c
movq %rsi, %r12
cmpb $0x0, 0x8(%rsi)
jne 0x34356
leaq 0x6(%rsp), %rsi
movb $0x5b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xf700
movq (%r12), %rax
movq 0x18(%rax), %r15
ad... | /hellige[P]ccs-cpp/src/graphviz.cpp |
ccs::ast::SelectorBranch::conjunction(std::shared_ptr<ccs::ast::SelectorLeaf>) | SelectorBranch::P SelectorBranch::conjunction(SelectorLeaf::P first) {
return std::make_shared<BranchImpl>(first, [](SelectorLeaf &first,
BuildContext::P context, BuildContext::P baseContext) {
return context->conjunction(context->traverse(first), baseContext);
});
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r12
movq %rdi, %r14
movl $0x48, %edi
callq 0xf5b0
movq %rax, %rbx
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%rbx)
leaq 0x74baf(%rip), %rax # 0xaa6a0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x10(%rbx), %r15
movq (%r12),... | /hellige[P]ccs-cpp/src/parser/ast.cpp |
ccs::TallyBuildContext<ccs::OrTally>::traverse(ccs::ast::SelectorLeaf&) | virtual Node &traverse(ast::SelectorLeaf &selector) {
Node &secondNode = selector.traverse(baseContext_);
// we've arrived at the same node by two different paths. no tally is
// actually needed here...
if (&firstNode_ == &secondNode) return firstNode_;
std::set<std::shared_ptr<Tally>> tallies;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rax
movq %rdi, %r14
movq 0x18(%rdi), %rcx
movq %rcx, 0x40(%rsp)
movq 0x20(%rdi), %rcx
movq %rcx, 0x48(%rsp)
testq %rcx, %rcx
je 0x393f4
movq 0x72b8a(%rip), %rdx # 0xabf70
cmpb $0x0, (%rdx)
je 0x393f0
incl 0x8(%rcx)
jmp 0x393f4
lock
incl 0x8(%rcx)
movq (%... | /hellige[P]ccs-cpp/src/parser/build_context.cpp |
ccs::(anonymous namespace)::Lexer::multilineComment() | void multilineComment() {
while (true) {
int c = stream_.get();
if (c == EOF)
THROW(stream_.location(), "Unterminated multi-line comment");
if (c == '*' && stream_.peek() == '/') {
stream_.get();
return;
}
if (c == '/' && stream_.peek() == '*') {
stream_... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %r14
movq %r14, %rdi
callq 0x3a5e8
movl %eax, %ebx
cmpl $0x2a, %eax
je 0x3ae8f
cmpl $0x2f, %ebx
je 0x3aea1
cmpl $-0x1, %ebx
jne 0x3ae74
jmp 0x3aed5
movq (%r14), %rdi
callq 0xf210
cmpl $0x2f, %eax
je 0x3aec0
cmpl $0x2f, %eb... | /hellige[P]ccs-cpp/src/parser/parser.cpp |
ccs::ParserImpl::advance() | void advance() { last_ = cur_; cur_ = lex_.consume(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movl 0x90(%rdi), %eax
movl %eax, 0xe8(%rdi)
movq 0x88(%rdi), %rax
movq %rax, 0xe0(%rdi)
addq $0xf0, %rdi
leaq 0x98(%rbx), %r14
movq %r14, %rsi
callq 0xf300
leaq 0x110(%rbx), %rdi
leaq 0xb8(%rbx), %rsi
callq 0x3ba3e
movups... | /hellige[P]ccs-cpp/src/parser/parser.cpp |
ccs::ParserImpl::parseTerm() | ast::SelectorLeaf::P parseTerm() {
auto left = parseStep();
while (cur_.type == Token::GT) {
// here we have to distinguish another step from a trailing '>'. again,
// peeking for ident or '(' does the trick.
if (!couldStartStep(lex_.peek())) return left;
advance();
left = left->de... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x499f2
cmpl $0x9, 0x88(%r14)
jne 0x4999e
leaq 0x28(%rsp), %r15
leaq 0x10(%rsp), %r12
movq %rsp, %r13
movl 0x30(%r14), %eax
cmpl $0x14, %eax
ja 0x4999e
movl $0x140002, %ecx # imm = 0x140002
b... | /hellige[P]ccs-cpp/src/parser/parser.cpp |
ccs::RuleBuilder::Impl::select(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | std::shared_ptr<RuleBuilder::Impl> RuleBuilder::Impl::select(
const std::string &name, const std::vector<std::string> &values) {
return std::shared_ptr<Impl>(new Child(shared_from_this(), name, values));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movl $0x30, %edi
callq 0xf5b0
movq %rax, %rbx
addq $0x8, %r13
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x4b21a
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r... | /hellige[P]ccs-cpp/src/rule_builder.cpp |
ccs::RuleBuilder::Impl::~Impl() | virtual ~Impl() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x5fc7b(%rip), %rax # 0xaacb8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x4b053
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x18(%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x4b091
movq 0x60f05(%rip), %rax # 0xabf70
cmpb $0x0, (%rax)
je 0x... | /hellige[P]ccs-cpp/src/rule_builder.cpp |
ccs::SearchState::doSearch(ccs::CcsContext const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | const CcsProperty *SearchState::doSearch(const CcsContext &context,
const std::string &propertyName) const {
auto it = properties.find(propertyName);
if (it == properties.end()) {
if (parent) return parent->doSearch(context, propertyName);
return nullptr;
}
if (it->second.values.size() == 1)
re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x80(%r15), %rdi
movq %rbx, %rsi
callq 0x4d2aa
leaq 0x88(%r15), %rcx
cmpq %rcx, %rax
jne 0x4b995
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x4b96c
jmp 0x4baf1
cmpq $... | /hellige[P]ccs-cpp/src/search_state.cpp |
ccs::SearchState::append(std::ostream&, bool) const | void SearchState::append(std::ostream &out, bool isPrefix) const {
if (parent) {
parent->append(out, isPrefix || !key.empty());
} else if (key.empty() && !isPrefix) {
out << "<root>";
return;
}
if (!key.empty()) {
out << key;
if (isPrefix) out << " > ";
}
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movq 0xe0(%r14), %rax
testq %rdi, %rdi
je 0x4bc24
testq %rax, %rax
setne %al
orb %bpl, %al
movzbl %al, %edx
movq %rbx, %rsi
callq 0x4bbf2
jmp 0x4bc2f
testq %rax, %rax
setne %al
orb %bpl, %al
je 0x4bc63
cmpq $0x0, 0xe0... | /hellige[P]ccs-cpp/src/search_state.cpp |
testing::internal::Random::Generate(unsigned int) | uint32_t Random::Generate(uint32_t range) {
// These constants are the same as are used in glibc's rand(3).
// Use wider types than necessary to prevent unsigned overflow diagnostics.
state_ = static_cast<uint32_t>(1103515245ULL*state_ + 12345U) % kMaxRange;
GTEST_CHECK_(range > 0)
<< "Cannot generate a ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
imull $0x41c64e6d, (%rdi), %eax # imm = 0x41C64E6D
addl $0x3039, %eax # imm = 0x3039
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movl %eax, (%rdi)
testl %esi, %esi
jne 0x4de71
leaq 0x341d9(%rip), %rdx # 0x81ffc
leaq 0xc(... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::UnitTest::GetInstance() | UnitTest* UnitTest::GetInstance() {
// CodeGear C++Builder insists on a public destructor for the
// default implementation. Use this implementation to keep good OO
// design with private destructor.
#if defined(__BORLANDC__)
static UnitTest* const instance = new UnitTest;
return instance;
#else
static Un... | pushq %rbx
movb 0x5ecef(%rip), %al # 0xacde8
testb %al, %al
je 0x4e106
leaq 0x5ec9c(%rip), %rax # 0xacda0
popq %rbx
retq
leaq 0x5ecdb(%rip), %rdi # 0xacde8
callq 0xfc00
testl %eax, %eax
je 0x4e0fd
leaq 0x5ec83(%rip), %rdi # 0xacda0
callq 0x62f7c
leaq 0x14eb9(%rip), %rdi # 0x62fe2
leaq 0x5ec70(%rip)... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::GetCurrentExecutableName() | FilePath GetCurrentExecutableName() {
FilePath result;
#if GTEST_OS_WINDOWS || GTEST_OS_OS2
result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
#else
result.Set(FilePath(GetArgvs()[0]));
#endif // GTEST_OS_WINDOWS
return result.RemoveDirectoryName();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x5d2df(%rip), %rsi # 0xacd80
leaq 0x48(%rsp), %rdi
callq 0x1790e
movq 0x48(%rsp), %rax
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() | ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
impl->SetGlobalTestPartResultReporter(old_reporter_);
} else {
impl->SetTestPartResultReporterForCurrentThread(old_repor... | pushq %rbx
movq %rdi, %rbx
leaq 0x59c41(%rip), %rax # 0xaae90
movq %rax, (%rdi)
callq 0x4e0f2
movq 0x5bb82(%rip), %rdi # 0xacde0
cmpl $0x1, 0x8(%rbx)
movq 0x10(%rbx), %rbx
jne 0x51272
movq %rbx, %rsi
callq 0x511ea
jmp 0x51281
addq $0x90, %rdi
callq 0x76012
movq %rbx, (%rax)
popq %rbx
retq
movq %rax, %rdi
callq ... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::os_stack_trace_getter() | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
if (os_stack_trace_getter_ == nullptr) {
#ifdef GTEST_OS_STACK_TRACE_GETTER_
os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
#else
os_stack_trace_getter_ = new OsStackTraceGetter;
#endif // GTEST_OS_STACK_TRACE_GETTER_
}
ret... | pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x210(%rdi)
jne 0x51d85
movl $0x8, %edi
callq 0xf5b0
leaq 0x5946d(%rip), %rcx # 0xab1e8
movq %rcx, (%rax)
movq %rax, 0x210(%rbx)
movq 0x210(%rbx), %rax
popq %rbx
retq
| /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::edit_distance::CalculateOptimalEdits(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>,... | std::vector<EditType> CalculateOptimalEdits(
const std::vector<std::string>& left,
const std::vector<std::string>& right) {
std::vector<size_t> left_ids, right_ids;
{
InternalStrings intern_table;
for (size_t i = 0; i < left.size(); ++i) {
left_ids.push_back(intern_table.GetId(left[i]));
}... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x50(%rsp)
xorl %eax, %eax
movq %rax, 0x40(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq %rax, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
leaq 0x60(%rsp), %rcx
movl $0x0, (%rcx)
movq %rax, 0x8... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::GetBoolAssertionFailureMessage[abi:cxx11](testing::AssertionResult const&, char const*, char const*, char const*) | std::string GetBoolAssertionFailureMessage(
const AssertionResult& assertion_result,
const char* expression_text,
const char* actual_predicate_value,
const char* expected_predicate_value) {
const char* actual_message = assertion_result.message();
Message msg;
msg << "Value of: " << expression_text... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %rbx
movq %rdi, 0x8(%rsp)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x53567
movq (%rax), %r13
jmp 0x5356e
leaq 0x2f663(%rip), %r13 # 0x82bd1
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x51f2e... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::TestResult::Clear() | void TestResult::Clear() {
test_part_results_.clear();
test_properties_.clear();
death_test_count_ = 0;
elapsed_time_ = 0;
} | pushq %rbx
movq %rdi, %rbx
addq $0x38, %rdi
movq 0x38(%rbx), %rsi
callq 0x76876
leaq 0x50(%rbx), %rdi
movq 0x50(%rbx), %rsi
callq 0x77048
movl $0x0, 0x68(%rbx)
movq $0x0, 0x78(%rbx)
popq %rbx
retq
nop
| /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::Test::HasSameFixtureClass() | int UnitTestImpl::test_suite_to_run_count() const {
return CountIf(test_suites_, ShouldRunTestSuite);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
callq 0x4e0f2
movq 0x5728a(%rip), %rax # 0xacde0
movq 0x168(%rax), %rcx
movq 0x170(%rax), %rbp
movq 0x30(%rcx), %rax
movq (%rax), %rax
movq 0x78(%rax), %rcx
movq 0x78(%rbp), %rdx
cmpq %rcx, %rdx
je 0x55efa
movq 0x20(%rax), %r14
movq ... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::GoogleTestFailureException::GoogleTestFailureException(testing::TestPartResult const&) | GoogleTestFailureException::GoogleTestFailureException(
const TestPartResult& failure)
: ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x55fb9
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xfc90
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55f81
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xf5e0
leaq 0x55850(%rip), %rax # 0xab7d8
movq %rax, ... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::Test::Run() | void Test::Run() {
if (!HasSameFixtureClass()) return;
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl->os_stack_trace_getter()->UponLeavingGTest();
internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
// We will run the test only if SetUp() was successful and ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x55b3c
testb %al, %al
je 0x56219
callq 0x4e0f2
movq 0x56cb8(%rip), %r14 # 0xacde0
cmpq $0x0, 0x210(%r14)
jne 0x5614d
movl $0x8, %edi
callq 0xf5b0
leaq 0x550a5(%rip), %rcx # 0xab1e8
movq %rcx, (%rax)
movq %rax, 0x210(%r14)
movq 0x210(%r14), %rdi
movq (%rdi)... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::MakeAndRegisterTestInfo(char const*, char const*, char const*, char const*, testing::internal::CodeLocation, void const*, void (*)(), void (*)(), testing::internal::TestFactoryBase*) | TestInfo* MakeAndRegisterTestInfo(
const char* test_suite_name, const char* name, const char* type_param,
const char* value_param, CodeLocation code_location,
TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
TestInfo* const test_inf... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, %r14
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %rbx
movl $0x110, %edi # imm = 0x110
callq 0xf5b0
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rbx, %rsi
callq 0... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::TestSuite::GetTestInfo(int) const | const TestInfo* TestSuite::GetTestInfo(int i) const {
const int index = GetElementOr(test_indices_, i, -1);
return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
} | movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %esi, %esi
js 0x57231
movq 0x48(%rdi), %rcx
movq 0x50(%rdi), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x57231
movl %esi, %eax
movl (%rcx,%rax,4), %eax
testl %eax, %eax
js 0x57240
movl %eax, %eax
movq 0x30(%rdi), %rcx
movq (%rcx,%rax,8), %rax
retq
xor... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestIterationStart(testing::UnitTest const&, int) | void PrettyUnitTestResultPrinter::OnTestIterationStart(
const UnitTest& unit_test, int iteration) {
if (GTEST_FLAG(repeat) != 1)
printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
const char* const filter = GTEST_FLAG(filter).c_str();
// Prints the filter if it's not *. This remin... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
cmpl $0x1, 0x553c4(%rip) # 0xacd28
je 0x57978
incl %edx
leaq 0x2b10c(%rip), %rdi # 0x82a7b
movl %edx, %esi
xorl %eax, %eax
callq 0xf080
movq 0x55359(%rip), %r14 # 0xaccd8
testq %r14, %r14
je 0x57997
leaq 0x295ab(%rip), %rsi # 0x80f36
movq... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::ShouldShard(char const*, char const*, bool) | bool ShouldShard(const char* total_shards_env,
const char* shard_index_env,
bool in_subprocess_for_death_test) {
if (in_subprocess_for_death_test) {
return false;
}
const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);
const int32_t shard_index = Int32FromE... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
testl %edx, %edx
jne 0x57c8c
movq %rsi, %r14
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x5805f
movl %eax, %ebx
movq %r14, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x5805f
movl %eax, %ebp
andl %ebx, %eax
cmpl $-0x1, %eax
je 0x57c8c
cmpl $-0x... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&) | void PrettyUnitTestResultPrinter::OnTestPartResult(
const TestPartResult& result) {
switch (result.type()) {
// If the test part succeeded, we don't need to do anything.
case TestPartResult::kSuccess:
return;
default:
// Print failure message from the assertion
// (e.g. expected this... | cmpl $0x0, (%rsi)
je 0x58436
pushq %rax
movq %rsi, %rdi
callq 0x58437
movq 0x53adb(%rip), %rax # 0xabf08
movq (%rax), %rdi
popq %rax
jmp 0xf760
retq
| /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlAttribute(std::ostream*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::alloc... | void XmlUnitTestResultPrinter::OutputXmlAttribute(
std::ostream* stream,
const std::string& element_name,
const std::string& name,
const std::string& value) {
const std::vector<std::string>& allowed_names =
GetReservedOutputAttributesForElement(element_name);
GTEST_CHECK_(std::find(allowed_na... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x5b736
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq %r15, %rdx
callq 0x41831
cmpq 0x30(%rsp), %rax
jne 0x5b647
leaq 0x26a52(%rip), %rdx ... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::GetReservedOutputAttributesForElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static std::vector<std::string> GetReservedOutputAttributesForElement(
const std::string& xml_element) {
if (xml_element == "testsuites") {
return ArrayAsVector(kReservedTestSuitesAttributes);
} else if (xml_element == "testsuite") {
return ArrayAsVector(kReservedTestSuiteAttributes);
} else if (xml_e... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x27768(%rip), %rsi # 0x82eaf
movq %r14, %rdi
callq 0xf170
testl %eax, %eax
je 0x5b7fd
leaq 0x2762a(%rip), %rsi # 0x82d88
movq %r14, %rdi
callq 0xf170
testl %eax, %eax
je 0x5b812
leaq 0x2765d(%rip), %rsi # 0x82dd2
movq %r14, %rdi
callq 0x... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes[abi:cxx11](testing::TestResult const&) | std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
const TestResult& result) {
Message attributes;
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
attributes << " " << property.key() << "="
<< "\"" << EscapeXmlA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, 0x30(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x51f2e
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
testl %eax, %eax
jle 0x5de1d
movq 0x8(%rsp), %r15
addq $0x10, %r15
xorl %ebp, %ebp
leaq 0x38(%rsp), %r12... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult(std::ostream*, testing::TestResult const&) | void JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult(
::std::ostream* stream, const TestResult& result) {
// Output the boilerplate for a new test suite.
*stream << Indent(4) << "{\n";
OutputJsonKey(stream, "testsuite", "name", "NonTestSuiteFailure", Indent(6));
OutputJsonKey(stream, "testsuite"... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, 0x80(%rsp)
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rsp, %r15
movl $0x4, %esi
movq %r15, %rdi
movl $0x20, %edx
callq 0xf740
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0xf700
leaq 0x2... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::PrintJsonTestSuite(std::ostream*, testing::TestSuite const&) | void JsonUnitTestResultPrinter::PrintJsonTestSuite(
std::ostream* stream, const TestSuite& test_suite) {
const std::string kTestsuite = "testsuite";
const std::string kIndent = Indent(6);
*stream << Indent(4) << "{\n";
OutputJsonKey(stream, kTestsuite, "name", test_suite.name(), kIndent);
OutputJsonKey(s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x216b9(%rip), %rsi # 0x82d88
leaq 0x216bb(%rip), %rdx # 0x82d91
leaq 0x68(%rsp), %rdi
callq 0x17d58
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
l... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::TestEventListeners::SetDefaultResultPrinter(testing::TestEventListener*) | void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
if (default_result_printer_ != listener) {
// It is an error to pass this method a listener that is already in the
// list.
delete Release(default_result_printer_);
default_result_printer_ = listener;
if (listener != n... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %rsi
cmpq %rbx, %rsi
je 0x6256e
movq %rdi, %r14
movq $0x0, 0x8(%rdi)
movq (%rdi), %rdi
callq 0x5933c
testq %rax, %rax
je 0x62553
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rbx, 0x8(%r14)
testq %rbx, %rbx
je 0x6256e
movq (%r14), %rdi
movq %rb... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::UnitTest::AddEnvironment(testing::Environment*) | Environment* UnitTest::AddEnvironment(Environment* env) {
if (env == nullptr) {
return nullptr;
}
impl_->environments().push_back(env);
return env;
} | pushq %rax
movq %rsi, (%rsp)
testq %rsi, %rsi
je 0x62767
movq 0x40(%rdi), %rdi
movq 0xa8(%rdi), %rax
cmpq 0xb0(%rdi), %rax
je 0x6276b
movq %rsi, (%rax)
addq $0x8, 0xa8(%rdi)
jmp 0x6277d
xorl %eax, %eax
jmp 0x62781
addq $0xa0, %rdi
movq %rsp, %rdx
movq %rax, %rsi
callq 0x77608
movq (%rsp), %rax
popq %rcx
retq
nop
| /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::~UnitTestImpl() | UnitTestImpl::~UnitTestImpl() {
// Deletes every TestSuite.
ForEach(test_suites_, internal::Delete<TestSuite>);
// Deletes every Environment.
ForEach(environments_, internal::Delete<Environment>);
delete os_stack_trace_getter_;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x47ccf(%rip), %rax # 0xab158
movq %rax, (%rdi)
movq 0xb8(%rdi), %r14
movq 0xc0(%rdi), %r15
cmpq %r15, %r14
je 0x634b3
movq (%r14), %rdi
testq %rdi, %rdi
je 0x634ad
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x6349a
movq 0xa0(%rbx), %r14
movq 0xa8(%r... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::ShuffleTests() | void UnitTestImpl::ShuffleTests() {
// Shuffles the death test suites.
ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_);
// Shuffles the non-death test suites.
ShuffleRange(random(), last_death_test_suite_ + 1,
static_cast<int>(test_suites_.size()), &test_suite_indices... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x220(%rdi), %rbx
movl 0x164(%rdi), %edx
incl %edx
leaq 0xd0(%rdi), %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x71a06
movl 0x164(%r14), %esi
incl %esi
movq 0xc0(%r14), %rdx
subq 0xb8(%r14), %rdx
shrq $0x3, %rdx
movq %rbx, %rdi
movq %r15, %rcx
callq ... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::ParseGoogleTestFlagsOnly(int*, char**) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
ParseGoogleTestFlagsOnlyImpl(argc, argv);
// Fix the value of *_NSGetArgc() on macOS, but if and only if
// *_NSGetArgv() == argv
// Only applicable to char** version of argv
#if GTEST_OS_MAC
#ifndef GTEST_OS_IOS
if (*_NSGetArgv() == argv) {
*_NSGet... | jmp 0x71c06
| /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::InitGoogleTest() | void InitGoogleTest() {
// Since Arduino doesn't have a command line, fake out the argc/argv arguments
int argc = 1;
const auto arg0 = "dummy";
char* argv0 = const_cast<char*>(arg0);
char** argv = &argv0;
#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, ar... | subq $0x18, %rsp
leaq 0xc(%rsp), %rdi
movl $0x1, (%rdi)
leaq 0x1e85b(%rip), %rax # 0x8337c
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
callq 0x71ed6
addq $0x18, %rsp
retq
| /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::DeathTestImpl::Passed(bool) | bool DeathTestImpl::Passed(bool status_ok) {
if (!spawned())
return false;
const std::string error_message = GetErrorLogs();
bool success = false;
Message buffer;
buffer << "Death test: " << statement() << "\n";
switch (outcome()) {
case LIVED:
buffer << " Result: failed to die.\n"
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
cmpb $0x1, 0x28(%rdi)
jne 0x65b85
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq *0x30(%rax)
leaq 0x28(%rsp), %rdi
callq 0x51f2e
movq 0x28(%rsp), %rbx
addq $0x10, %rbx
leaq 0x1d9ba(%rip)... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest-death-test.cc |
testing::internal::ForkingDeathTest::ForkingDeathTest(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>) | ForkingDeathTest::ForkingDeathTest(const char* a_statement,
Matcher<const std::string&> matcher)
: DeathTestImpl(a_statement, std::move(matcher)), child_pid_(-1) {} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x457fc(%rip), %r15 # 0xabae0
movq %r15, (%rsp)
movq 0x8(%rdx), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rdx), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x8(%rdx)
leaq 0x4554f(%rip), %r12 # 0xab858
movq %r12, (%rsp)
callq ... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest-death-test.cc |
testing::internal::ExecDeathTest::AssumeRole() | DeathTest::TestRole ExecDeathTest::AssumeRole() {
const UnitTestImpl* const impl = GetUnitTestImpl();
const InternalRunDeathTestFlag* const flag =
impl->internal_run_death_test_flag();
const TestInfo* const info = impl->current_test_info();
const int death_test_index = info->result()->death_test_count();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, %rbx
callq 0x4e0f2
movq 0x452c0(%rip), %rax # 0xacde0
movq 0x170(%rax), %r14
movq 0x238(%rax), %rax
movl 0xf8(%r14), %ecx
movl %ecx, 0x134(%rsp)
testq %rax, %rax
je 0x67b51
movl 0x28(%rax), %eax
m... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest-death-test.cc |
testing::internal::FilePath::GetCurrentDir() | FilePath FilePath::GetCurrentDir() {
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_ESP32 || \
GTEST_OS_XTENSA
// These platforms do not have a current directory, so we just return
// something reasonable.
return FilePath(kCurrentDire... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1028, %rsp # imm = 0x1028
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movl $0x1001, %edx # imm = 0x1001
movq %r14, %rdi
xorl %esi, %esi
callq 0xf320
movl $0x1001, %esi # imm = 0x1001
movq %r14, %rdi
callq 0xf2b0
testq %rax, %rax
leaq 0x17905(%r... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest-filepath.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<const std::string&>::Matcher(const std::string& s) { *this = Eq(s); } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x3ff01(%rip), %r14 # 0xab858
movq %r14, (%rdi)
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x174fa
leaq 0x10(%rs... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest-matchers.cc |
testing::internal::FlagToEnvVar[abi:cxx11](char const*) | static std::string FlagToEnvVar(const char* flag) {
const std::string full_flag =
(Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
Message env_var;
for (size_t i = 0; i != full_flag.length(); i++) {
env_var << ToUpper(full_flag.c_str()[i]);
}
return env_var.GetString();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x51f2e
movq (%r14), %r14
leaq 0x10(%r14), %r12
leaq 0x17079(%rip), %rsi # 0x836f8
movl $0x6, %r13d
movl $0x6, %edx
movq %r12, %rdi
callq 0xf700
testq %r15, %r15
je 0x6c... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest-port.cc |
testing::internal::PrintTo(wchar_t const*, std::ostream*) | void PrintTo(const wchar_t* s, ostream* os) { PrintCStringTo(s, os); } | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x6cb70
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf470
leaq 0x17b93(%rip), %rsi # 0x846d9
movl $0xd, %edx
movq %rax, %rdi
callq 0xf700
movq %r14, %rdi
callq 0xf4d0
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq ... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest-printers.cc |
testing::internal::CharFormat testing::internal::PrintCharsAsStringTo<char16_t>(char16_t const*, unsigned long, std::ostream*) | static CharFormat PrintCharsAsStringTo(
const CharType* begin, size_t len, ostream* os) {
const char* const quote_prefix = GetCharWidthPrefix(*begin);
*os << quote_prefix << "\"";
bool is_previous_hex = false;
CharFormat print_format = kAsIs;
for (size_t index = 0; index < len; ++index) {
const CharTy... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x134a2(%rip), %rsi # 0x80370
movl $0x1, %edx
movq %rbx, %rdi
callq 0xf700
leaq 0x160cf(%rip), %rsi # 0x82fb1
movl $0x1, %edx
movq %rbx, %rdi
callq 0xf700
testq %r14, %r14
je 0x6cf6f... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest-printers.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.