name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
FIX50SP1::MessageCracker::onMessage(FIX50SP1::ApplicationMessageRequestAck const&, FIX::SessionID const&) | virtual void onMessage( const ApplicationMessageRequestAck&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x107fa(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x2829b(%rip), %rsi # 0x59af0
leaq 0xeb6e(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x31886
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x31886
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x31893
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp1/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::AllocationInstructionAck const&, FIX::SessionID const&) | virtual void onMessage( const AllocationInstructionAck&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xfb88(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x27629(%rip), %rsi # 0x59af0
leaq 0xdefc(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x324f8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x324f8
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x32505
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::DontKnowTrade const&, FIX::SessionID const&) | virtual void onMessage( const QuoteRequest&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xfaf4(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x27595(%rip), %rsi # 0x59af0
leaq 0xde68(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3258c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x3258c
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x32599
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::Quote const&, FIX::SessionID const&) | virtual void onMessage( const Quote&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf9cc(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x2746d(%rip), %rsi # 0x59af0
leaq 0xdd40(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x326b4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x326b4
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x326c1
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::SettlementInstructions const&, FIX::SessionID const&) | virtual void onMessage( const MarketDataRequest&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf938(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x273d9(%rip), %rsi # 0x59af0
leaq 0xdcac(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32748
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x32748
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x32755
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::MarketDataRequest const&, FIX::SessionID const&) | virtual void onMessage( const MarketDataSnapshotFullRefresh&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf8a4(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x27345(%rip), %rsi # 0x59af0
leaq 0xdc18(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x327dc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x327dc
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x327e9
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::MarketDataSnapshotFullRefresh const&, FIX::SessionID const&) | virtual void onMessage( const MarketDataIncrementalRefresh&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf810(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x272b1(%rip), %rsi # 0x59af0
leaq 0xdb84(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32870
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x32870
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3287d
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::QuoteStatusRequest const&, FIX::SessionID const&) | virtual void onMessage( const QuoteStatusRequest&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf5c0(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x27061(%rip), %rsi # 0x59af0
leaq 0xd934(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32ac0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x32ac0
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x32acd
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::MassQuoteAck const&, FIX::SessionID const&) | virtual void onMessage( const MassQuoteAck&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf52c(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x26fcd(%rip), %rsi # 0x59af0
leaq 0xd8a0(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32b54
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x32b54
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x32b61
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::SecurityDefinition const&, FIX::SessionID const&) | virtual void onMessage( const SecurityDefinition&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf404(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x26ea5(%rip), %rsi # 0x59af0
leaq 0xd778(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32c7c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x32c7c
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x32c89
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::SecurityStatus const&, FIX::SessionID const&) | virtual void onMessage( const TradingSessionStatusRequest&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf2dc(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x26d7d(%rip), %rsi # 0x59af0
leaq 0xd650(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32da4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x32da4
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x32db1
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::BidResponse const&, FIX::SessionID const&) | virtual void onMessage( const ListStrikePrice&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xeff6(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x26a97(%rip), %rsi # 0x59af0
leaq 0xd36a(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3308a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x3308a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x33097
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::OrderMassCancelRequest const&, FIX::SessionID const&) | virtual void onMessage( const OrderMassCancelReport&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xeda6(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x26847(%rip), %rsi # 0x59af0
leaq 0xd11a(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x332da
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x332da
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x332e7
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::OrderMassCancelReport const&, FIX::SessionID const&) | virtual void onMessage( const NewOrderCross&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xed12(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x267b3(%rip), %rsi # 0x59af0
leaq 0xd086(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3336e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x3336e
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3337b
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::SecurityListRequest const&, FIX::SessionID const&) | virtual void onMessage( const SecurityListRequest&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe99a(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x2643b(%rip), %rsi # 0x59af0
leaq 0xcd0e(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x336e6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x336e6
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x336f3
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::DerivativeSecurityList const&, FIX::SessionID const&) | virtual void onMessage( const DerivativeSecurityList&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe7de(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x2627f(%rip), %rsi # 0x59af0
leaq 0xcb52(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x338a2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x338a2
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x338af
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::NewOrderMultileg const&, FIX::SessionID const&) | virtual void onMessage( const MultilegOrderCancelReplace&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe74a(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x261eb(%rip), %rsi # 0x59af0
leaq 0xcabe(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x33936
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x33936
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x33943
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::TradeCaptureReportRequest const&, FIX::SessionID const&) | virtual void onMessage( const TradeCaptureReportRequest&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe622(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x260c3(%rip), %rsi # 0x59af0
leaq 0xc996(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x33a5e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x33a5e
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x33a6b
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::ContraryIntentionReport const&, FIX::SessionID const&) | virtual void onMessage( const ContraryIntentionReport&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd436(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x24ed7(%rip), %rsi # 0x59af0
leaq 0xb7aa(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x34c4a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x34c4a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x34c57
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::SecurityListUpdateReport const&, FIX::SessionID const&) | virtual void onMessage( const AdjustedPositionReport&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd30e(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x24daf(%rip), %rsi # 0x59af0
leaq 0xb682(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x34d72
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x34d72
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x34d7f
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::AdjustedPositionReport const&, FIX::SessionID const&) | virtual void onMessage( const AllocationInstructionAlert&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd27a(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x24d1b(%rip), %rsi # 0x59af0
leaq 0xb5ee(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x34e06
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x34e06
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x34e13
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::AllocationInstructionAlert const&, FIX::SessionID const&) | virtual void onMessage( const ExecutionAck&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd1e6(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x24c87(%rip), %rsi # 0x59af0
leaq 0xb55a(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x34e9a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x34e9a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x34ea7
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::TradingSessionList const&, FIX::SessionID const&) | virtual void onMessage( const TradingSessionList&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd0be(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x24b5f(%rip), %rsi # 0x59af0
leaq 0xb432(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x34fc2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x34fc2
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x34fcf
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::TradingSessionListRequest const&, FIX::SessionID const&) | virtual void onMessage( const TradingSessionListRequest&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd02a(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x24acb(%rip), %rsi # 0x59af0
leaq 0xb39e(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x35056
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x35056
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x35063
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::SettlementObligationReport const&, FIX::SessionID const&) | virtual void onMessage( const SettlementObligationReport&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xcf96(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x24a37(%rip), %rsi # 0x59af0
leaq 0xb30a(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x350ea
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x350ea
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x350f7
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::DerivativeSecurityListUpdateReport const&, FIX::SessionID const&) | virtual void onMessage( const DerivativeSecurityListUpdateReport&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xcf02(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x249a3(%rip), %rsi # 0x59af0
leaq 0xb276(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3517e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x3517e
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3518b
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::MarketDefinition const&, FIX::SessionID const&) | virtual void onMessage( const MarketDefinitionUpdateReport&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xcd46(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x247e7(%rip), %rsi # 0x59af0
leaq 0xb0ba(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3533a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x3533a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x35347
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::MarketDefinitionUpdateReport const&, FIX::SessionID const&) | virtual void onMessage( const MarketDefinitionUpdateReport&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xccb2(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x24753(%rip), %rsi # 0x59af0
leaq 0xb026(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x353ce
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x353ce
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x353db
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::StreamAssignmentReport const&, FIX::SessionID const&) | virtual void onMessage( const StreamAssignmentReportACK&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xc812(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x242b3(%rip), %rsi # 0x59af0
leaq 0xab86(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3586e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x3586e
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3587b
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::PartyEntitlementsRequest const&, FIX::SessionID const&) | virtual void onMessage( const PartyEntitlementsReport&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xbed2(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x23973(%rip), %rsi # 0x59af0
leaq 0xa246(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x361ae
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x361ae
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x361bb
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::PartyDetailsDefinitionRequest const&, FIX::SessionID const&) | virtual void onMessage( const PartyDetailsDefinitionRequest&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xbd16(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x237b7(%rip), %rsi # 0x59af0
leaq 0xa08a(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3636a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x3636a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x36377
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::PartyDetailsDefinitionRequestAck const&, FIX::SessionID const&) | virtual void onMessage( const PartyDetailsDefinitionRequestAck&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xbc82(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x23723(%rip), %rsi # 0x59af0
leaq 0x9ff6(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x363fe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x363fe
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3640b
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::PartyEntitlementsDefinitionRequest const&, FIX::SessionID const&) | virtual void onMessage( const PartyEntitlementsDefinitionRequestAck&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xbb5a(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x235fb(%rip), %rsi # 0x59af0
leaq 0x9ece(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x36526
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x36526
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x36533
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::TradeMatchReport const&, FIX::SessionID const&) | virtual void onMessage( const TradeMatchReport&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xba32(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x234d3(%rip), %rsi # 0x59af0
leaq 0x9da6(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3664e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x3664e
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3665b
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::MarketDataStatisticsReport const&, FIX::SessionID const&) | virtual void onMessage( const MarketDataStatisticsReport&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xb2ae(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x22d4f(%rip), %rsi # 0x59af0
leaq 0x9622(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x36dd2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x36dd2
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x36ddf
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::TradeAggregationRequest const&, FIX::SessionID const&) | virtual void onMessage( const TradeAggregationReport&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xaea2(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x22943(%rip), %rsi # 0x59af0
leaq 0x9216(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x371de
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x371de
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x371eb
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::TradeAggregationReport const&, FIX::SessionID const&) | virtual void onMessage( const TradeAggregationReport&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xae0e(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x228af(%rip), %rsi # 0x59af0
leaq 0x9182(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x37272
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x37272
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3727f
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIX50SP2::MessageCracker::onMessage(FIX50SP2::PayManagementReport const&, FIX::SessionID const&) | virtual void onMessage( const PayManagementReportAck&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xad7a(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x2281b(%rip), %rsi # 0x59af0
leaq 0x90ee(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x37306
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x37306
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x37313
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fix50sp2/MessageCracker.h |
FIXT11::MessageCracker::onMessage(FIXT11::Message const&, FIX::SessionID const&) | virtual void onMessage( Message&, const FIX::SessionID& )
{ throw FIX::UnsupportedMessageType(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x50, %edi
callq 0x1e100
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa9e2(%rip), %rdx # 0x42029
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ed40
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x40336
xorl %ebp, %ebp
leaq 0x22483(%rip), %rsi # 0x59af0
leaq 0x8d56(%rip), %rdx # 0x403ca
movq %rbx, %rdi
callq 0x1e2b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3769e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1e200
jmp 0x3769e
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x376ab
movq %rbx, %rdi
callq 0x1e180
movq %r14, %rdi
callq 0x1e2c0
nop
| /quickfix[P]quickfix/include/quickfix/fixt11/MessageCracker.h |
iu_iuRenameParamTest_x_iutest_x_Test_Test::Body() | IUTEST_P(iuRenameParamTest, Test)
{
if( GetParam() )
{
IUTEST_ASSERT_STREQ("Test/true", ::iutest::UnitTest::GetInstance()->current_test_info()->name());
}
else
{
IUTEST_ASSERT_STREQ("Test/false", ::iutest::UnitTest::GetInstance()->current_test_info()->name());
}
} | pushq %rbx
subq $0x1f0, %rsp # imm = 0x1F0
callq 0x16176
cmpb $0x1, (%rax)
jne 0x14f39
callq 0x1a60e
movq 0x21834(%rip), %rax # 0x366d0
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %r8
leaq 0x14252(%rip), %rsi # 0x29100
leaq 0x14257(%rip), %rdx # 0x2910c
leaq 0x1428f(%rip), %rcx # 0x2914b
leaq 0x21445(%rip), %r9 # 0x36308
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x161fb
cmpb $0x0, 0x20(%rbx)
jne 0x15016
leaq 0x68(%rsp), %rbx
movl $0x188, %edx # imm = 0x188
movq %rbx, %rdi
xorl %esi, %esi
callq 0x14190
movq %rbx, %rdi
callq 0x21b40
movq 0x10(%rsp), %rsi
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x15f1c
leaq 0x14244(%rip), %rax # 0x29155
leaq 0x38(%rsp), %rdi
movq %rax, 0x20(%rdi)
movabsq $0x200000026, %rax # imm = 0x200000026
movq %rax, 0x28(%rdi)
leaq 0x68(%rsp), %rsi
xorl %edx, %edx
callq 0x20978
jmp 0x14fdd
callq 0x1a60e
movq 0x2178b(%rip), %rax # 0x366d0
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %r8
leaq 0x14262(%rip), %rsi # 0x291b9
leaq 0x141ae(%rip), %rdx # 0x2910c
leaq 0x14261(%rip), %rcx # 0x291c6
leaq 0x2139c(%rip), %r9 # 0x36308
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x161fb
cmpb $0x0, 0x20(%rbx)
jne 0x15016
leaq 0x68(%rsp), %rbx
movl $0x188, %edx # imm = 0x188
movq %rbx, %rdi
xorl %esi, %esi
callq 0x14190
movq %rbx, %rdi
callq 0x21b40
movq 0x10(%rsp), %rsi
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x15f1c
leaq 0x1419b(%rip), %rax # 0x29155
leaq 0x38(%rsp), %rdi
movq %rax, 0x20(%rdi)
movabsq $0x20000002a, %rax # imm = 0x20000002A
movq %rax, 0x28(%rdi)
leaq 0x68(%rsp), %rsi
xorl %edx, %edx
callq 0x20978
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14ff8
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x142c0
leaq 0x208f9(%rip), %rsi # 0x358f8
leaq 0x68(%rsp), %rdi
callq 0x14230
leaq 0xe8(%rsp), %rdi
callq 0x140d0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15031
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x142c0
addq $0x1f0, %rsp # imm = 0x1F0
popq %rbx
retq
jmp 0x1503c
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15061
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x142c0
jmp 0x15061
jmp 0x1505e
movq %rax, %rbx
leaq 0x20890(%rip), %rsi # 0x358f8
leaq 0x68(%rsp), %rdi
callq 0x14230
leaq 0xe8(%rsp), %rdi
callq 0x140d0
jmp 0x15086
jmp 0x15083
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x150a1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x142c0
movq %rbx, %rdi
callq 0x14510
| /srz-zumix[P]iutest/test/param_test_name_tests.cpp |
iutest::detail::iuConsole::color_output(iutest::detail::iuConsole::Color, char const*, ...) | inline void iuConsole::color_output(Color color, const char *fmt, ...)
{
va_list va;
va_start(va, fmt);
if( IsShouldUseColor(true) )
{
color_output_impl(color, fmt, va);
}
else
{
voutput(fmt, va);
}
va_end(va);
} | pushq %rbp
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x15a66
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rsp)
callq 0x19d0c
testb $0x1, 0x1(%rax)
jne 0x15ab3
callq 0x19d0c
testb $0x2, 0x1(%rax)
jne 0x15ae0
movb 0x20886(%rip), %al # 0x36328
testb %al, %al
je 0x15b2a
testb $0x1, 0x2086f(%rip) # 0x36320
je 0x15ae0
addl $0x30, %ebp
leaq 0x13804(%rip), %rdi # 0x292c1
movl %ebp, %esi
xorl %eax, %eax
callq 0x19e4a
movq 0x20863(%rip), %rdi # 0x36330
testq %rdi, %rdi
je 0x15afa
movq (%rdi), %rax
movq %rsp, %rdx
movq %rbx, %rsi
callq *0x18(%rax)
jmp 0x15b05
movq 0x20849(%rip), %rdi # 0x36330
testq %rdi, %rdi
je 0x15b1d
movq (%rdi), %rax
movq %rsp, %rdx
movq %rbx, %rsi
callq *0x18(%rax)
jmp 0x15b13
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x142d0
leaq 0x137be(%rip), %rdi # 0x292ca
xorl %eax, %eax
callq 0x19e4a
addq $0xd8, %rsp
popq %rbx
popq %rbp
retq
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x142d0
jmp 0x15b13
leaq 0x207f7(%rip), %rdi # 0x36328
callq 0x14540
testl %eax, %eax
je 0x15aaa
callq 0x19d2a
movb %al, 0x207d7(%rip) # 0x36320
leaq 0x207d8(%rip), %rdi # 0x36328
callq 0x141e0
jmp 0x15aaa
movq %rax, %rbx
leaq 0x207c4(%rip), %rdi # 0x36328
callq 0x141d0
movq %rbx, %rdi
callq 0x14510
nop
| /srz-zumix[P]iutest/include/internal/iutest_console.hpp |
iutest::AssertionResult iutest::internal::CmpHelperSTREQ<char const*, char const*>(char const*, char const*, char const*, char const*, iutest_type_traits::enable_if<!detail::is_integral<char const*>::value || !detail::is_pointer<char const*>::value, void>::type*&) | inline AssertionResult IUTEST_ATTRIBUTE_UNUSED_ CmpHelperSTREQ(
const char* expr1, const char* expr2
, T1 val1, T2 val2, typename detail::enable_if<
!detail::is_integral<T1>::value || !detail::is_pointer<T2>::value, void>::type*& = detail::enabler::value)
{
if IUTEST_COND_LIKELY( StrEqHelper::Compare(val1, val2) )
{
return AssertionSuccess();
}
return EqFailure(expr1, expr2
, detail::ShowStringQuoted(FormatForComparisonFailureMessage(val1, val2))
, detail::ShowStringQuoted(FormatForComparisonFailureMessage(val2, val1)));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
testq %rcx, %rcx
sete %al
testq %r8, %r8
sete %cl
orb %al, %cl
je 0x16240
cmpq %r12, %r13
je 0x16343
jmp 0x16277
movq %r13, %rdi
callq 0x14120
movq %rax, %rbp
movq %r12, %rdi
callq 0x14120
cmpq %rax, %rbp
jne 0x16277
testq %rbp, %rbp
je 0x16343
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x142e0
testl %eax, %eax
je 0x16343
leaq 0x78(%rsp), %r12
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x26b8c
leaq 0x58(%rsp), %rdi
movq %r12, %rsi
callq 0x27aa3
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x26b8c
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x27aa3
leaq 0x58(%rsp), %rcx
leaq 0x38(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x2783d
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x162ea
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x142c0
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16305
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x142c0
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16320
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x142c0
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1635a
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x142c0
jmp 0x1635a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movb $0x1, 0x20(%rbx)
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16392
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x142c0
jmp 0x16392
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x163b2
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x142c0
jmp 0x163b2
movq %rax, %rbx
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x163d2
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x142c0
jmp 0x163d2
movq %rax, %rbx
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x163f3
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x142c0
movq %rbx, %rdi
callq 0x14510
nop
| /srz-zumix[P]iutest/include/internal/../iutest_assertion.hpp |
iutest::DefaultXmlGeneratorListener::~DefaultXmlGeneratorListener() | virtual ~DefaultXmlGeneratorListener()
{
FileClose();
TestEnv::event_listeners().set_default_xml_generator(NULL);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1d122(%rip), %rax # 0x34e70
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x17d7e
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x1e971(%rip), %rdi # 0x366d8
testq %rdi, %rdi
je 0x17d76
movq 0x48(%rbx), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x48(%rbx)
callq 0x19ef6
movq %rax, %r14
movq %rax, %rdi
addq $0xe8, %rdi
movq 0x110(%rax), %rsi
callq 0x1d5c0
testq %rax, %rax
je 0x17daa
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq $0x0, 0x110(%r14)
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x17dcd
movq (%rax), %rsi
incq %rsi
callq 0x142c0
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x17dec
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x142c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x1a256
| /srz-zumix[P]iutest/include/listener/iutest_default_xml_generator.hpp |
iutest::TestEnv::Variable::Variable() | Variable()
: m_random_seed(0)
, m_current_random_seed(0)
, m_before_origin_random_seed(0)
, m_repeat_count(1)
, m_testpartresult_reporter(NULL)
{} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movaps 0xf0b2(%rip), %xmm0 # 0x29030
movups %xmm0, (%rdi)
leaq 0x28(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movb %al, 0x28(%rdi)
leaq 0x48(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movq %rcx, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movb %al, 0x48(%rdi)
leaq 0x68(%rdi), %r13
movq %r13, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0x90(%rdi), %rbp
movq %rbp, 0x80(%rdi)
movq %rax, 0x88(%rdi)
movb %al, 0x90(%rdi)
leaq 0xb0(%rdi), %r14
movq %r14, 0xa0(%rdi)
movq %rax, 0xa8(%rdi)
movb %al, 0xb0(%rdi)
addq $0xc0, %rdi
movaps 0xf042(%rip), %xmm0 # 0x29040
movups %xmm0, 0xc0(%rbx)
callq 0x1a262
leaq 0xd0(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%rbx)
movq $0x0, 0xe0(%rbx)
leaq 0x1acc3(%rip), %r12 # 0x34cf0
movq %r12, 0xe8(%rbx)
leaq 0x120(%rbx), %rdi
movups %xmm0, 0xf0(%rbx)
movups %xmm0, 0x100(%rbx)
movups %xmm0, 0x110(%rbx)
callq 0x14200
leaq 0x2b8(%rbx), %rax
movq %rax, 0x2a8(%rbx)
movq $0x0, 0x2b0(%rbx)
movb $0x0, 0x2b8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%rsp)
movq %r12, 0xe8(%rbx)
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0x1a0aa
movq 0x100(%rbx), %rsi
subq %rdi, %rsi
callq 0x142c0
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1a0c7
movq 0xe0(%rbx), %rsi
subq %rdi, %rsi
callq 0x142c0
jmp 0x1a0c7
movq %rax, (%rsp)
movq 0xa0(%rbx), %rdi
cmpq %r14, %rdi
je 0x1a0de
movq (%r14), %rsi
incq %rsi
callq 0x142c0
movq 0x80(%rbx), %rdi
cmpq %rbp, %rdi
je 0x1a0f6
movq (%rbp), %rsi
incq %rsi
callq 0x142c0
movq 0x58(%rbx), %rdi
cmpq %r13, %rdi
je 0x1a10b
movq (%r13), %rsi
incq %rsi
callq 0x142c0
movq 0x38(%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x1a126
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x142c0
movq 0x18(%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x1a141
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x142c0
movq (%rsp), %rdi
callq 0x14510
| /srz-zumix[P]iutest/include/internal/../internal/../iutest_env.hpp |
iutest::StdioFile::OpenImpl(char const*, int) | virtual bool OpenImpl(const char* filename, int mode) IUTEST_CXX_OVERRIDE
{
Close();
switch( mode )
{
case IFile::OpenRead:
m_fp = internal::posix::FileOpen(filename, "rb");
break;
case IFile::OpenWrite:
m_fp = internal::posix::FileOpen(filename, "wb");
break;
case IFile::OpenAppend:
m_fp = internal::posix::FileOpen(filename, "ab");
break;
default:
break;
}
return m_fp != NULL;
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x20(%rax)
cmpl $0x1, %ebp
je 0x1c187
cmpl $0x2, %ebp
je 0x1c17e
cmpl $0x3, %ebp
jne 0x1c19c
leaq 0xd45a(%rip), %rsi # 0x295d6
jmp 0x1c18e
leaq 0xd44e(%rip), %rsi # 0x295d3
jmp 0x1c18e
leaq 0xd442(%rip), %rsi # 0x295d0
movq %r14, %rdi
callq 0x14320
movq %rax, 0x10(%rbx)
jmp 0x1c1a0
movq 0x10(%rbx), %rax
testq %rax, %rax
setne %al
popq %rbx
popq %r14
popq %rbp
retq
nop
| /srz-zumix[P]iutest/include/internal/../internal/../impl/../internal/iutest_file.hpp |
iutest::detail::StringFormat[abi:cxx11](char const*, __va_list_tag*) | inline ::std::string StringFormat(const char* format, va_list va)
{
size_t n = strlen(format) * 2 + 1;
{
va_list va2;
iu_va_copy(va2, va); // cppcheck-suppress va_list_usedBeforeStarted
const int ret = iu_vsnprintf(NULL, 0u, format, va2);
va_end(va2);
if( ret > 0 )
{
n = static_cast<size_t>(ret + 1);
}
}
for( ;; )
{
char* dst = new char[n];
va_list va2;
iu_va_copy(va2, va); // cppcheck-suppress va_list_usedBeforeStarted
const int written = iu_vsnprintf(dst, n, format, va2);
va_end(va2);
if( written < 0 )
{
#if defined(EOVERFLOW)
if( errno == EOVERFLOW )
{
break;
}
#endif
#if defined(E2BIG)
if( errno == E2BIG )
{
break;
}
#endif
}
else if( static_cast<size_t>(written) < n )
{
::std::string s = ::std::string(dst, static_cast<size_t>(written));
delete[] dst;
return s;
}
delete[] dst;
n *= 2;
}
return "";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x14120
leaq 0x1(,%rax,2), %rbp
movq 0x10(%r14), %rax
movq %rsp, %r12
movq %rax, 0x10(%r12)
movups (%r14), %xmm0
movaps %xmm0, (%r12)
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x141c0
leal 0x1(%rax), %r13d
testl %eax, %eax
cmovleq %rbp, %r13
movq %r13, %rdi
callq 0x14030
movq %rax, %rbp
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x141c0
testl %eax, %eax
js 0x1c379
movl %eax, %eax
cmpq %rax, %r13
jbe 0x1c38a
jmp 0x1c3b2
callq 0x14040
movl (%rax), %eax
cmpl $0x7, %eax
je 0x1c397
cmpl $0x4b, %eax
je 0x1c397
movq %rbp, %rdi
callq 0x143a0
addq %r13, %r13
jmp 0x1c33f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xed11(%rip), %rdx # 0x2b0b6
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x1bc24
jmp 0x1c3d2
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbp, %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x1bc24
movq %rbp, %rdi
callq 0x143a0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /srz-zumix[P]iutest/include/internal/iutest_string.hpp |
iutest::DefaultXmlGeneratorListener::DefaultXmlGeneratorListener(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | explicit DefaultXmlGeneratorListener(const ::std::string& path)
: m_fp(NULL)
{
SetFilePath(path);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
leaq 0x1782b(%rip), %rax # 0x34e70
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r14
movq %r14, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %r13
movq %r13, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
movq %rax, 0x48(%rdi)
callq 0x1d810
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r12
movq 0x28(%r15), %rdi
cmpq %r13, %rdi
je 0x1d697
movq (%r13), %rsi
incq %rsi
callq 0x142c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14a8c
movq %r12, %rdi
callq 0x14510
| /srz-zumix[P]iutest/include/listener/iutest_default_xml_generator.hpp |
iutest::detail::BasicSocket::Open(char const*, char const*) | bool Open(const char* host, const char* port)
{
if( m_socket != INVALID_DESCRIPTOR )
{
return true;
}
addrinfo* servinfo = NULL;
addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
const int err_no = getaddrinfo(host, port, &hints, &servinfo);
if( err_no != 0 )
{
return false;
}
for( addrinfo* curr=servinfo; curr != NULL; curr = curr->ai_next )
{
const descriptor_t fd = socket(curr->ai_family, curr->ai_socktype, curr->ai_protocol);
if( fd != INVALID_DESCRIPTOR )
{
if( connect(fd, curr->ai_addr, static_cast<length_t>(curr->ai_addrlen)) != -1 )
{
m_socket = fd;
break;
}
Close(fd);
}
}
freeaddrinfo(servinfo);
return (m_socket != INVALID_DESCRIPTOR);
} | movb $0x1, %al
cmpl $-0x1, (%rdi)
je 0x1ddd2
retq
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rcx
movq $0x0, (%rcx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movl $0x1, 0x8(%rax)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x14390
testl %eax, %eax
je 0x1de19
xorl %eax, %eax
jmp 0x1de6e
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x1de5e
movl 0x4(%r14), %edi
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
callq 0x14080
cmpl $-0x1, %eax
je 0x1de56
movl %eax, %ebp
movq 0x18(%r14), %rsi
movl 0x10(%r14), %edx
movl %eax, %edi
callq 0x14260
cmpl $-0x1, %eax
jne 0x1de5c
movl %ebp, %edi
callq 0x14570
movq 0x28(%r14), %r14
jmp 0x1de1e
movl %ebp, (%rbx)
movq 0x8(%rsp), %rdi
callq 0x143b0
cmpl $-0x1, (%rbx)
setne %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
| /srz-zumix[P]iutest/include/listener/../internal/iutest_socket.hpp |
iutest::detail::iuOptionMessage::ShowFeature() | inline void iuOptionMessage::ShowFeature()
{
#if 0
IIUT_SHOW_FEATURE_MACROS(IIUT_SHOW_MACRO);
#else
IIUT_SHOW_FEATURE_MACROS(IIUT_SHOW_ENABLE_MACRO);
IIUT_SHOW_FEATURE_MACROS(IIUT_SHOW_DISABLE_MACRO);
#endif
} | pushq %r14
pushq %rbx
pushq %rax
leaq 0xbe45(%rip), %rbx # 0x2a0e8
leaq 0xbe4e(%rip), %rsi # 0x2a0f8
leaq 0xc711(%rip), %r14 # 0x2a9c2
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbe4d(%rip), %rsi # 0x2a112
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbe5f(%rip), %rsi # 0x2a138
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbe67(%rip), %rsi # 0x2a154
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbe75(%rip), %rsi # 0x2a176
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbe74(%rip), %rsi # 0x2a189
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbe72(%rip), %rsi # 0x2a19b
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbe73(%rip), %rsi # 0x2a1b0
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbe75(%rip), %rsi # 0x2a1c6
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbe74(%rip), %rsi # 0x2a1d9
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbe74(%rip), %rsi # 0x2a1ed
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbe83(%rip), %rsi # 0x2a210
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbe87(%rip), %rsi # 0x2a228
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbe92(%rip), %rsi # 0x2a247
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbea4(%rip), %rsi # 0x2a26d
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbeac(%rip), %rsi # 0x2a289
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbeb5(%rip), %rsi # 0x2a2a6
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbeba(%rip), %rsi # 0x2a2bf
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbec2(%rip), %rsi # 0x2a2db
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbec1(%rip), %rsi # 0x2a2ee
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbec1(%rip), %rsi # 0x2a302
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbeca(%rip), %rsi # 0x2a31f
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbecc(%rip), %rsi # 0x2a335
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbee3(%rip), %rsi # 0x2a360
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbedf(%rip), %rsi # 0x2a370
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbee1(%rip), %rsi # 0x2a386
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbee2(%rip), %rsi # 0x2a39b
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbeea(%rip), %rsi # 0x2a3b7
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbeea(%rip), %rsi # 0x2a3cb
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbeee(%rip), %rsi # 0x2a3e3
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbeeb(%rip), %rsi # 0x2a3f4
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbef1(%rip), %rsi # 0x2a40e
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbeef(%rip), %rsi # 0x2a420
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbef9(%rip), %rsi # 0x2a43e
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbefe(%rip), %rsi # 0x2a457
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf0a(%rip), %rsi # 0x2a477
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf0f(%rip), %rsi # 0x2a490
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf15(%rip), %rsi # 0x2a4aa
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf1a(%rip), %rsi # 0x2a4c3
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf2c(%rip), %rsi # 0x2a4e9
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf32(%rip), %rsi # 0x2a503
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf3b(%rip), %rsi # 0x2a520
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf3d(%rip), %rsi # 0x2a536
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf41(%rip), %rsi # 0x2a54e
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf42(%rip), %rsi # 0x2a563
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf4a(%rip), %rsi # 0x2a57f
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf53(%rip), %rsi # 0x2a59c
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf5a(%rip), %rsi # 0x2a5b7
leaq 0xac8e(%rip), %r14 # 0x292f2
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf56(%rip), %rsi # 0x2a5ce
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf51(%rip), %rsi # 0x2a5dd
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf51(%rip), %rsi # 0x2a5f1
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19e4a
| /srz-zumix[P]iutest/include/internal/iutest_option_message.hpp |
iutest::detail::iuOptionMessage::ShowSpec() | inline void iuOptionMessage::ShowSpec()
{
IIUT_SHOW_MACRO(IUTEST_PLATFORM);
IIUT_SHOW_MACRO(IUTEST_CHECK_STRICT);
IIUT_SHOW_MACRO(IUTEST_CPLUSPLUS);
IIUT_SHOW_MACRO(IUTEST_FORCE_COLORCONSOLE);
IIUT_SHOW_MACRO(IUTEST_HAS_ANALYSIS_ASSUME);
IIUT_SHOW_MACRO(IUTEST_HAS_ATTRIBUTE);
IIUT_SHOW_MACRO(IUTEST_HAS_ATTRIBUTE_DEPRECATED);
IIUT_SHOW_MACRO(IUTEST_HAS_ATTRIBUTE_LIKELY_UNLIKELY);
IIUT_SHOW_MACRO(IUTEST_HAS_AUTO);
IIUT_SHOW_MACRO(IUTEST_HAS_CATCH_SEH_EXCEPTION_ASSERTION);
IIUT_SHOW_MACRO(IUTEST_HAS_CHAR16_T);
IIUT_SHOW_MACRO(IUTEST_HAS_CHAR16_T_PRINTABLE);
IIUT_SHOW_MACRO(IUTEST_HAS_CHAR32_T);
IIUT_SHOW_MACRO(IUTEST_HAS_CHAR32_T_PRINTABLE);
IIUT_SHOW_MACRO(IUTEST_HAS_CLOCK);
IIUT_SHOW_MACRO(IUTEST_HAS_COLORCONSOLE);
IIUT_SHOW_MACRO(IUTEST_HAS_CONCEPTS);
IIUT_SHOW_MACRO(IUTEST_HAS_CONSTEXPR);
IIUT_SHOW_MACRO(IUTEST_HAS_CONSTEXPR_IF);
IIUT_SHOW_MACRO(IUTEST_HAS_COUNTER_MACRO);
IIUT_SHOW_MACRO(IUTEST_HAS_CTIME);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX_HDR_ANY);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX_HDR_ARRAY);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX_HDR_CHARCONV);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX_HDR_CHRONO);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX_HDR_CODECVT);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX_HDR_CSTDINT);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX_HDR_CUCHAR);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX_HDR_FILESYSTEM);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX_HDR_OPTIONAL);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX_HDR_RANDOM);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX_HDR_REGEX);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX_HDR_STRING_VIEW);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX_HDR_TYPE_TARITS);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX_HDR_VARIANT);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX_HDR_VERSION);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX11);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX14);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX1Z);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX17);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX2A);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX20);
IIUT_SHOW_MACRO(IUTEST_HAS_CXX2B);
IIUT_SHOW_MACRO(IUTEST_HAS_DECLTYPE);
IIUT_SHOW_MACRO(IUTEST_HAS_DEFAULT_FUNCTIONS);
IIUT_SHOW_MACRO(IUTEST_HAS_DELETED_FUNCTIONS);
IIUT_SHOW_MACRO(IUTEST_HAS_EXCEPTIONS);
IIUT_SHOW_MACRO(IUTEST_HAS_EXPLICIT_CONVERSION);
IIUT_SHOW_MACRO(IUTEST_HAS_EXTERN_TEMPLATE);
IIUT_SHOW_MACRO(IUTEST_HAS_FD_DUP);
IIUT_SHOW_MACRO(IUTEST_HAS_FILENO);
IIUT_SHOW_MACRO(IUTEST_HAS_FILE_STAT);
IIUT_SHOW_MACRO(IUTEST_HAS_FLOAT128);
IIUT_SHOW_MACRO(IUTEST_HAS_FOPEN);
IIUT_SHOW_MACRO(IUTEST_HAS_GETTIMEOFDAY);
IIUT_SHOW_MACRO(IUTEST_HAS_HDR_CXXABI);
IIUT_SHOW_MACRO(IUTEST_HAS_HDR_SYSTIME);
IIUT_SHOW_MACRO(IUTEST_HAS_IF_EXISTS);
IIUT_SHOW_MACRO(IUTEST_HAS_INITIALIZER_LIST);
IIUT_SHOW_MACRO(IUTEST_HAS_INLINE_VARIABLE);
IIUT_SHOW_MACRO(IUTEST_HAS_INT128);
IIUT_SHOW_MACRO(IUTEST_HAS_IOMANIP);
IIUT_SHOW_MACRO(IUTEST_HAS_LAMBDA);
IIUT_SHOW_MACRO(IUTEST_HAS_LAMBDA_STATEMENTS);
IIUT_SHOW_MACRO(IUTEST_HAS_LARGEFILE_API);
IIUT_SHOW_MACRO(IUTEST_HAS_LONG_DOUBLE);
IIUT_SHOW_MACRO(IUTEST_HAS_MKSTEMP);
IIUT_SHOW_MACRO(IUTEST_HAS_MOVE_ASSIGNMENT_DEFAULT_FUNCTION);
IIUT_SHOW_MACRO(IUTEST_HAS_NOEXCEPT);
IIUT_SHOW_MACRO(IUTEST_HAS_NULLPTR);
IIUT_SHOW_MACRO(IUTEST_HAS_OVERRIDE_AND_FINAL);
IIUT_SHOW_MACRO(IUTEST_HAS_RTTI);
IIUT_SHOW_MACRO(IUTEST_HAS_RVALUE_REFS);
IIUT_SHOW_MACRO(IUTEST_HAS_SEH);
IIUT_SHOW_MACRO(IUTEST_HAS_STD_BEGIN_END);
IIUT_SHOW_MACRO(IUTEST_HAS_STD_DECLVAL);
IIUT_SHOW_MACRO(IUTEST_HAS_STD_EMPLACE);
IIUT_SHOW_MACRO(IUTEST_HAS_STD_FILESYSTEM);
IIUT_SHOW_MACRO(IUTEST_HAS_STD_QUICK_EXIT);
IIUT_SHOW_MACRO(IUTEST_HAS_STD_STR_TO_VALUE);
IIUT_SHOW_MACRO(IUTEST_HAS_STD_TO_CHARS);
IIUT_SHOW_MACRO(IUTEST_HAS_STRINGSTREAM);
IIUT_SHOW_MACRO(IUTEST_HAS_STRONG_ENUMS);
IIUT_SHOW_MACRO(IUTEST_HAS_STRSTREAM);
IIUT_SHOW_MACRO(IUTEST_HAS_TUPLE);
IIUT_SHOW_MACRO(IUTEST_HAS_VARIADIC_TEMPLATES);
IIUT_SHOW_MACRO(IUTEST_HAS_VARIADIC_TEMPLATE_TEMPLATES);
IIUT_SHOW_MACRO(IUTEST_HAS_VARIADIC_TUPLES);
IIUT_SHOW_MACRO(IUTEST_HAS_WANT_SECURE_LIB);
IIUT_SHOW_MACRO(IUTEST_LONG_DOUBLE_AS_IS_DOUBLE);
IIUT_SHOW_MACRO(IUTEST_UNICODE);
IIUT_SHOW_MACRO(IUTEST_USE_OWN_LIST);
IIUT_SHOW_MACRO(IUTEST_USE_OWN_STRING_VIEW);
IIUT_SHOW_MACRO(IUTEST_USE_THROW_ON_ASSERTION_FAILURE);
IIUT_SHOW_MACRO(IUTEST_WCHAR_UNSIGNED);
#ifdef IUTEST_LIBSTDCXX_VERSION
IIUT_SHOW_MACRO(IUTEST_LIBSTDCXX_VERSION);
#endif
#ifdef _MSC_FULL_VER
IIUT_SHOW_MACRO(_MSC_FULL_VER);
#endif
#ifdef _MSVC_LANG
IIUT_SHOW_MACRO(_MSVC_LANG);
#endif
#ifdef __GLIBCXX__
IIUT_SHOW_MACRO(__GLIBCXX__);
#endif
#ifdef __GLIBCPP__
IIUT_SHOW_MACRO(__GLIBCPP__);
#endif
#ifdef _GLIBCXX_USE_CXX11_ABI
IIUT_SHOW_MACRO(_GLIBCXX_USE_CXX11_ABI);
#endif
#ifdef _LIBCPP_VERSION
IIUT_SHOW_MACRO(_LIBCPP_VERSION);
#endif
#ifdef __POSIX_VISIBLE
IIUT_SHOW_MACRO(__POSIX_VISIBLE);
#endif
#ifdef __USE_MINGW_ANSI_STDIO
IIUT_SHOW_MACRO(__USE_MINGW_ANSI_STDIO);
#endif
#ifdef __MAC_OS_X_VERSION_MIN_REQUIRED
IIUT_SHOW_MACRO(__MAC_OS_X_VERSION_MIN_REQUIRED);
#endif
#undef IIUT_SHOW_MACRO
} | pushq %r15
pushq %r14
pushq %rbx
leaq 0xba28(%rip), %rbx # 0x2a0e8
leaq 0xbf50(%rip), %rsi # 0x2a617
leaq 0xbf59(%rip), %rdx # 0x2a627
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf50(%rip), %rsi # 0x2a62f
leaq 0xc2dc(%rip), %r14 # 0x2a9c2
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf49(%rip), %rsi # 0x2a643
leaq 0xbf53(%rip), %rdx # 0x2a654
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf4a(%rip), %rsi # 0x2a65c
leaq 0xabd9(%rip), %r15 # 0x292f2
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf49(%rip), %rsi # 0x2a676
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf50(%rip), %rsi # 0x2a691
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf51(%rip), %rsi # 0x2a6a6
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf5d(%rip), %rsi # 0x2a6c6
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf6e(%rip), %rsi # 0x2a6eb
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf6a(%rip), %rsi # 0x2a6fb
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf7f(%rip), %rsi # 0x2a724
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf7f(%rip), %rsi # 0x2a738
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf89(%rip), %rsi # 0x2a756
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf89(%rip), %rsi # 0x2a76a
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf93(%rip), %rsi # 0x2a788
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf90(%rip), %rsi # 0x2a799
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf94(%rip), %rsi # 0x2a7b1
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf94(%rip), %rsi # 0x2a7c5
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf95(%rip), %rsi # 0x2a7da
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf99(%rip), %rsi # 0x2a7f2
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf9e(%rip), %rsi # 0x2a80b
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf9b(%rip), %rsi # 0x2a81c
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbf9e(%rip), %rsi # 0x2a833
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbfa3(%rip), %rsi # 0x2a84c
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbfab(%rip), %rsi # 0x2a868
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbfb1(%rip), %rsi # 0x2a882
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbfb8(%rip), %rsi # 0x2a89d
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbfbf(%rip), %rsi # 0x2a8b8
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbfc5(%rip), %rsi # 0x2a8d2
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbfcf(%rip), %rsi # 0x2a8f0
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbfd7(%rip), %rsi # 0x2a90c
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbfdd(%rip), %rsi # 0x2a926
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbfe2(%rip), %rsi # 0x2a93f
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbfed(%rip), %rsi # 0x2a95e
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbff8(%rip), %rsi # 0x2a97d
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbfff(%rip), %rsi # 0x2a998
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc006(%rip), %rsi # 0x2a9b3
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc003(%rip), %rsi # 0x2a9c4
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc000(%rip), %rsi # 0x2a9d5
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbffd(%rip), %rsi # 0x2a9e6
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbffa(%rip), %rsi # 0x2a9f7
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbff7(%rip), %rsi # 0x2aa08
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbff4(%rip), %rsi # 0x2aa19
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbff1(%rip), %rsi # 0x2aa2a
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbff1(%rip), %rsi # 0x2aa3e
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbffa(%rip), %rsi # 0x2aa5b
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xb73b(%rip), %rsi # 0x2a1b0
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbfef(%rip), %rsi # 0x2aa78
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbffa(%rip), %rsi # 0x2aa97
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc001(%rip), %rsi # 0x2aab2
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbfff(%rip), %rsi # 0x2aac4
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbffd(%rip), %rsi # 0x2aad6
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbffe(%rip), %rsi # 0x2aaeb
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbffe(%rip), %rsi # 0x2aaff
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbffb(%rip), %rsi # 0x2ab10
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xbfff(%rip), %rsi # 0x2ab28
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc001(%rip), %rsi # 0x2ab3e
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc004(%rip), %rsi # 0x2ab55
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc005(%rip), %rsi # 0x2ab6a
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc00d(%rip), %rsi # 0x2ab86
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc014(%rip), %rsi # 0x2aba1
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc012(%rip), %rsi # 0x2abb3
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc011(%rip), %rsi # 0x2abc6
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc00f(%rip), %rsi # 0x2abd8
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc018(%rip), %rsi # 0x2abf5
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc01d(%rip), %rsi # 0x2ac0e
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc020(%rip), %rsi # 0x2ac25
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc01f(%rip), %rsi # 0x2ac38
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc037(%rip), %rsi # 0x2ac64
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc037(%rip), %rsi # 0x2ac78
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc036(%rip), %rsi # 0x2ac8b
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc040(%rip), %rsi # 0x2aca9
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc03c(%rip), %rsi # 0x2acb9
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc03f(%rip), %rsi # 0x2acd0
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc03a(%rip), %rsi # 0x2acdf
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc03f(%rip), %rsi # 0x2acf8
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc042(%rip), %rsi # 0x2ad0f
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc045(%rip), %rsi # 0x2ad26
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc04b(%rip), %rsi # 0x2ad40
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc051(%rip), %rsi # 0x2ad5a
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc059(%rip), %rsi # 0x2ad76
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc05d(%rip), %rsi # 0x2ad8e
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc061(%rip), %rsi # 0x2ada6
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc065(%rip), %rsi # 0x2adbe
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc066(%rip), %rsi # 0x2add3
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc063(%rip), %rsi # 0x2ade4
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc06d(%rip), %rsi # 0x2ae02
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc080(%rip), %rsi # 0x2ae29
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc087(%rip), %rsi # 0x2ae44
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc08e(%rip), %rsi # 0x2ae5f
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc09a(%rip), %rsi # 0x2ae7f
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc095(%rip), %rsi # 0x2ae8e
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc095(%rip), %rsi # 0x2aea2
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc09c(%rip), %rsi # 0x2aebd
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc0ae(%rip), %rsi # 0x2aee3
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x19e4a
leaq 0xc0b0(%rip), %rsi # 0x2aef9
leaq 0xc0c2(%rip), %rdx # 0x2af12
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19e4a
leaq 0xc0b7(%rip), %rsi # 0x2af18
leaq 0xc0bc(%rip), %rdx # 0x2af24
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19e4a
leaq 0xc0b4(%rip), %rsi # 0x2af2d
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x19e4a
nop
| /srz-zumix[P]iutest/include/internal/iutest_option_message.hpp |
iutest::detail::FormatCxxException[abi:cxx11](char const*) | inline ::std::string FormatCxxException(const char* description)
{
iu_stringstream strm;
if( description != NULL )
{
strm << "C++ exception with description \"" << description << "\"";
}
else
{
strm << "Unknown C++ exception";
}
return strm.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x14200
leaq 0x18(%rsp), %r14
testq %r15, %r15
je 0x208ff
leaq 0xa6be(%rip), %rsi # 0x2af8c
movl $0x20, %edx
movq %r14, %rdi
callq 0x14350
movq %r15, %rdi
callq 0x14120
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x14350
movl $0x1, %edx
leaq 0xa6ae(%rip), %rsi # 0x2afab
jmp 0x2090b
movl $0x15, %edx
leaq 0xa6a2(%rip), %rsi # 0x2afad
movq %r14, %rdi
callq 0x14350
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x14470
movq 0x15699(%rip), %rsi # 0x35fc0
leaq 0x8(%rsp), %rdi
callq 0x14230
leaq 0x88(%rsp), %rdi
callq 0x140d0
movq %rbx, %rax
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x15668(%rip), %rsi # 0x35fc0
leaq 0x8(%rsp), %rdi
callq 0x14230
leaq 0x88(%rsp), %rdi
callq 0x140d0
movq %rbx, %rdi
callq 0x14510
nop
| /srz-zumix[P]iutest/include/internal/iutest_exception.hpp |
iutest::AssertionHelper::OnFixed(iutest::AssertionHelper::Fixed const&, bool) | void OnFixed(const Fixed& fixed, bool isException = false)
{
// OnFixed で throw しないこと！テスト側の例外キャッチにかからなくなる
const ::std::string append_message = fixed.GetString();
if( !append_message.empty() )
{
m_part_result.add_message(" " + append_message);
}
ScopedTrace::GetInstance().append_message(m_part_result, isException);
if( TestEnv::GetGlobalTestPartResultReporter() != IUTEST_NULLPTR )
{
TestEnv::GetGlobalTestPartResultReporter()->ReportTestPartResult(m_part_result);
}
else
{
detail::DefaultReportTestPartResult(m_part_result);
}
if IUTEST_COND_UNLIKELY(m_part_result.failed()
&& TestFlag::IsEnableFlag(iutest::TestFlag::BREAK_ON_FAILURE))
{
IUTEST_BREAK();
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebp
movq %rdi, %rbx
addq $0x18, %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x14470
cmpq $0x0, 0x8(%r14)
je 0x209dd
leaq 0xa968(%rip), %rsi # 0x2b30c
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x20adc
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x140c0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x209dd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x142c0
callq 0x20b64
movzbl %bpl, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x20b82
callq 0x19ef6
cmpq $0x0, 0x118(%rax)
je 0x20a17
callq 0x19ef6
movq 0x118(%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
jmp 0x20a1f
movq %rbx, %rdi
callq 0x1adfc
movl 0x2c(%rbx), %ebx
callq 0x19d0c
cmpl $-0x1, %ebx
sete %cl
testl %ebx, %ebx
jg 0x20a3a
movb (%rax), %al
shrb $0x7, %al
andb %al, %cl
je 0x20a44
callq 0x19d0c
testb $0x10, (%rax)
jne 0x20a68
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20a5f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x142c0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
ud2
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20a8f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x142c0
jmp 0x20a8f
jmp 0x20a8c
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20aaa
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x142c0
movq %rbx, %rdi
callq 0x14510
| /srz-zumix[P]iutest/include/internal/../iutest_assertion.hpp |
iutest::AssertionHelper::ScopedTrace::append_message(iutest::TestPartResult&, bool) | void append_message(TestPartResult& part_result, bool isException)
{
if( !list.empty() || detail::UncaughtScopedTrace::Has() )
{
part_result.add_message("\niutest trace:");
// TODO : 追加メッセージとして保存するべき
// 現状はテスト結果のメッセージに追加している。
for( msg_list::iterator it = list.begin(), end=list.end(); it != end; ++it )
{
part_result.add_message("\n");
part_result.add_message((*it)->make_message().c_str());
}
if( isException )
{
part_result.add_message(detail::UncaughtScopedTrace::Get());
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, 0x30(%rsp)
cmpq %rdi, (%rdi)
je 0x20d21
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa410(%rip), %rsi # 0x2afc3
leaq 0xa417(%rip), %rdx # 0x2afd1
leaq 0x8(%rsp), %rdi
callq 0x1bc24
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x140c0
movl %ebp, 0x2c(%rsp)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x20bf1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x142c0
movq 0x30(%rsp), %rax
movq (%rax), %r12
cmpq %rax, %r12
je 0x20ce5
leaq 0x8(%rsp), %r13
leaq 0x38(%rsp), %rbp
movq %r15, 0x8(%rsp)
movq %r13, %rdi
leaq 0xa49a(%rip), %rsi # 0x2b0b5
leaq 0xa494(%rip), %rdx # 0x2b0b6
callq 0x1bc24
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x140c0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x20c50
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x142c0
movq 0x10(%r12), %r14
movq 0x20(%r14), %rsi
movl 0x28(%r14), %edx
movq %rbp, %rdi
callq 0x1b24f
movq %rbp, %rdi
leaq 0xac29(%rip), %rsi # 0x2b898
callq 0x14550
movq (%r14), %rsi
movq %rbp, %rdi
callq 0x14550
movq 0x38(%rsp), %rsi
movq %r13, %rdi
leaq 0x7(%rsp), %rdx
callq 0x15f1c
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x140c0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x20cba
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x142c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x20cd6
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x142c0
movq (%r12), %r12
cmpq 0x30(%rsp), %r12
jne 0x20c0c
cmpb $0x0, 0x2c(%rsp)
je 0x20d53
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x20df2
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x140c0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x20d53
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x142c0
jmp 0x20d53
movq 0x159a8(%rip), %rax # 0x366d0
testq %rax, %rax
je 0x20d53
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x20d53
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x20d53
movq 0xa0(%rax), %rcx
cmpq 0xa8(%rax), %rcx
jne 0x20ba3
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20d6d
jmp 0x20d6d
jmp 0x20d68
movq %rax, %rbx
jmp 0x20dbe
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x20dbe
movq 0x18(%rsp), %rsi
jmp 0x20db6
jmp 0x20d9f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x20da2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x142c0
jmp 0x20da2
movq %rax, %rbx
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x20dbe
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x142c0
movq %rbx, %rdi
callq 0x14510
| /srz-zumix[P]iutest/include/internal/../iutest_assertion.hpp |
iutest::detail::ParamTestInstance<iu_iuRenameParamTest_x_iutest_x_Test_Test>::MakeTestSuite(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void*, void (*)(), void (*)()) const | virtual TestSuite* MakeTestSuite(const ::std::string& testsuite_name, TestTypeId id
, SetUpMethod setup, TearDownMethod teardown) const IUTEST_CXX_OVERRIDE
{
#if !defined(IUTEST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)
return UnitTest::instance().AddTestSuite<TestSuite>(testsuite_name, id, setup, teardown);
#else
return UnitTest::instance().AddTestSuite(
testsuite_name, id, setup, teardown, detail::explicit_type<TestSuite>());
#endif
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
callq 0x1a60e
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21078
| /srz-zumix[P]iutest/include/iutest_param_tests.hpp |
iutest::detail::iuPool::push(iutest::detail::iuIObject*) | void push(value_ptr ptr) { m_pool.push_back(ptr); } | pushq %rax
movq %rsi, %rax
movq %rsi, (%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x214be
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x214c6
movq %rsp, %rdx
callq 0x21db2
popq %rax
retq
| /srz-zumix[P]iutest/include/internal/iutest_pool.hpp |
iutest::detail::iuParamTestFactory<iu_iuRenameParamTest_x_iutest_x_Test_Test>::~iuParamTestFactory() | class iuParamTestFactory IUTEST_CXX_FINAL : public iuParamTestFactoryBase<typename Tester::ParamType>
{
typedef typename Tester::ParamType ParamType;
typedef iuParamTestFactoryBase<ParamType> _Mybase;
public:
iuParamTestFactory() IUTEST_CXX_DEFAULT_FUNCTION
explicit iuParamTestFactory(ParamType param) : _Mybase(param) {}
public:
virtual auto_ptr<Test> Create() IUTEST_CXX_OVERRIDE
{
Tester::SetParam(&this->m_param);
auto_ptr<Test> p( new Tester() );
return p;
} | movl $0x10, %esi
jmp 0x142c0
| /srz-zumix[P]iutest/include/internal/../internal/iutest_factory.hpp |
iutest::TestInfo::Mediator::HasNonfatalFailure() const | TestInfo* ptr() const IUTEST_CXX_NOEXCEPT_SPEC { return m_test_info; } | movq 0x8(%rdi), %rax
movq 0x40(%rax), %rdx
movq 0x48(%rax), %rcx
cmpq %rcx, %rdx
je 0x219af
addq $0x30, %rdx
cmpl $0x1, -0x4(%rdx)
sete %al
je 0x219ae
leaq 0x30(%rdx), %rsi
cmpq %rcx, %rdx
movq %rsi, %rdx
jne 0x21999
retq
xorl %eax, %eax
retq
| /srz-zumix[P]iutest/include/internal/../internal/iutest_mediator.hpp |
iutest::detail::iuPool::~iuPool() | ~iuPool()
{
// すべて解放する
for( pool::iterator it=m_pool.begin(); it != m_pool.end(); )
{
value_ptr p = *it;
it = m_pool.erase(it);
delete p;
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rbx
movq 0x8(%rdi), %rdx
cmpq %rdx, %rbx
je 0x21d86
leaq 0x8(%rbx), %r15
movq (%rbx), %r12
cmpq %rdx, %r15
je 0x21d63
subq %r15, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14490
movq 0x8(%r14), %rdx
addq $-0x8, %rdx
movq %rdx, 0x8(%r14)
testq %r12, %r12
je 0x21d7e
movq (%r12), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq 0x8(%r14), %rdx
cmpq %rdx, %rbx
jne 0x21d49
movq (%r14), %rbx
testq %rbx, %rbx
je 0x21da5
movq 0x10(%r14), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x142c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /srz-zumix[P]iutest/include/internal/iutest_pool.hpp |
iuRenameParamTest::MakeTestParamName[abi:cxx11](iutest::TestParamInfo<bool> const&) | static const ::std::string MakeTestParamName(const iutest::TestParamInfo<bool>& info)
{
return ::iutest::StreamableToString(info.param);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x21b40
movq %r15, %rdi
movq %r14, %rsi
callq 0x220e6
addq $0x18, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14470
leaq 0x13862(%rip), %rsi # 0x358f8
leaq 0x8(%rsp), %rdi
callq 0x14230
leaq 0x88(%rsp), %rdi
callq 0x140d0
movq %rbx, %rax
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x13831(%rip), %rsi # 0x358f8
leaq 0x8(%rsp), %rdi
callq 0x14230
leaq 0x88(%rsp), %rdi
callq 0x140d0
movq %rbx, %rdi
callq 0x14510
| /srz-zumix[P]iutest/test/param_test_name_tests.cpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<bool>(bool const&) | iuStreamMessage& operator << (const T& value)
{
#if !defined(IUTEST_NO_ARGUMENT_DEPENDENT_LOOKUP)
m_stream << PrintToString(value);
#else
m_stream << value;
#endif
return *this;
} | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x21b40
leaq 0x30(%rsp), %rdi
movzbl (%r14), %edx
leaq 0x7040(%rip), %rax # 0x29150
leaq 0x70b4(%rip), %rsi # 0x291cb
testq %rdx, %rdx
cmovneq %rax, %rsi
xorq $0x5, %rdx
callq 0x14350
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x14470
leaq 0x10(%rbx), %r14
leaq 0x137b9(%rip), %rsi # 0x358f8
leaq 0x20(%rsp), %rdi
callq 0x14230
leaq 0xa0(%rsp), %rdi
callq 0x140d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x14350
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22182
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x142c0
movq %rbx, %rax
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x221d1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x142c0
jmp 0x221d1
movq %rax, %rbx
leaq 0x1373e(%rip), %rsi # 0x358f8
leaq 0x20(%rsp), %rdi
callq 0x14230
leaq 0xa0(%rsp), %rdi
callq 0x140d0
movq %rbx, %rdi
callq 0x14510
nop
| /srz-zumix[P]iutest/include/internal/../internal/iutest_message.hpp |
iutest::detail::ParamTestInstance<iu_RenameParamTest_x_iutest_x_Test_Test>::MakeTestSuite(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void*, void (*)(), void (*)()) const | virtual TestSuite* MakeTestSuite(const ::std::string& testsuite_name, TestTypeId id
, SetUpMethod setup, TearDownMethod teardown) const IUTEST_CXX_OVERRIDE
{
#if !defined(IUTEST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)
return UnitTest::instance().AddTestSuite<TestSuite>(testsuite_name, id, setup, teardown);
#else
return UnitTest::instance().AddTestSuite(
testsuite_name, id, setup, teardown, detail::explicit_type<TestSuite>());
#endif
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
callq 0x1a60e
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21078
| /srz-zumix[P]iutest/include/iutest_param_tests.hpp |
iutest::detail::iuParamTestFactory<iu_RenameParamTest_x_iutest_x_Test_Test>::~iuParamTestFactory() | class iuParamTestFactory IUTEST_CXX_FINAL : public iuParamTestFactoryBase<typename Tester::ParamType>
{
typedef typename Tester::ParamType ParamType;
typedef iuParamTestFactoryBase<ParamType> _Mybase;
public:
iuParamTestFactory() IUTEST_CXX_DEFAULT_FUNCTION
explicit iuParamTestFactory(ParamType param) : _Mybase(param) {}
public:
virtual auto_ptr<Test> Create() IUTEST_CXX_OVERRIDE
{
Tester::SetParam(&this->m_param);
auto_ptr<Test> p( new Tester() );
return p;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x1365d(%rip), %rax # 0x35c70
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x2262e
movq (%rax), %rsi
incq %rsi
callq 0x142c0
movl $0x28, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x142c0
| /srz-zumix[P]iutest/include/internal/../internal/iutest_factory.hpp |
iutest::detail::iuValueArray<char const*, char const*>::operator iutest::detail::iuIParamGenerator<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 | operator iuIParamGenerator<T>* () const
{
make_array<T> ar(v);
#if !defined(IUTEST_NO_FUNCTION_TEMPLATE_ORDERING)
return new iuValuesInParamsGenerator<T>(ar.val);
#else
return new iuValuesInParamsGenerator<T>(ar.val, ar.val + IUTEST_PP_COUNTOF(ar.val));
#endif
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rsi
movq %rsp, %rdi
callq 0x227c0
movl $0x28, %edi
callq 0x142b0
movq %rax, %rbx
movq %rsp, %rsi
movq %rax, %rdi
callq 0x22816
movq $-0x40, %r14
leaq 0x30(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %rdi, %r15
je 0x22762
movq (%r15), %rsi
incq %rsi
callq 0x142c0
addq $-0x20, %r15
addq $0x20, %r14
jne 0x2274e
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x28, %esi
movq %rbx, %rdi
callq 0x142c0
jmp 0x2278e
movq %rax, %r14
movq $-0x40, %rbx
leaq 0x30(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %rdi, %r15
je 0x227ae
movq (%r15), %rsi
incq %rsi
callq 0x142c0
addq $-0x20, %r15
addq $0x20, %rbx
jne 0x2279a
movq %r14, %rdi
callq 0x14510
| /srz-zumix[P]iutest/include/internal/iutest_genparams.hpp |
iutest::tuples::detail::tuple_foreach_impl<std::tuple<char const*, char const*> const, iutest::detail::iuValueArray<char const*, char const*>::make_array<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, 0>::impl<2, 0>::do_something(std::tuple<char const*, char const*> const&, iutest::detail::iuValueArray<char const*, char const*>::make_array<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&) | static void do_something(T& t, F fn)
{
fn(I, get<I>(t));
impl<N, I + 1>::do_something(t, fn);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq 0x8(%rsi), %r12
movq %r15, %rdi
callq 0x14120
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x14450
movq (%r14), %r14
movq 0x28(%rbx), %r15
addq $0x20, %rbx
movq %r14, %rdi
callq 0x14120
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x14450
| /srz-zumix[P]iutest/include/internal/../internal/iutest_stdlib.hpp |
iutest::UnitTestImpl::ValidateTestPropertyName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static bool ValidateTestPropertyName(const ::std::string& name)
{
const char* ban[] = {
"name", "tests", "failures", "disabled", "skip", "errors", "time", "timestamp", "random_seed"
};
#if !defined(IUTEST_NO_FUNCTION_TEMPLATE_ORDERING)
return TestProperty::ValidateName(name, ban);
#else
return TestProperty::ValidateName(name, ban, ban+IUTEST_PP_COUNTOF(ban));
#endif
} | pushq %rbx
subq $0x50, %rsp
movq %rdi, %rdx
leaq 0x10ded(%rip), %rsi # 0x351d0
movq %rsp, %rax
movl $0x9, %ecx
movq %rax, %rdi
rep movsq (%rsi), %es:(%rdi)
leaq 0x48(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x24cc1
cmpq %rbx, %rax
sete %al
addq $0x50, %rsp
popq %rbx
retq
nop
| /srz-zumix[P]iutest/include/internal/iutest_core_impl.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::PrintToString<char const*>(char const* const&) | inline ::std::string PrintToString(const T& v)
{
iu_global_format_stringstream strm;
detail::UniversalTersePrint(v, &strm);
return strm.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x21b40
movq (%r14), %r15
leaq 0x30(%rsp), %r14
testq %r15, %r15
je 0x26bfb
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x14120
leaq (%rax,%r15), %rdx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x1bc24
movq %rsp, %rdi
movq %r14, %rsi
callq 0x226cc
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x26c0f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x142c0
jmp 0x26c0f
leaq 0x4a3f(%rip), %rsi # 0x2b641
movl $0x6, %edx
movq %r14, %rdi
callq 0x14350
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x14470
leaq 0xecd5(%rip), %rsi # 0x358f8
leaq 0x20(%rsp), %rdi
callq 0x14230
leaq 0xa0(%rsp), %rdi
callq 0x140d0
movq %rbx, %rax
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x26c6a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x142c0
jmp 0x26c6a
movq %rax, %rbx
leaq 0xec87(%rip), %rsi # 0x358f8
leaq 0x20(%rsp), %rdi
callq 0x14230
leaq 0xa0(%rsp), %rdi
callq 0x140d0
movq %rbx, %rdi
callq 0x14510
| /srz-zumix[P]iutest/include/internal/../internal/../iutest_printers.hpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<unsigned long>(unsigned long const&) | iuStreamMessage& operator << (const T& value)
{
#if !defined(IUTEST_NO_ARGUMENT_DEPENDENT_LOOKUP)
m_stream << PrintToString(value);
#else
m_stream << value;
#endif
return *this;
} | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x21b40
leaq 0x30(%rsp), %rdi
movq (%r14), %rsi
callq 0x141f0
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x14470
leaq 0x10(%rbx), %r14
leaq 0xead7(%rip), %rsi # 0x358f8
leaq 0x20(%rsp), %rdi
callq 0x14230
leaq 0xa0(%rsp), %rdi
callq 0x140d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x14350
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26e64
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x142c0
movq %rbx, %rax
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26eb3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x142c0
jmp 0x26eb3
movq %rax, %rbx
leaq 0xea5c(%rip), %rsi # 0x358f8
leaq 0x20(%rsp), %rdi
callq 0x14230
leaq 0xa0(%rsp), %rdi
callq 0x140d0
movq %rbx, %rdi
callq 0x14510
nop
| /srz-zumix[P]iutest/include/internal/../internal/iutest_message.hpp |
iutest::detail::IParamTestSuiteInfo::IParamTestSuiteInfo(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&) | IParamTestSuiteInfo(const char* base_name, const char* package_name)
: m_testsuite_base_name(base_name), m_package_name(package_name) {} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0xecb9(%rip), %rax # 0x35d50
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
leaq 0x20(%rdi), %r15
leaq 0x30(%rdi), %r12
movq %r12, 0x20(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x26ebc
leaq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x26ebc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x2710d
movq (%r12), %rsi
incq %rsi
callq 0x142c0
jmp 0x2710d
movq %rax, %r14
leaq 0x8(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x27125
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x142c0
movq %r14, %rdi
callq 0x14510
nop
| /srz-zumix[P]iutest/include/internal/iutest_params_util.hpp |
iutest::detail::IParamTestSuiteInfo::~IParamTestSuiteInfo() | virtual ~IParamTestSuiteInfo() {} | pushq %rbx
movq %rdi, %rbx
leaq 0xe831(%rip), %rax # 0x35d50
movq %rax, (%rdi)
movq 0x40(%rdi), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x2753a
movq (%rax), %rsi
incq %rsi
callq 0x142c0
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x27552
movq (%rax), %rsi
incq %rsi
callq 0x142c0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x27568
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x142c0
popq %rbx
retq
| /srz-zumix[P]iutest/include/internal/iutest_params_util.hpp |
iutest::detail::ShowStringQuoted(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline ::std::string ShowStringQuoted(const ::std::string& str)
{
::std::string s = "\""; s += str; s += "\"";
return s;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x34ef(%rip), %rsi # 0x2afab
leaq 0x34e9(%rip), %rdx # 0x2afac
callq 0x1bc24
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x140c0
leaq 0x34cd(%rip), %rsi # 0x2afab
movq %rbx, %rdi
callq 0x14550
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x27b05
movq (%r15), %rsi
incq %rsi
callq 0x142c0
movq %r14, %rdi
callq 0x14510
nop
| /srz-zumix[P]iutest/include/internal/iutest_string.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::internal::FormatForComparisonFailureMessage<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&, char const* const&) | inline ::std::string FormatForComparisonFailureMessage(const T1& value, const T2& /*other_operand*/)
{
return PrintToString(value);
} | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x21b40
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x226cc
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x14470
leaq 0xd29e(%rip), %rsi # 0x358f8
movq %rsp, %rdi
callq 0x14230
leaq 0x80(%rsp), %rdi
callq 0x140d0
movq %rbx, %rax
addq $0x188, %rsp # imm = 0x188
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0xd271(%rip), %rsi # 0x358f8
movq %rsp, %rdi
callq 0x14230
leaq 0x80(%rsp), %rdi
callq 0x140d0
movq %rbx, %rdi
callq 0x14510
| /srz-zumix[P]iutest/include/internal/../iutest_assertion.hpp |
llvm::SmallPtrSetImplBase::swap(llvm::SmallPtrSetImplBase&) | void SmallPtrSetImplBase::swap(SmallPtrSetImplBase &RHS) {
if (this == &RHS) return;
// We can only avoid copying elements if neither set is small.
if (!this->isSmall() && !RHS.isSmall()) {
std::swap(this->CurArray, RHS.CurArray);
std::swap(this->CurArraySize, RHS.CurArraySize);
std::swap(this->NumNonEmpty, RHS.NumNonEmpty);
std::swap(this->NumTombstones, RHS.NumTombstones);
return;
}
// FIXME: From here on we assume that both sets have the same small size.
// If only RHS is small, copy the small elements into LHS and move the pointer
// from LHS to RHS.
if (!this->isSmall() && RHS.isSmall()) {
assert(RHS.CurArray == RHS.SmallArray);
std::copy(RHS.CurArray, RHS.CurArray + RHS.NumNonEmpty, this->SmallArray);
std::swap(RHS.CurArraySize, this->CurArraySize);
std::swap(this->NumNonEmpty, RHS.NumNonEmpty);
std::swap(this->NumTombstones, RHS.NumTombstones);
RHS.CurArray = this->CurArray;
this->CurArray = this->SmallArray;
return;
}
// If only LHS is small, copy the small elements into RHS and move the pointer
// from RHS to LHS.
if (this->isSmall() && !RHS.isSmall()) {
assert(this->CurArray == this->SmallArray);
std::copy(this->CurArray, this->CurArray + this->NumNonEmpty,
RHS.SmallArray);
std::swap(RHS.CurArraySize, this->CurArraySize);
std::swap(RHS.NumNonEmpty, this->NumNonEmpty);
std::swap(RHS.NumTombstones, this->NumTombstones);
this->CurArray = RHS.CurArray;
RHS.CurArray = RHS.SmallArray;
return;
}
// Both a small, just swap the small elements.
assert(this->isSmall() && RHS.isSmall());
unsigned MinNonEmpty = std::min(this->NumNonEmpty, RHS.NumNonEmpty);
std::swap_ranges(this->SmallArray, this->SmallArray + MinNonEmpty,
RHS.SmallArray);
if (this->NumNonEmpty > MinNonEmpty) {
std::copy(this->SmallArray + MinNonEmpty,
this->SmallArray + this->NumNonEmpty,
RHS.SmallArray + MinNonEmpty);
} else {
std::copy(RHS.SmallArray + MinNonEmpty, RHS.SmallArray + RHS.NumNonEmpty,
this->SmallArray + MinNonEmpty);
}
assert(this->CurArraySize == RHS.CurArraySize);
std::swap(this->NumNonEmpty, RHS.NumNonEmpty);
std::swap(this->NumTombstones, RHS.NumTombstones);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq 0x18(%rsp), %rax
jne 0x87d6f4
jmp 0x87d9d8
movq 0x8(%rsp), %rdi
callq 0x847c90
testb $0x1, %al
jne 0x87d771
movq 0x18(%rsp), %rdi
callq 0x847c90
testb $0x1, %al
jne 0x87d771
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
callq 0x87d9e0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x18(%rsp), %rsi
addq $0x10, %rsi
callq 0x815680
movq 0x8(%rsp), %rdi
addq $0x14, %rdi
movq 0x18(%rsp), %rsi
addq $0x14, %rsi
callq 0x815680
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x18(%rsp), %rsi
addq $0x18, %rsi
callq 0x815680
jmp 0x87d9d8
movq 0x8(%rsp), %rdi
callq 0x847c90
testb $0x1, %al
jne 0x87d827
movq 0x18(%rsp), %rdi
callq 0x847c90
testb $0x1, %al
jne 0x87d796
jmp 0x87d827
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rdi
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rsi
movq 0x18(%rsp), %rcx
movl 0x14(%rcx), %ecx
shlq $0x3, %rcx
addq %rcx, %rsi
movq (%rax), %rdx
callq 0x87d630
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
addq $0x10, %rsi
callq 0x815680
movq 0x8(%rsp), %rdi
addq $0x14, %rdi
movq 0x18(%rsp), %rsi
addq $0x14, %rsi
callq 0x815680
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x18(%rsp), %rsi
addq $0x18, %rsi
callq 0x815680
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x18(%rsp), %rcx
movq %rdx, 0x8(%rcx)
movq (%rax), %rcx
movq %rcx, 0x8(%rax)
jmp 0x87d9d8
movq 0x8(%rsp), %rdi
callq 0x847c90
testb $0x1, %al
jne 0x87d83a
jmp 0x87d8dd
movq 0x18(%rsp), %rdi
callq 0x847c90
testb $0x1, %al
jne 0x87d8dd
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rax), %rsi
movl 0x14(%rax), %eax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x18(%rsp), %rax
movq (%rax), %rdx
callq 0x87d630
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
addq $0x10, %rsi
callq 0x815680
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
addq $0x14, %rdi
addq $0x14, %rsi
callq 0x815680
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
addq $0x18, %rsi
callq 0x815680
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x87d9d8
movq 0x8(%rsp), %rdi
addq $0x14, %rdi
movq 0x18(%rsp), %rsi
addq $0x14, %rsi
callq 0x827850
movq %rax, %rcx
movq 0x8(%rsp), %rax
movl (%rcx), %ecx
movl %ecx, 0x14(%rsp)
movq (%rax), %rdi
movq (%rax), %rsi
movl 0x14(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x18(%rsp), %rax
movq (%rax), %rdx
callq 0x87da20
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
cmpl 0x14(%rsp), %eax
jbe 0x87d968
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movl 0x14(%rsp), %ecx
shlq $0x3, %rcx
addq %rcx, %rdi
movq (%rax), %rsi
movl 0x14(%rax), %eax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x18(%rsp), %rax
movq (%rax), %rdx
movl 0x14(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdx
callq 0x87d630
jmp 0x87d9aa
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rdi
movl 0x14(%rsp), %ecx
shlq $0x3, %rcx
addq %rcx, %rdi
movq 0x18(%rsp), %rcx
movq (%rcx), %rsi
movq 0x18(%rsp), %rcx
movl 0x14(%rcx), %ecx
shlq $0x3, %rcx
addq %rcx, %rsi
movq (%rax), %rdx
movl 0x14(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdx
callq 0x87d630
movq 0x8(%rsp), %rdi
addq $0x14, %rdi
movq 0x18(%rsp), %rsi
addq $0x14, %rsi
callq 0x815680
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x18(%rsp), %rsi
addq $0x18, %rsi
callq 0x815680
addq $0x28, %rsp
retq
nopl (%rax)
| /Support/SmallPtrSet.cpp |
llvm::detail::LeadingZerosCounter<unsigned int, 4ul>::count(unsigned int) | static unsigned count(T Val) {
if (Val == 0)
return 32;
#if __has_builtin(__builtin_clz) || defined(__GNUC__)
return __builtin_clz(Val);
#elif defined(_MSC_VER)
unsigned long Index;
_BitScanReverse(&Index, Val);
return Index ^ 31;
#endif
} | movl %edi, -0x8(%rsp)
cmpl $0x0, -0x8(%rsp)
jne 0x87daa5
movl $0x20, -0x4(%rsp)
jmp 0x87dab3
movl -0x8(%rsp), %eax
bsrl %eax, %eax
xorl $0x1f, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
| /llvm/ADT/bit.h |
llvm::SmallVectorBase<unsigned long>::grow_pod(void*, unsigned long, unsigned long) | void SmallVectorBase<Size_T>::grow_pod(void *FirstEl, size_t MinSize,
size_t TSize) {
size_t NewCapacity = getNewCapacity<Size_T>(MinSize, TSize, this->capacity());
void *NewElts;
if (BeginX == FirstEl) {
NewElts = llvm::safe_malloc(NewCapacity * TSize);
if (NewElts == FirstEl)
NewElts = replaceAllocation(NewElts, TSize, NewCapacity);
// Copy the elements over. No need to run dtors on PODs.
memcpy(NewElts, this->BeginX, size() * TSize);
} else {
// If this wasn't grown from the inline copy, grow the allocated space.
NewElts = llvm::safe_realloc(this->BeginX, NewCapacity * TSize);
if (NewElts == FirstEl)
NewElts = replaceAllocation(NewElts, TSize, NewCapacity, size());
}
this->set_allocation_range(NewElts, NewCapacity);
} | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x40(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
callq 0x87e120
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %rax, %rdx
callq 0x87e0a0
movq %rax, %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x50(%rsp)
movq (%rax), %rax
cmpq 0x68(%rsp), %rax
jne 0x87e27e
movq 0x50(%rsp), %rdi
imulq 0x58(%rsp), %rdi
callq 0x87cde0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x68(%rsp), %rax
jne 0x87e248
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x87e130
movq %rax, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rdi), %rax
movq %rax, 0x28(%rsp)
callq 0x87e310
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rax, %rdx
imulq 0x58(%rsp), %rdx
callq 0x73a720
jmp 0x87e2f2
movq 0x40(%rsp), %rax
movq (%rax), %rdi
movq 0x50(%rsp), %rsi
imulq 0x58(%rsp), %rsi
callq 0x87d5c0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x68(%rsp), %rax
jne 0x87e2f0
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x87e310
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rax, %r8
callq 0x87e130
movq %rax, 0x48(%rsp)
jmp 0x87e2f2
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x87e320
addq $0x78, %rsp
retq
nopl (%rax,%rax)
| /Support/SmallVector.cpp |
report_size_overflow(unsigned long, unsigned long) | static void report_size_overflow(size_t MinSize, size_t MaxSize) {
std::string Reason = "SmallVector unable to grow. Requested capacity (" +
std::to_string(MinSize) +
") is larger than maximum value for size type (" +
std::to_string(MaxSize) + ")";
#ifdef LLVM_ENABLE_EXCEPTIONS
throw std::length_error(Reason);
#else
report_fatal_error(Twine(Reason));
#endif
} | subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xf0(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x87e630
leaq 0x68(%rsp), %rdi
leaq 0x7599eca(%rip), %rsi # 0x7e1828f
leaq 0x48(%rsp), %rdx
callq 0x87e5e0
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x7599edd(%rip), %rdx # 0x7e182c0
callq 0x7fcec0
movq 0xe8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x87e630
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x87e4f0
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x9057ae4(%rip), %rdx # 0x98d5f0f
callq 0x7fcec0
leaq 0xa8(%rsp), %rdi
callq 0x73b5d0
leaq 0x28(%rsp), %rdi
callq 0x73b5d0
leaq 0x88(%rsp), %rdi
callq 0x73b5d0
leaq 0x68(%rsp), %rdi
callq 0x73b5d0
leaq 0x48(%rsp), %rdi
callq 0x73b5d0
movq %rsp, %rdi
leaq 0xc8(%rsp), %rsi
callq 0x7fcea0
movq %rsp, %rdi
movl $0x1, %esi
callq 0x866630
nopw %cs:(%rax,%rax)
nop
| /Support/SmallVector.cpp |
llvm::StringMapImpl::LookupBucketFor(llvm::StringRef, unsigned int) | unsigned StringMapImpl::LookupBucketFor(StringRef Name,
uint32_t FullHashValue) {
#ifdef EXPENSIVE_CHECKS
assert(FullHashValue == hash(Name));
#endif
// Hash table unallocated so far?
if (NumBuckets == 0)
init(16);
if (shouldReverseIterate())
FullHashValue = ~FullHashValue;
unsigned BucketNo = FullHashValue & (NumBuckets - 1);
unsigned *HashTable = getHashTable(TheTable, NumBuckets);
unsigned ProbeAmt = 1;
int FirstTombstone = -1;
while (true) {
StringMapEntryBase *BucketItem = TheTable[BucketNo];
// If we found an empty bucket, this key isn't in the table yet, return it.
if (LLVM_LIKELY(!BucketItem)) {
// If we found a tombstone, we want to reuse the tombstone instead of an
// empty bucket. This reduces probing.
if (FirstTombstone != -1) {
HashTable[FirstTombstone] = FullHashValue;
return FirstTombstone;
}
HashTable[BucketNo] = FullHashValue;
return BucketNo;
}
if (BucketItem == getTombstoneVal()) {
// Skip over tombstones. However, remember the first one we see.
if (FirstTombstone == -1)
FirstTombstone = BucketNo;
} else if (LLVM_LIKELY(HashTable[BucketNo] == FullHashValue)) {
// If the full hash value matches, check deeply for a match. The common
// case here is that we are only looking at the buckets (for item info
// being non-null and for the full hash value) not at the items. This
// is important for cache locality.
// Do the comparison like this because Name isn't necessarily
// null-terminated!
char *ItemStr = (char *)BucketItem + ItemSize;
if (Name == StringRef(ItemStr, BucketItem->getKeyLength())) {
// We found a match!
return BucketNo;
}
}
// Okay, we didn't find the item. Probe to the next bucket.
BucketNo = (BucketNo + ProbeAmt) & (NumBuckets - 1);
// Use quadratic probing, it has fewer clumping artifacts than linear
// probing and has good cache behavior in the common case.
++ProbeAmt;
}
} | subq $0x88, %rsp
movq %rsi, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
movq %rdi, 0x68(%rsp)
movl %ecx, 0x64(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x8(%rax)
jne 0x884e49
movq 0x18(%rsp), %rdi
movl $0x10, %esi
callq 0x884d20
callq 0x847940
testb $0x1, %al
jne 0x884e54
jmp 0x884e5f
movl 0x64(%rsp), %eax
xorl $-0x1, %eax
movl %eax, 0x64(%rsp)
movq 0x18(%rsp), %rax
movl 0x64(%rsp), %ecx
movl 0x8(%rax), %edx
subl $0x1, %edx
andl %edx, %ecx
movl %ecx, 0x60(%rsp)
movq (%rax), %rdi
movl 0x8(%rax), %esi
callq 0x885000
movq %rax, 0x58(%rsp)
movl $0x1, 0x54(%rsp)
movl $0xffffffff, 0x50(%rsp) # imm = 0xFFFFFFFF
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0x60(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x884eba
jmp 0x884f02
cmpl $-0x1, 0x50(%rsp)
je 0x884ee2
movl 0x64(%rsp), %edx
movq 0x58(%rsp), %rax
movslq 0x50(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x50(%rsp), %eax
movl %eax, 0x84(%rsp)
jmp 0x884fec
movl 0x64(%rsp), %edx
movq 0x58(%rsp), %rax
movl 0x60(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl 0x60(%rsp), %eax
movl %eax, 0x84(%rsp)
jmp 0x884fec
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x7f3a30
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jne 0x884f32
cmpl $-0x1, 0x50(%rsp)
jne 0x884f2d
movl 0x60(%rsp), %eax
movl %eax, 0x50(%rsp)
jmp 0x884fc3
movq 0x58(%rsp), %rax
movl 0x60(%rsp), %ecx
movl (%rax,%rcx,4), %eax
cmpl 0x64(%rsp), %eax
jne 0x884fc1
movq 0x18(%rsp), %rcx
movq 0x48(%rsp), %rax
movl 0x14(%rcx), %ecx
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x7f3ad0
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x20(%rsp), %rdi
callq 0x7f47a0
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x7ed410
testb $0x1, %al
jne 0x884fb2
jmp 0x884fbf
movl 0x60(%rsp), %eax
movl %eax, 0x84(%rsp)
jmp 0x884fec
jmp 0x884fc1
jmp 0x884fc3
movq 0x18(%rsp), %rcx
movl 0x60(%rsp), %eax
addl 0x54(%rsp), %eax
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, 0x60(%rsp)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x884e94
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopl (%rax,%rax)
| /Support/StringMap.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::StringRef, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseSetPair<llvm::StringRef>>, llvm::StringRef, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseSetPair<llvm::StringRef>>::LookupBucketFor<llvm::StringRef>(llvm::StringRef const&, llvm::detail::DenseSetPair<llvm::StringRef> const*&) const | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of whether we find a tombstone while probing.
const BucketT *FoundTombstone = nullptr;
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
assert(!KeyInfoT::isEqual(Val, EmptyKey) &&
!KeyInfoT::isEqual(Val, TombstoneKey) &&
"Empty/Tombstone value shouldn't be inserted into map!");
unsigned BucketNo = getHashValue(Val) & (NumBuckets-1);
unsigned ProbeAmt = 1;
while (true) {
const BucketT *ThisBucket = BucketsPtr + BucketNo;
// Found Val's bucket? If so, return it.
if (LLVM_LIKELY(KeyInfoT::isEqual(Val, ThisBucket->getFirst()))) {
FoundBucket = ThisBucket;
return true;
}
// If we found an empty bucket, the key doesn't exist in the set.
// Insert it and return the default value.
if (LLVM_LIKELY(KeyInfoT::isEqual(ThisBucket->getFirst(), EmptyKey))) {
// If we've already seen a tombstone while probing, fill it in instead
// of the empty bucket we eventually probed to.
FoundBucket = FoundTombstone ? FoundTombstone : ThisBucket;
return false;
}
// If this is a tombstone, remember it. If Val ends up not in the map, we
// prefer to return it than something that would require more probing.
if (KeyInfoT::isEqual(ThisBucket->getFirst(), TombstoneKey) &&
!FoundTombstone)
FoundTombstone = ThisBucket; // Remember the first tombstone found.
// Otherwise, it's a hash collision or a tombstone, continue quadratic
// probing.
BucketNo += ProbeAmt++;
BucketNo &= (NumBuckets-1);
}
} | subq $0xd8, %rsp
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
movq 0xc8(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x886690
movq 0x8(%rsp), %rdi
movq %rax, 0xb0(%rsp)
callq 0x7f44f0
movl %eax, 0xac(%rsp)
cmpl $0x0, 0xac(%rsp)
jne 0x886470
movq 0xb8(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0xd7(%rsp)
jmp 0x88667d
movq $0x0, 0xa0(%rsp)
callq 0x7f4500
movq %rax, 0x90(%rsp)
movq %rdx, 0x98(%rsp)
callq 0x7f4530
movq %rax, 0x80(%rsp)
movq %rdx, 0x88(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x8866a0
movl 0xac(%rsp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, 0x7c(%rsp)
movl $0x1, 0x78(%rsp)
movq 0xb0(%rsp), %rax
movl 0x7c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x70(%rsp)
movq 0xc0(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x60(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x8866e0
movq (%rax), %rcx
movq %rcx, 0x50(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x58(%rsp), %rcx
callq 0x7f45b0
testb $0x1, %al
jne 0x886536
jmp 0x886553
movq 0x70(%rsp), %rcx
movq 0xb8(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0xd7(%rsp)
jmp 0x88667d
movq 0x70(%rsp), %rdi
callq 0x8866e0
movq (%rax), %rcx
movq %rcx, 0x40(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x7f45b0
testb $0x1, %al
jne 0x8865a7
jmp 0x8865e5
cmpq $0x0, 0xa0(%rsp)
je 0x8865c0
movq 0xa0(%rsp), %rax
movq %rax, (%rsp)
jmp 0x8865c9
movq 0x70(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0xb8(%rsp), %rax
movq %rcx, (%rax)
movb $0x0, 0xd7(%rsp)
jmp 0x88667d
movq 0x70(%rsp), %rdi
callq 0x8866e0
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x7f45b0
testb $0x1, %al
jne 0x886639
jmp 0x886651
cmpq $0x0, 0xa0(%rsp)
jne 0x886651
movq 0x70(%rsp), %rax
movq %rax, 0xa0(%rsp)
movl 0x78(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x78(%rsp)
addl 0x7c(%rsp), %eax
movl %eax, 0x7c(%rsp)
movl 0xac(%rsp), %eax
subl $0x1, %eax
andl 0x7c(%rsp), %eax
movl %eax, 0x7c(%rsp)
jmp 0x8864cb
movb 0xd7(%rsp), %al
andb $0x1, %al
addq $0xd8, %rsp
retq
nop
| /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::StringRef, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseSetPair<llvm::StringRef>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
// Free the old table.
deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x10(%rax), %ecx
movl %ecx, 0x18(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x40, 0xc(%rsp)
movl 0x1c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x7f65b0
movl %eax, 0x8(%rsp)
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x814ed0
movq (%rsp), %rdi
movl (%rax), %esi
callq 0x886cc0
cmpq $0x0, 0x10(%rsp)
jne 0x886c7e
movq (%rsp), %rdi
callq 0x886d30
jmp 0x886cb5
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0x18(%rsp), %eax
shlq $0x4, %rax
addq %rax, %rdx
callq 0x886dc0
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x876030
addq $0x28, %rsp
retq
nopw (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::APFloat::Storage::~Storage() | ~Storage() {
if (usesLayout<IEEEFloat>(*semantics)) {
IEEE.~IEEEFloat();
return;
}
if (usesLayout<DoubleAPFloat>(*semantics)) {
Double.~DoubleAPFloat();
return;
}
llvm_unreachable("Unexpected semantics");
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rdi
callq 0x889d70
testb $0x1, %al
jne 0x889d31
jmp 0x889d3d
movq 0x8(%rsp), %rdi
callq 0x8f4510
jmp 0x889d5c
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x889da0
testb $0x1, %al
jne 0x889d50
jmp 0x889d5c
movq 0x8(%rsp), %rdi
callq 0x889dd0
jmp 0x889d5c
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /llvm/ADT/APFloat.h |
llvm::StdThreadPool::grow(int) | void StdThreadPool::grow(int requested) {
llvm::sys::ScopedWriter LockGuard(ThreadsLock);
if (Threads.size() >= MaxThreadCount)
return; // Already hit the max thread pool size.
int newThreadCount = std::min<int>(requested, MaxThreadCount);
while (static_cast<int>(Threads.size()) < newThreadCount) {
int ThreadID = Threads.size();
Threads.emplace_back([this, ThreadID] {
set_thread_name(formatv("llvm-worker-{0}", ThreadID));
Strategy.apply_thread_strategy(ThreadID);
processTasks(nullptr);
});
}
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x20, %rsi
leaq 0x30(%rsp), %rdi
callq 0x88b380
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x88b3b0
movq 0x8(%rsp), %rcx
movl 0x164(%rcx), %ecx
cmpq %rcx, %rax
jb 0x88b2ed
movl $0x1, 0x2c(%rsp)
jmp 0x88b367
movq 0x8(%rsp), %rax
movl 0x164(%rax), %eax
movl %eax, 0x24(%rsp)
leaq 0x3c(%rsp), %rdi
leaq 0x24(%rsp), %rsi
callq 0x88b3d0
movl (%rax), %eax
movl %eax, 0x28(%rsp)
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x88b3b0
cmpl 0x28(%rsp), %eax
jge 0x88b35f
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x88b3b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movl %ecx, 0x20(%rsp)
movq %rax, %rdi
addq $0x8, %rdi
movq %rax, 0x10(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x18(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x88b410
jmp 0x88b311
movl $0x0, 0x2c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x88b490
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
| /Support/ThreadPool.cpp |
llvm::sys::SmartRWMutex<false>::lock() | bool lock() {
if (!mt_only || llvm_is_multithreaded()) {
impl.lock();
return true;
}
// Single-threaded debugging code. This would be racy in multithreaded
// mode, but provides not basic checks in single threaded mode.
assert(writers == 0 && "Writer lock already acquired!");
++writers;
return true;
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x88e030
movb $0x1, %al
andb $0x1, %al
popq %rcx
retq
nopw %cs:(%rax,%rax)
nop
| /llvm/Support/RWMutex.h |
clang::DiagnosticsEngine::DiagStateMap::DiagStatePoint const* llvm::SmallVectorTemplateCommon<clang::DiagnosticsEngine::DiagStateMap::DiagStatePoint, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<clang::DiagnosticsEngine::DiagStateMap::DiagStatePoint, true>>(llvm::SmallVectorTemplateBase<clang::DiagnosticsEngine::DiagStateMap::DiagStatePoint, true>*, clang::DiagnosticsEngine::DiagStateMap::DiagStatePoint const&, unsigned long) | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::TakesParamByValue) {
if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
ReferencesStorage = true;
Index = &Elt - This->begin();
}
}
This->grow(NewSize);
return ReferencesStorage ? This->begin() + Index : &Elt;
} | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x87dfe0
addq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x87ddf0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
ja 0x953c74
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x953cc6
movb $0x0, 0x1f(%rsp)
movq $-0x1, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x950910
testb $0x1, 0x1f(%rsp)
je 0x953cb4
movq 0x38(%rsp), %rdi
callq 0x94a3b0
movq 0x10(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
jmp 0x953cbd
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
| /llvm/ADT/SmallVector.h |
llvm::DenseMap<unsigned int, clang::DiagnosticMapping, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, clang::DiagnosticMapping>>::copyFrom(llvm::DenseMap<unsigned int, clang::DiagnosticMapping, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, clang::DiagnosticMapping>> const&) | void copyFrom(const DenseMap& other) {
this->destroyAll();
deallocate_buffer(Buckets, sizeof(BucketT) * NumBuckets, alignof(BucketT));
if (allocateBuckets(other.NumBuckets)) {
this->BaseT::copyFrom(other);
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x94f220
movq (%rsp), %rax
movq (%rax), %rdi
movl 0x10(%rax), %eax
movl %eax, %esi
shlq $0x3, %rsi
movl $0x4, %edx
callq 0x876030
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x10(%rax), %esi
callq 0x951be0
testb $0x1, %al
jne 0x954d0d
jmp 0x954d1d
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x954d40
jmp 0x954d2f
movq (%rsp), %rax
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /llvm/ADT/DenseMap.h |
clang::DiagnosticIDs::getDiagnosticLevel(unsigned int, clang::SourceLocation, clang::DiagnosticsEngine const&) const | DiagnosticIDs::Level
DiagnosticIDs::getDiagnosticLevel(unsigned DiagID, SourceLocation Loc,
const DiagnosticsEngine &Diag) const {
// Handle custom diagnostics, which cannot be mapped.
if (DiagID >= diag::DIAG_UPPER_LIMIT) {
assert(CustomDiagInfo && "Invalid CustomDiagInfo");
return CustomDiagInfo->getLevel(DiagID);
}
unsigned DiagClass = getBuiltinDiagClass(DiagID);
if (DiagClass == CLASS_NOTE) return DiagnosticIDs::Note;
return toLevel(getDiagnosticSeverity(DiagID, Loc, Diag));
} | subq $0x38, %rsp
movl %edx, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x2080, 0x24(%rsp) # imm = 0x2080
jb 0x9581da
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x957cf0
movq %rax, %rdi
movl 0x24(%rsp), %esi
callq 0x958230
movl %eax, 0x34(%rsp)
jmp 0x958222
movl 0x24(%rsp), %edi
callq 0x957f00
movl %eax, 0x14(%rsp)
cmpl $0x1, 0x14(%rsp)
jne 0x9581f8
movl $0x1, 0x34(%rsp)
jmp 0x958222
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x30(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movl 0x10(%rsp), %edx
callq 0x9582c0
movl %eax, %edi
callq 0x958260
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
| /Basic/DiagnosticIDs.cpp |
clang::DiagnosticIDs::isUnrecoverable(unsigned int) const | bool DiagnosticIDs::isUnrecoverable(unsigned DiagID) const {
if (DiagID >= diag::DIAG_UPPER_LIMIT) {
assert(CustomDiagInfo && "Invalid CustomDiagInfo");
// Custom diagnostics.
return CustomDiagInfo->getLevel(DiagID) >= DiagnosticIDs::Error;
}
// Only errors may be unrecoverable.
if (getBuiltinDiagClass(DiagID) < CLASS_ERROR)
return false;
if (DiagID == diag::err_unavailable ||
DiagID == diag::err_unavailable_message)
return false;
// Currently we consider all ARC errors as recoverable.
if (isARCDiagnostic(DiagID))
return false;
if (isCodegenABICheckDiagnostic(DiagID))
return false;
return true;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x2080, 0x14(%rsp) # imm = 0x2080
jb 0x9596e9
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x957cf0
movq %rax, %rdi
movl 0x14(%rsp), %esi
callq 0x958230
cmpl $0x4, %eax
setge %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x95974a
movl 0x14(%rsp), %edi
callq 0x957f00
cmpl $0x5, %eax
jae 0x9596fe
movb $0x0, 0x27(%rsp)
jmp 0x95974a
cmpl $0x1357, 0x14(%rsp) # imm = 0x1357
je 0x959712
cmpl $0x1359, 0x14(%rsp) # imm = 0x1359
jne 0x959719
movb $0x0, 0x27(%rsp)
jmp 0x95974a
movl 0x14(%rsp), %edi
callq 0x9597e0
testb $0x1, %al
jne 0x959728
jmp 0x95972f
movb $0x0, 0x27(%rsp)
jmp 0x95974a
movl 0x14(%rsp), %edi
callq 0x959840
testb $0x1, %al
jne 0x95973e
jmp 0x959745
movb $0x0, 0x27(%rsp)
jmp 0x95974a
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /Basic/DiagnosticIDs.cpp |
clang::IdentifierInfo::isCPlusPlusKeyword(clang::LangOptions const&) const | bool IdentifierInfo::isCPlusPlusKeyword(const LangOptions &LangOpts) const {
if (!LangOpts.CPlusPlus || !isKeyword(LangOpts))
return false;
// This is a C++ keyword if this identifier is not a keyword when checked
// using LangOptions without C++ support.
LangOptions LangOptsNoCPP = LangOpts;
LangOptsNoCPP.CPlusPlus = false;
LangOptsNoCPP.CPlusPlus11 = false;
LangOptsNoCPP.CPlusPlus20 = false;
return !isKeyword(LangOptsNoCPP);
} | subq $0x358, %rsp # imm = 0x358
movq %rdi, 0x348(%rsp)
movq %rsi, 0x340(%rsp)
movq 0x348(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x340(%rsp), %rax
movq (%rax), %rax
shrq $0xa, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0x9650b2
movq 0x8(%rsp), %rdi
movq 0x340(%rsp), %rsi
callq 0x9630c0
testb $0x1, %al
jne 0x9650bc
movb $0x0, 0x357(%rsp)
jmp 0x96512e
movq 0x340(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x965140
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
andq $-0x401, %rax # imm = 0xFBFF
orq $0x0, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
andq $-0x801, %rax # imm = 0xF7FF
orq $0x0, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
andq $-0x4001, %rax # imm = 0xBFFF
orq $0x0, %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x9630c0
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x357(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x965420
movb 0x357(%rsp), %al
andb $0x1, %al
addq $0x358, %rsp # imm = 0x358
retq
nop
| /Basic/IdentifierTable.cpp |
clang::Selector::isKeywordSelector(llvm::ArrayRef<llvm::StringRef>) const | bool Selector::isKeywordSelector(ArrayRef<StringRef> Names) const {
assert(!Names.empty() && "must have >= 1 selector slots");
if (getNumArgs() != Names.size())
return false;
for (unsigned I = 0, E = Names.size(); I != E; ++I) {
if (getNameForSlot(I) != Names[I])
return false;
}
return true;
} | subq $0x58, %rsp
movq %rsi, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x966320
movl %eax, %eax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x858170
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x966279
movb $0x0, 0x57(%rsp)
jmp 0x96630b
movl $0x0, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x858170
movl %eax, 0x30(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x30(%rsp), %eax
je 0x966306
movq (%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x966390
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movl 0x34(%rsp), %eax
movl %eax, %esi
leaq 0x40(%rsp), %rdi
callq 0x966400
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x7f20f0
testb $0x1, %al
jne 0x9662f0
jmp 0x9662f7
movb $0x0, 0x57(%rsp)
jmp 0x96630b
jmp 0x9662f9
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x96628f
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
| /Basic/IdentifierTable.cpp |
clang::getNullabilitySpelling(clang::NullabilityKind, bool) | StringRef clang::getNullabilitySpelling(NullabilityKind kind,
bool isContextSensitive) {
switch (kind) {
case NullabilityKind::NonNull:
return isContextSensitive ? "nonnull" : "_Nonnull";
case NullabilityKind::Nullable:
return isContextSensitive ? "nullable" : "_Nullable";
case NullabilityKind::NullableResult:
assert(!isContextSensitive &&
"_Nullable_result isn't supported as context-sensitive keyword");
return "_Nullable_result";
case NullabilityKind::Unspecified:
return isContextSensitive ? "null_unspecified" : "_Null_unspecified";
}
llvm_unreachable("Unknown nullability kind.");
} | subq $0x28, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, 0x17(%rsp)
andb $0x1, %al
movb %al, 0x16(%rsp)
movzbl 0x17(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
leaq 0x7551c36(%rip), %rcx # 0x7eb9d20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb 0x16(%rsp), %cl
leaq 0x7684e99(%rip), %rsi # 0x7fecf97
leaq 0x93aec9d(%rip), %rax # 0x9d16da2
testb $0x1, %cl
cmovneq %rax, %rsi
leaq 0x18(%rsp), %rdi
callq 0x7eb0f0
jmp 0x968175
movb 0x16(%rsp), %cl
leaq 0x7684e7e(%rip), %rsi # 0x7fecfa1
leaq 0x7597a8a(%rip), %rax # 0x7effbb4
testb $0x1, %cl
cmovneq %rax, %rsi
leaq 0x18(%rsp), %rdi
callq 0x7eb0f0
jmp 0x968175
leaq 0x18(%rsp), %rdi
leaq 0x7684e76(%rip), %rsi # 0x7fecfbf
callq 0x7eb0f0
jmp 0x968175
movb 0x16(%rsp), %cl
leaq 0x7684e51(%rip), %rsi # 0x7fecfac
leaq 0x7597a3f(%rip), %rax # 0x7effba1
testb $0x1, %cl
cmovneq %rax, %rsi
leaq 0x18(%rsp), %rdi
callq 0x7eb0f0
jmp 0x968175
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /Basic/IdentifierTable.cpp |
getKeywordStatusHelper(clang::LangOptions const&, (anonymous namespace)::TokenKey) | static KeywordStatus getKeywordStatusHelper(const LangOptions &LangOpts,
TokenKey Flag) {
// Flag is a single bit version of TokenKey (that is, not
// KEYALL/KEYALLCXX/etc), so we can check with == throughout this function.
assert((Flag & ~(Flag - 1)) == Flag && "Multiple bits set?");
switch (Flag) {
case KEYC99:
if (LangOpts.C99)
return KS_Enabled;
return !LangOpts.CPlusPlus ? KS_Future : KS_Unknown;
case KEYC23:
if (LangOpts.C23)
return KS_Enabled;
return !LangOpts.CPlusPlus ? KS_Future : KS_Unknown;
case KEYCXX:
return LangOpts.CPlusPlus ? KS_Enabled : KS_Unknown;
case KEYCXX11:
if (LangOpts.CPlusPlus11)
return KS_Enabled;
return LangOpts.CPlusPlus ? KS_Future : KS_Unknown;
case KEYCXX20:
if (LangOpts.CPlusPlus20)
return KS_Enabled;
return LangOpts.CPlusPlus ? KS_Future : KS_Unknown;
case KEYGNU:
return LangOpts.GNUKeywords ? KS_Extension : KS_Unknown;
case KEYMS:
return LangOpts.MicrosoftExt ? KS_Extension : KS_Unknown;
case BOOLSUPPORT:
if (LangOpts.Bool) return KS_Enabled;
return !LangOpts.CPlusPlus ? KS_Future : KS_Unknown;
case KEYALTIVEC:
return LangOpts.AltiVec ? KS_Enabled : KS_Unknown;
case KEYBORLAND:
return LangOpts.Borland ? KS_Extension : KS_Unknown;
case KEYOPENCLC:
return LangOpts.OpenCL && !LangOpts.OpenCLCPlusPlus ? KS_Enabled
: KS_Unknown;
case WCHARSUPPORT:
return LangOpts.WChar ? KS_Enabled : KS_Unknown;
case HALFSUPPORT:
return LangOpts.Half ? KS_Enabled : KS_Unknown;
case CHAR8SUPPORT:
if (LangOpts.Char8) return KS_Enabled;
if (LangOpts.CPlusPlus20) return KS_Unknown;
if (LangOpts.CPlusPlus) return KS_Future;
return KS_Unknown;
case KEYOBJC:
// We treat bridge casts as objective-C keywords so we can warn on them
// in non-arc mode.
return LangOpts.ObjC ? KS_Enabled : KS_Unknown;
case KEYZVECTOR:
return LangOpts.ZVector ? KS_Enabled : KS_Unknown;
case KEYCOROUTINES:
return LangOpts.Coroutines ? KS_Enabled : KS_Unknown;
case KEYMODULES:
return KS_Unknown;
case KEYOPENCLCXX:
return LangOpts.OpenCLCPlusPlus ? KS_Enabled : KS_Unknown;
case KEYMSCOMPAT:
return LangOpts.MSVCCompat ? KS_Enabled : KS_Unknown;
case KEYSYCL:
return LangOpts.isSYCL() ? KS_Enabled : KS_Unknown;
case KEYCUDA:
return LangOpts.CUDA ? KS_Enabled : KS_Unknown;
case KEYHLSL:
return LangOpts.HLSL ? KS_Enabled : KS_Unknown;
case KEYNOCXX:
// This is enabled in all non-C++ modes, but might be enabled for other
// reasons as well.
return LangOpts.CPlusPlus ? KS_Unknown : KS_Enabled;
case KEYNOOPENCL:
// The disable behavior for this is handled in getKeywordStatus.
return KS_Unknown;
case KEYNOMS18:
// The disable behavior for this is handled in getKeywordStatus.
return KS_Unknown;
case KEYFIXEDPOINT:
return LangOpts.FixedPoint ? KS_Enabled : KS_Disabled;
default:
llvm_unreachable("Unknown KeywordStatus flag");
}
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
subl $0x1, %eax
je 0x96db92
jmp 0x96d9f0
movl 0x10(%rsp), %eax
subl $0x2, %eax
je 0x96dc30
jmp 0x96d9ff
movl 0x10(%rsp), %eax
subl $0x4, %eax
je 0x96dc58
jmp 0x96da0e
movl 0x10(%rsp), %eax
subl $0x8, %eax
je 0x96dcec
jmp 0x96da1d
movl 0x10(%rsp), %eax
subl $0x10, %eax
je 0x96dd14
jmp 0x96da2c
movl 0x10(%rsp), %eax
subl $0x20, %eax
je 0x96dd3c
jmp 0x96da3b
movl 0x10(%rsp), %eax
subl $0x40, %eax
je 0x96dd8d
jmp 0x96da4a
movl 0x10(%rsp), %eax
subl $0x80, %eax
je 0x96e03f
jmp 0x96da5b
movl 0x10(%rsp), %eax
subl $0x100, %eax # imm = 0x100
je 0x96ddb6
jmp 0x96da6c
movl 0x10(%rsp), %eax
subl $0x200, %eax # imm = 0x200
je 0x96ddde
jmp 0x96da7d
movl 0x10(%rsp), %eax
subl $0x400, %eax # imm = 0x400
je 0x96dbdf
jmp 0x96da8e
movl 0x10(%rsp), %eax
subl $0x800, %eax # imm = 0x800
je 0x96e06e
jmp 0x96da9f
movl 0x10(%rsp), %eax
subl $0x1000, %eax # imm = 0x1000
je 0x96e064
jmp 0x96dab0
movl 0x10(%rsp), %eax
subl $0x2000, %eax # imm = 0x2000
je 0x96de33
jmp 0x96dac1
movl 0x10(%rsp), %eax
subl $0x4000, %eax # imm = 0x4000
je 0x96de5b
jmp 0x96dad2
movl 0x10(%rsp), %eax
subl $0x8000, %eax # imm = 0x8000
je 0x96de83
jmp 0x96dae3
movl 0x10(%rsp), %eax
subl $0x10000, %eax # imm = 0x10000
je 0x96def6
jmp 0x96daf4
movl 0x10(%rsp), %eax
subl $0x20000, %eax # imm = 0x20000
je 0x96df1e
jmp 0x96db05
movl 0x10(%rsp), %eax
subl $0x40000, %eax # imm = 0x40000
je 0x96df47
jmp 0x96db16
movl 0x10(%rsp), %eax
subl $0x80000, %eax # imm = 0x80000
je 0x96df70
jmp 0x96db27
movl 0x10(%rsp), %eax
subl $0x100000, %eax # imm = 0x100000
je 0x96dca2
jmp 0x96db38
movl 0x10(%rsp), %eax
subl $0x200000, %eax # imm = 0x200000
je 0x96df7d
jmp 0x96db49
movl 0x10(%rsp), %eax
subl $0x400000, %eax # imm = 0x400000
je 0x96dfa6
jmp 0x96db5a
movl 0x10(%rsp), %eax
subl $0x800000, %eax # imm = 0x800000
je 0x96dfce
jmp 0x96db6b
movl 0x10(%rsp), %eax
subl $0x1000000, %eax # imm = 0x1000000
je 0x96dff0
jmp 0x96db7c
movl 0x10(%rsp), %eax
subl $0x2000000, %eax # imm = 0x2000000
je 0x96e019
jmp 0x96db8d
jmp 0x96e078
movq 0x18(%rsp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0x96dbb0
movl $0x4, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0xa, %rax
andq $0x1, %rax
cmpl $0x0, %eax
setne %dl
xorb $-0x1, %dl
xorl %eax, %eax
movl $0x2, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0x3, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0x96dc01
movl $0x4, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0xa, %rax
andq $0x1, %rax
cmpl $0x0, %eax
setne %dl
xorb $-0x1, %dl
xorl %eax, %eax
movl $0x2, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0xa, %rax
andq $0x1, %rax
movl %eax, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0xb, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0x96dc7a
movl $0x4, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0xa, %rax
andq $0x1, %rax
movl %eax, %edx
xorl %eax, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0xe, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0x96dcc4
movl $0x4, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0xa, %rax
andq $0x1, %rax
movl %eax, %edx
xorl %eax, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0x22, %rax
andq $0x1, %rax
movl %eax, %edx
xorl %eax, %eax
movl $0x3, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0x7, %rax
andq $0x1, %rax
movl %eax, %edx
xorl %eax, %eax
movl $0x3, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0x19, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0x96dd5e
movl $0x4, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0xa, %rax
andq $0x1, %rax
cmpl $0x0, %eax
setne %dl
xorb $-0x1, %dl
xorl %eax, %eax
movl $0x2, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
shrq $0x29, %rax
andq $0x1, %rax
movl %eax, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0x9, %rax
andq $0x1, %rax
movl %eax, %edx
xorl %eax, %eax
movl $0x3, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
shrq $0x3e, %rax
andq $0x1, %rax
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0x96de19
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
shrq $0x20, %rax
andq $0x1, %rax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %dl
xorl %eax, %eax
movl $0x4, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0x1b, %rax
andq $0x1, %rax
movl %eax, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0x1a, %rax
andq $0x1, %rax
movl %eax, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0x1c, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0x96dea5
movl $0x4, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0xe, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0x96dec7
movl $0x0, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0xa, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0x96dee9
movl $0x2, 0x24(%rsp)
jmp 0x96e0a0
movl $0x0, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0x11, %rax
andq $0x1, %rax
movl %eax, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
shrq $0x2a, %rax
andq $0x1, %rax
movl %eax, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
shrq $0x3b, %rax
andq $0x1, %rax
movl %eax, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movl $0x0, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
shrq $0x20, %rax
andq $0x1, %rax
movl %eax, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0x5, %rax
andq $0x1, %rax
movl %eax, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rdi
callq 0x96e0b0
movb %al, %dl
xorl %eax, %eax
movl $0x4, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
shrq $0x24, %rax
andq $0x1, %rax
movl %eax, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq 0x58(%rax), %rax
shrq $0x9, %rax
andq $0x1, %rax
movl %eax, %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
shrq $0xa, %rax
andq $0x1, %rax
movl %eax, %edx
movl $0x4, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movl $0x0, 0x24(%rsp)
jmp 0x96e0a0
movl $0x0, 0x24(%rsp)
jmp 0x96e0a0
movq 0x18(%rsp), %rax
movq 0xa0(%rax), %rax
andq $0x1, %rax
movl %eax, %edx
movl $0x1, %eax
movl $0x4, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x96e0a0
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
| /Basic/IdentifierTable.cpp |
llvm::FoldingSetNodeID::AddPointer(void const*) | void AddPointer(const void *Ptr) {
// Note: this adds pointers to the hash using sizes and endianness that
// depend on the host. It doesn't matter, however, because hashing on
// pointer values is inherently unstable. Nothing should depend on the
// ordering of nodes in the folding set.
static_assert(sizeof(uintptr_t) <= sizeof(unsigned long long),
"unexpected pointer size");
AddInteger(reinterpret_cast<uintptr_t>(Ptr));
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x910430
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /llvm/ADT/FoldingSet.h |
clang::SrcMgr::SLocEntry::get(unsigned int, clang::SrcMgr::FileInfo const&) | static SLocEntry get(SourceLocation::UIntTy Offset, const FileInfo &FI) {
assert(!(Offset & (1ULL << OffsetBits)) && "Offset is too large");
SLocEntry E;
E.Offset = Offset;
E.IsExpansion = false;
E.File = FI;
return E;
} | subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
callq 0x94ffd0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x24(%rsp), %edx
movl (%rdi), %ecx
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
andl $0x80000000, %ecx # imm = 0x80000000
orl %edx, %ecx
movl %ecx, (%rdi)
movl (%rdi), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, (%rdi)
movq 0x18(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x8(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x10(%rdi)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /clang/Basic/SourceManager.h |
clang::SourceManager::createFileIDImpl(clang::SrcMgr::ContentCache&, llvm::StringRef, clang::SourceLocation, clang::SrcMgr::CharacteristicKind, int, unsigned int) | FileID SourceManager::createFileIDImpl(ContentCache &File, StringRef Filename,
SourceLocation IncludePos,
SrcMgr::CharacteristicKind FileCharacter,
int LoadedID,
SourceLocation::UIntTy LoadedOffset) {
if (LoadedID < 0) {
assert(LoadedID != -1 && "Loading sentinel FileID");
unsigned Index = unsigned(-LoadedID) - 2;
assert(Index < LoadedSLocEntryTable.size() && "FileID out of range");
assert(!SLocEntryLoaded[Index] && "FileID already loaded");
LoadedSLocEntryTable[Index] = SLocEntry::get(
LoadedOffset, FileInfo::get(IncludePos, File, FileCharacter, Filename));
SLocEntryLoaded[Index] = SLocEntryOffsetLoaded[Index] = true;
return FileID::get(LoadedID);
}
unsigned FileSize = File.getSize();
if (!(NextLocalOffset + FileSize + 1 > NextLocalOffset &&
NextLocalOffset + FileSize + 1 <= CurrentLoadedOffset)) {
Diag.Report(IncludePos, diag::err_sloc_space_too_large);
noteSLocAddressSpaceUsage(Diag);
return FileID();
}
LocalSLocEntryTable.push_back(
SLocEntry::get(NextLocalOffset,
FileInfo::get(IncludePos, File, FileCharacter, Filename)));
// We do a +1 here because we want a SourceLocation that means "the end of the
// file", e.g. for the "no newline at the end of the file" diagnostic.
NextLocalOffset += FileSize + 1;
updateSlocUsageStats();
// Set LastFileIDLookup to the newly created file. The next getFileID call is
// almost guaranteed to be from that file.
FileID FID = FileID::get(LocalSLocEntryTable.size()-1);
return LastFileIDLookup = FID;
} | subq $0x178, %rsp # imm = 0x178
movl 0x188(%rsp), %eax
movl 0x180(%rsp), %eax
movq %rdx, 0x160(%rsp)
movq %rcx, 0x168(%rsp)
movl %r8d, 0x15c(%rsp)
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movl %r9d, 0x144(%rsp)
movq 0x150(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x180(%rsp)
jge 0x97752e
movl 0x180(%rsp), %ecx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
subl %ecx, %eax
movl %eax, 0x140(%rsp)
movl 0x188(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x15c(%rsp), %eax
movl %eax, 0x114(%rsp)
movq 0x148(%rsp), %rsi
movl 0x144(%rsp), %edx
movups 0x160(%rsp), %xmm0
movaps %xmm0, 0x100(%rsp)
movl 0x114(%rsp), %edi
movq 0x100(%rsp), %rcx
movq 0x108(%rsp), %r8
callq 0x976700
movl 0x24(%rsp), %esi
movq %rax, 0x118(%rsp)
movq %rdx, 0x120(%rsp)
leaq 0x128(%rsp), %rdi
leaq 0x118(%rsp), %rdx
callq 0x976690
movq 0x28(%rsp), %rdi
addq $0xc8, %rdi
movl 0x140(%rsp), %eax
movl %eax, %esi
callq 0x94fce0
movq 0x28(%rsp), %rdi
movq 0x138(%rsp), %rcx
movq %rcx, 0x10(%rax)
movups 0x128(%rsp), %xmm0
movups %xmm0, (%rax)
addq $0x148, %rdi # imm = 0x148
movl 0x140(%rsp), %esi
callq 0x94fc80
movl %edx, 0xd8(%rsp)
movq %rax, 0xd0(%rsp)
movl 0xd8(%rsp), %eax
movl %eax, 0xe8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0xe0(%rsp)
leaq 0xe0(%rsp), %rdi
movl $0x1, %esi
callq 0x9779d0
movq 0x28(%rsp), %rdi
movups (%rax), %xmm0
movaps %xmm0, 0xf0(%rsp)
addq $0x100, %rdi # imm = 0x100
movl 0x140(%rsp), %esi
callq 0x94fc80
movl %edx, 0xb8(%rsp)
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0xc0(%rsp)
movl 0xb8(%rsp), %eax
movl %eax, 0xc8(%rsp)
movq 0xf0(%rsp), %rsi
movl 0xf8(%rsp), %edx
leaq 0xc0(%rsp), %rdi
callq 0x977a40
movl 0x180(%rsp), %edi
callq 0x976cb0
movl %eax, 0x174(%rsp)
jmp 0x97770b
movq 0x148(%rsp), %rdi
callq 0x972a70
movq 0x28(%rsp), %rcx
movl %eax, 0xac(%rsp)
movl 0xf8(%rcx), %eax
addl 0xac(%rsp), %eax
addl $0x1, %eax
cmpl 0xf8(%rcx), %eax
jbe 0x977580
movq 0x28(%rsp), %rcx
movl 0xf8(%rcx), %eax
addl 0xac(%rsp), %eax
addl $0x1, %eax
cmpl 0xfc(%rcx), %eax
jbe 0x97761c
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rsi
movl 0x15c(%rsp), %eax
movl %eax, 0x84(%rsp)
movl 0x84(%rsp), %edx
leaq 0x88(%rsp), %rdi
movl $0x41, %ecx
callq 0x94f470
leaq 0x88(%rsp), %rdi
callq 0x949780
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x20, 0x78(%rsp)
leaq 0x7c(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x978090
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x7c(%rsp), %rdx
callq 0x977a80
leaq 0x174(%rsp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x73aa90
leaq 0x174(%rsp), %rdi
callq 0x94f7e0
jmp 0x97770b
movq 0x28(%rsp), %rax
movq %rax, %rcx
addq $0xb8, %rcx
movq %rcx, 0x10(%rsp)
movl 0xf8(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0x15c(%rsp), %eax
movl %eax, 0x4c(%rsp)
movq 0x148(%rsp), %rsi
movl 0x144(%rsp), %edx
movq 0x160(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x168(%rsp), %rax
movq %rax, 0x40(%rsp)
movl 0x4c(%rsp), %edi
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %r8
callq 0x976700
movl 0xc(%rsp), %esi
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x976690
movq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x9780c0
movq 0x28(%rsp), %rdi
movl 0xac(%rsp), %eax
addl $0x1, %eax
addl 0xf8(%rdi), %eax
movl %eax, 0xf8(%rdi)
callq 0x976c10
movq 0x28(%rsp), %rdi
addq $0xb8, %rdi
callq 0x87dfe0
subq $0x1, %rax
movl %eax, %edi
callq 0x976cb0
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x34(%rsp)
movl 0x34(%rsp), %ecx
movl %ecx, 0x198(%rax)
movl 0x198(%rax), %eax
movl %eax, 0x174(%rsp)
movl 0x174(%rsp), %eax
addq $0x178, %rsp # imm = 0x178
retq
nopw (%rax,%rax)
| /Basic/SourceManager.cpp |
clang::SourceManager::getFileIDLocal(unsigned int) const | FileID SourceManager::getFileIDLocal(SourceLocation::UIntTy SLocOffset) const {
assert(SLocOffset < NextLocalOffset && "Bad function choice");
// After the first and second level caches, I see two common sorts of
// behavior: 1) a lot of searched FileID's are "near" the cached file
// location or are "near" the cached expansion location. 2) others are just
// completely random and may be a very long way away.
//
// To handle this, we do a linear search for up to 8 steps to catch #1 quickly
// then we fall back to a less cache efficient, but more scalable, binary
// search to find the location.
// See if this is near the file point - worst case we start scanning from the
// most newly created FileID.
// LessIndex - This is the lower bound of the range that we're searching.
// We know that the offset corresponding to the FileID is less than
// SLocOffset.
unsigned LessIndex = 0;
// upper bound of the search range.
unsigned GreaterIndex = LocalSLocEntryTable.size();
if (LastFileIDLookup.ID >= 0) {
// Use the LastFileIDLookup to prune the search space.
if (LocalSLocEntryTable[LastFileIDLookup.ID].getOffset() < SLocOffset)
LessIndex = LastFileIDLookup.ID;
else
GreaterIndex = LastFileIDLookup.ID;
}
// Find the FileID that contains this.
unsigned NumProbes = 0;
while (true) {
--GreaterIndex;
assert(GreaterIndex < LocalSLocEntryTable.size());
if (LocalSLocEntryTable[GreaterIndex].getOffset() <= SLocOffset) {
FileID Res = FileID::get(int(GreaterIndex));
// Remember it. We have good locality across FileID lookups.
LastFileIDLookup = Res;
NumLinearScans += NumProbes+1;
return Res;
}
if (++NumProbes == 8)
break;
}
NumProbes = 0;
while (true) {
unsigned MiddleIndex = (GreaterIndex-LessIndex)/2+LessIndex;
SourceLocation::UIntTy MidOffset =
getLocalSLocEntry(MiddleIndex).getOffset();
++NumProbes;
// If the offset of the midpoint is too large, chop the high side of the
// range to the midpoint.
if (MidOffset > SLocOffset) {
GreaterIndex = MiddleIndex;
continue;
}
// If the middle index contains the value, succeed and return.
if (MiddleIndex + 1 == LocalSLocEntryTable.size() ||
SLocOffset < getLocalSLocEntry(MiddleIndex + 1).getOffset()) {
FileID Res = FileID::get(MiddleIndex);
// Remember it. We have good locality across FileID lookups.
LastFileIDLookup = Res;
NumBinaryProbes += NumProbes;
return Res;
}
// Otherwise, move the low-side up to the middle index.
LessIndex = MiddleIndex;
}
} | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x0, 0x30(%rsp)
addq $0xb8, %rdi
callq 0x87dfe0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movl %ecx, 0x2c(%rsp)
cmpl $0x0, 0x198(%rax)
jl 0x978e6b
movq 0x18(%rsp), %rax
movq %rax, %rdi
addq $0xb8, %rdi
movslq 0x198(%rax), %rsi
callq 0x979050
movq %rax, %rdi
callq 0x94f880
cmpl 0x34(%rsp), %eax
jae 0x978e5a
movq 0x18(%rsp), %rax
movl 0x198(%rax), %eax
movl %eax, 0x30(%rsp)
jmp 0x978e69
movq 0x18(%rsp), %rax
movl 0x198(%rax), %eax
movl %eax, 0x2c(%rsp)
jmp 0x978e6b
movl $0x0, 0x28(%rsp)
movq 0x18(%rsp), %rdi
movl 0x2c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x2c(%rsp)
addq $0xb8, %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x979050
movq %rax, %rdi
callq 0x94f880
cmpl 0x34(%rsp), %eax
ja 0x978ed9
movl 0x2c(%rsp), %edi
callq 0x976cb0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x44(%rsp)
movl 0x44(%rsp), %ecx
movl %ecx, 0x198(%rax)
movl 0x28(%rsp), %ecx
addl $0x1, %ecx
addl 0x1c8(%rax), %ecx
movl %ecx, 0x1c8(%rax)
jmp 0x978fd4
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
cmpl $0x8, %eax
jne 0x978eeb
jmp 0x978eed
jmp 0x978e73
movl $0x0, 0x28(%rsp)
movq 0x18(%rsp), %rdi
movl 0x2c(%rsp), %eax
subl 0x30(%rsp), %eax
shrl %eax
addl 0x30(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %esi
callq 0x979080
movq %rax, %rdi
callq 0x94f880
movl %eax, 0x20(%rsp)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x34(%rsp), %eax
jbe 0x978f40
movl 0x24(%rsp), %eax
movl %eax, 0x2c(%rsp)
jmp 0x978ef5
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movq %rax, 0x10(%rsp)
addq $0xb8, %rdi
callq 0x87dfe0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x978f97
movq 0x18(%rsp), %rdi
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x24(%rsp), %esi
addl $0x1, %esi
callq 0x979080
movq %rax, %rdi
callq 0x94f880
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jae 0x978fc7
movl 0x24(%rsp), %edi
callq 0x976cb0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x44(%rsp)
movl 0x44(%rsp), %ecx
movl %ecx, 0x198(%rax)
movl 0x28(%rsp), %ecx
addl 0x1cc(%rax), %ecx
movl %ecx, 0x1cc(%rax)
jmp 0x978fd4
movl 0x24(%rsp), %eax
movl %eax, 0x30(%rsp)
jmp 0x978ef5
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
| /Basic/SourceManager.cpp |
MoveUpTranslationUnitIncludeHierarchy(std::pair<clang::FileID, unsigned int>&, clang::SourceManager const&) | static bool
MoveUpTranslationUnitIncludeHierarchy(std::pair<FileID, unsigned> &Loc,
const SourceManager &SM) {
std::pair<FileID, unsigned> UpperLoc = SM.getDecomposedIncludedLoc(Loc.first);
if (UpperLoc.first.isInvalid() ||
!SM.isInTheSameTranslationUnitImpl(UpperLoc, Loc))
return true; // We reached the top.
Loc = UpperLoc;
return false;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %esi
callq 0x97c710
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x977070
testb $0x1, %al
jne 0x97de82
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x8(%rsp), %rsi
callq 0x97cb60
testb $0x1, %al
jne 0x97de89
movb $0x1, 0x27(%rsp)
jmp 0x97de9d
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x97e040
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| /Basic/SourceManager.cpp |
llvm::DenseMapBase<llvm::DenseMap<clang::FileEntry const*, clang::FileEntryRef, llvm::DenseMapInfo<clang::FileEntry const*, void>, llvm::detail::DenseMapPair<clang::FileEntry const*, clang::FileEntryRef>>, clang::FileEntry const*, clang::FileEntryRef, llvm::DenseMapInfo<clang::FileEntry const*, void>, llvm::detail::DenseMapPair<clang::FileEntry const*, clang::FileEntryRef>>::getMinBucketToReserveForEntries(unsigned int) | unsigned getMinBucketToReserveForEntries(unsigned NumEntries) {
// Ensure that "NumEntries * 4 < NumBuckets * 3"
if (NumEntries == 0)
return 0;
// +1 is required because of the strict equality.
// For example if NumEntries is 48, we need to return 401.
return NextPowerOf2(NumEntries * 4 / 3 + 1);
} | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x98105e
movl $0x0, 0x14(%rsp)
jmp 0x98107e
movl 0x4(%rsp), %eax
shll $0x2, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x7f65b0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<std::pair<clang::FileID, clang::FileID>, clang::InBeforeInTUCacheEntry, llvm::DenseMapInfo<std::pair<clang::FileID, clang::FileID>, void>, llvm::detail::DenseMapPair<std::pair<clang::FileID, clang::FileID>, clang::InBeforeInTUCacheEntry>, false>::AdvancePastEmptyBuckets() | void AdvancePastEmptyBuckets() {
assert(Ptr <= End);
const KeyT Empty = KeyInfoT::getEmptyKey();
const KeyT Tombstone = KeyInfoT::getTombstoneKey();
while (Ptr != End && (KeyInfoT::isEqual(Ptr->getFirst(), Empty) ||
KeyInfoT::isEqual(Ptr->getFirst(), Tombstone)))
++Ptr;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x987cc0
movq %rax, 0x18(%rsp)
callq 0x988960
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0x7(%rsp)
je 0x98d298
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x987c70
movq %rax, %rdi
leaq 0x18(%rsp), %rsi
callq 0x9888d0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x6(%rsp)
jne 0x98d290
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x987c70
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0x9888d0
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x98d2a2
jmp 0x98d2b3
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x20, %rcx
movq %rcx, (%rax)
jmp 0x98d237
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<void const*, llvm::StringRef, llvm::DenseMapInfo<void const*, void>, llvm::detail::DenseMapPair<void const*, llvm::StringRef>>, void const*, llvm::StringRef, llvm::DenseMapInfo<void const*, void>, llvm::detail::DenseMapPair<void const*, llvm::StringRef>>::find(void const*) | iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*this, true);
return end();
} | subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x99cfd0
testb $0x1, %al
jne 0x997abd
jmp 0x997b1b
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x99d100
testb $0x1, %al
jne 0x997ad2
jmp 0x997ae3
movq 0x18(%rsp), %rdi
callq 0x999570
movq %rax, 0x8(%rsp)
jmp 0x997af2
movq 0x18(%rsp), %rdi
callq 0x999580
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl $0x1, %r8d
movq %rcx, %rdi
callq 0x99d020
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
jmp 0x997b2f
movq 0x18(%rsp), %rdi
callq 0x997b70
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
nop
| /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::sys::fs::UniqueID, clang::DirectoryEntry*, llvm::DenseMapInfo<llvm::sys::fs::UniqueID, void>, llvm::detail::DenseMapPair<llvm::sys::fs::UniqueID, clang::DirectoryEntry*>>, llvm::sys::fs::UniqueID, clang::DirectoryEntry*, llvm::DenseMapInfo<llvm::sys::fs::UniqueID, void>, llvm::detail::DenseMapPair<llvm::sys::fs::UniqueID, clang::DirectoryEntry*>>::destroyAll() | void destroyAll() {
if (getNumBuckets() == 0) // Nothing to do.
return;
const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) {
if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(P->getFirst(), TombstoneKey))
P->getSecond().~ValueT();
P->getFirst().~KeyT();
}
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x998f10
cmpl $0x0, %eax
jne 0x999b52
jmp 0x999bf4
callq 0x998e30
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
callq 0x999c00
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
callq 0x998e60
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x998e70
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x999bf4
movq 0x18(%rsp), %rdi
callq 0x998eb0
movq %rax, %rdi
leaq 0x30(%rsp), %rsi
callq 0x81b500
testb $0x1, %al
jne 0x999bda
movq 0x18(%rsp), %rdi
callq 0x998eb0
movq %rax, %rdi
leaq 0x20(%rsp), %rsi
callq 0x81b500
testb $0x1, %al
jne 0x999bda
movq 0x18(%rsp), %rdi
callq 0x999c30
movq 0x18(%rsp), %rdi
callq 0x998eb0
movq 0x18(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x18(%rsp)
jmp 0x999b8e
addq $0x48, %rsp
retq
nopl (%rax)
| /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::sys::fs::UniqueID, clang::DirectoryEntry*, llvm::DenseMapInfo<llvm::sys::fs::UniqueID, void>, llvm::detail::DenseMapPair<llvm::sys::fs::UniqueID, clang::DirectoryEntry*>>, llvm::sys::fs::UniqueID, clang::DirectoryEntry*, llvm::DenseMapInfo<llvm::sys::fs::UniqueID, void>, llvm::detail::DenseMapPair<llvm::sys::fs::UniqueID, clang::DirectoryEntry*>>::LookupBucketFor<llvm::sys::fs::UniqueID>(llvm::sys::fs::UniqueID const&, llvm::detail::DenseMapPair<llvm::sys::fs::UniqueID, clang::DirectoryEntry*> const*&) const | bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of whether we find a tombstone while probing.
const BucketT *FoundTombstone = nullptr;
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
assert(!KeyInfoT::isEqual(Val, EmptyKey) &&
!KeyInfoT::isEqual(Val, TombstoneKey) &&
"Empty/Tombstone value shouldn't be inserted into map!");
unsigned BucketNo = getHashValue(Val) & (NumBuckets-1);
unsigned ProbeAmt = 1;
while (true) {
const BucketT *ThisBucket = BucketsPtr + BucketNo;
// Found Val's bucket? If so, return it.
if (LLVM_LIKELY(KeyInfoT::isEqual(Val, ThisBucket->getFirst()))) {
FoundBucket = ThisBucket;
return true;
}
// If we found an empty bucket, the key doesn't exist in the set.
// Insert it and return the default value.
if (LLVM_LIKELY(KeyInfoT::isEqual(ThisBucket->getFirst(), EmptyKey))) {
// If we've already seen a tombstone while probing, fill it in instead
// of the empty bucket we eventually probed to.
FoundBucket = FoundTombstone ? FoundTombstone : ThisBucket;
return false;
}
// If this is a tombstone, remember it. If Val ends up not in the map, we
// prefer to return it than something that would require more probing.
if (KeyInfoT::isEqual(ThisBucket->getFirst(), TombstoneKey) &&
!FoundTombstone)
FoundTombstone = ThisBucket; // Remember the first tombstone found.
// Otherwise, it's a hash collision or a tombstone, continue quadratic
// probing.
BucketNo += ProbeAmt++;
BucketNo &= (NumBuckets-1);
}
} | subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x99a400
movq 0x18(%rsp), %rdi
movq %rax, 0x60(%rsp)
callq 0x998f10
movl %eax, 0x5c(%rsp)
cmpl $0x0, 0x5c(%rsp)
jne 0x99a2a8
movq 0x68(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x87(%rsp)
jmp 0x99a3ee
movq $0x0, 0x50(%rsp)
callq 0x998e30
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
callq 0x999c00
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x70(%rsp), %rdi
callq 0x99a410
movl 0x5c(%rsp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, 0x2c(%rsp)
movl $0x1, 0x28(%rsp)
movq 0x60(%rsp), %rax
movl 0x2c(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x99a440
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x81b500
testb $0x1, %al
jne 0x99a32a
jmp 0x99a344
movq 0x20(%rsp), %rcx
movq 0x68(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x87(%rsp)
jmp 0x99a3ee
movq 0x20(%rsp), %rdi
callq 0x99a440
movq %rax, %rdi
leaq 0x40(%rsp), %rsi
callq 0x81b500
testb $0x1, %al
jne 0x99a361
jmp 0x99a396
cmpq $0x0, 0x50(%rsp)
je 0x99a375
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x99a37f
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x68(%rsp), %rax
movq %rcx, (%rax)
movb $0x0, 0x87(%rsp)
jmp 0x99a3ee
movq 0x20(%rsp), %rdi
callq 0x99a440
movq %rax, %rdi
leaq 0x30(%rsp), %rsi
callq 0x81b500
testb $0x1, %al
jne 0x99a3b3
jmp 0x99a3c5
cmpq $0x0, 0x50(%rsp)
jne 0x99a3c5
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
movl 0x28(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rsp)
addl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x5c(%rsp), %eax
subl $0x1, %eax
andl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
jmp 0x99a2ee
movb 0x87(%rsp), %al
andb $0x1, %al
addq $0x88, %rsp
retq
nop
| /llvm/ADT/DenseMap.h |
std::pair<llvm::StringMapIterator<llvm::ErrorOr<clang::FileEntryRef::MapValue>>, bool> llvm::StringMap<llvm::ErrorOr<clang::FileEntryRef::MapValue>, llvm::MallocAllocator>::try_emplace_with_hash<llvm::ErrorOr<clang::FileEntryRef::MapValue>>(llvm::StringRef, unsigned int, llvm::ErrorOr<clang::FileEntryRef::MapValue>&&) | std::pair<iterator, bool> try_emplace_with_hash(StringRef Key,
uint32_t FullHashValue,
ArgsTy &&...Args) {
unsigned BucketNo = LookupBucketFor(Key, FullHashValue);
StringMapEntryBase *&Bucket = TheTable[BucketNo];
if (Bucket && Bucket != getTombstoneVal())
return std::make_pair(iterator(TheTable + BucketNo, false),
false); // Already exists in map.
if (Bucket == getTombstoneVal())
--NumTombstones;
Bucket =
MapEntryTy::create(Key, getAllocator(), std::forward<ArgsTy>(Args)...);
++NumItems;
assert(NumItems + NumTombstones <= NumBuckets);
BucketNo = RehashTable(BucketNo);
return std::make_pair(iterator(TheTable + BucketNo, false), true);
} | subq $0xd8, %rsp
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rdi, 0xb0(%rsp)
movl %ecx, 0xac(%rsp)
movq %r8, 0xa0(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x90(%rsp)
movl 0xac(%rsp), %ecx
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x884e10
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x9c(%rsp)
movq (%rax), %rax
movl 0x9c(%rsp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
cmpq $0x0, (%rax)
je 0x99ca50
movq 0x80(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
callq 0x7f3a30
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
je 0x99ca50
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl 0x9c(%rsp), %ecx
leaq (%rax,%rcx,8), %rsi
leaq 0x78(%rsp), %rdi
movq %rdi, 0x18(%rsp)
xorl %edx, %edx
callq 0x99b670
movq 0x18(%rsp), %rdi
movb $0x0, 0x77(%rsp)
leaq 0x77(%rsp), %rsi
callq 0x99b640
movb %dl, 0x68(%rsp)
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0xc8(%rsp)
movb 0x68(%rsp), %al
movb %al, 0xd0(%rsp)
jmp 0x99cb3a
movq 0x80(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x7f3a30
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jne 0x99ca80
movq 0x28(%rsp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq 0x28(%rsp), %rdi
movups 0xb8(%rsp), %xmm0
movaps %xmm0, 0x50(%rsp)
callq 0x7f3aa0
movq %rax, %rdx
movq 0xa0(%rsp), %rcx
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x99cb60
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movq 0x80(%rsp), %rax
movq %rcx, (%rax)
movl 0xc(%rdi), %eax
incl %eax
movl %eax, 0xc(%rdi)
movl 0x9c(%rsp), %esi
callq 0x885350
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x9c(%rsp)
movq (%rax), %rax
movl 0x9c(%rsp), %ecx
leaq (%rax,%rcx,8), %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %edx, %edx
callq 0x99b670
movq 0x8(%rsp), %rdi
movb $0x1, 0x47(%rsp)
leaq 0x47(%rsp), %rsi
callq 0x99b640
movb %dl, 0x38(%rsp)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0xc8(%rsp)
movb 0x38(%rsp), %al
movb %al, 0xd0(%rsp)
movq 0xc8(%rsp), %rax
movb 0xd0(%rsp), %dl
addq $0xd8, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /llvm/ADT/StringMap.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.