Split (1)

train · ~2.3M rows (showing the first 1.36M)

name string	code string	asm string	file string
void slang::syntax::SyntaxVisitor<slang::parsing::(anonymous namespace)::MetadataVisitor>::visitDefault<slang::syntax::ClockingItemSyntax const&>(slang::syntax::ClockingItemSyntax const&)	void visitDefault(T&& node) { for (uint32_t i = 0; i < node.getChildCount(); i++) { auto child = node.childNode(i); if (child) child->visit(*DERIVED); else { auto token = node.childToken(i); if (token) DERIVED->visitToken(token); } } }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq %rsi, %rdi callq 0x203670 testq %rax, %rax je 0x2c588c movl $0x1, %ebp xorl %r15d, %r15d movq %rbx, %rdi movq %r15, %rsi callq 0xc9464 testq %rax, %rax je 0x2c585f movq %rax, %rdi movq %r14, %rsi callq 0x2c284f jmp 0x2c587a movq %rbx, %rdi movq %r15, %rsi callq 0xc94d0 testq %rdx, %rdx je 0x2c587a movq %r14, %rdi movq %rax, %rsi callq 0x2c3bf6 movl %ebp, %r15d movq %rbx, %rdi callq 0x203670 incl %ebp cmpq %r15, %rax ja 0x2c5842 addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq nop	/MikePopoloski[P]slang/source/../include/slang/syntax/SyntaxVisitor.h
void slang::syntax::SyntaxVisitor<slang::parsing::(anonymous namespace)::MetadataVisitor>::visitDefault<slang::syntax::ClockingSequenceExprSyntax const&>(slang::syntax::ClockingSequenceExprSyntax const&)	void visitDefault(T&& node) { for (uint32_t i = 0; i < node.getChildCount(); i++) { auto child = node.childNode(i); if (child) child->visit(*DERIVED); else { auto token = node.childToken(i); if (token) DERIVED->visitToken(token); } } }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq %rsi, %rdi callq 0x203670 testq %rax, %rax je 0x2c597c movl $0x1, %ebp xorl %r15d, %r15d movq %rbx, %rdi movq %r15, %rsi callq 0xc9464 testq %rax, %rax je 0x2c594f movq %rax, %rdi movq %r14, %rsi callq 0x2c284f jmp 0x2c596a movq %rbx, %rdi movq %r15, %rsi callq 0xc94d0 testq %rdx, %rdx je 0x2c596a movq %r14, %rdi movq %rax, %rsi callq 0x2c3bf6 movl %ebp, %r15d movq %rbx, %rdi callq 0x203670 incl %ebp cmpq %r15, %rax ja 0x2c5932 addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq nop	/MikePopoloski[P]slang/source/../include/slang/syntax/SyntaxVisitor.h
void slang::syntax::SyntaxVisitor<slang::parsing::(anonymous namespace)::MetadataVisitor>::visitDefault<slang::syntax::CovergroupDeclarationSyntax const&>(slang::syntax::CovergroupDeclarationSyntax const&)	void visitDefault(T&& node) { for (uint32_t i = 0; i < node.getChildCount(); i++) { auto child = node.childNode(i); if (child) child->visit(*DERIVED); else { auto token = node.childToken(i); if (token) DERIVED->visitToken(token); } } }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq %rsi, %rdi callq 0x203670 testq %rax, %rax je 0x2c66a6 movl $0x1, %ebp xorl %r15d, %r15d movq %rbx, %rdi movq %r15, %rsi callq 0xc9464 testq %rax, %rax je 0x2c6679 movq %rax, %rdi movq %r14, %rsi callq 0x2c284f jmp 0x2c6694 movq %rbx, %rdi movq %r15, %rsi callq 0xc94d0 testq %rdx, %rdx je 0x2c6694 movq %r14, %rdi movq %rax, %rsi callq 0x2c3bf6 movl %ebp, %r15d movq %rbx, %rdi callq 0x203670 incl %ebp cmpq %r15, %rax ja 0x2c665c addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq nop	/MikePopoloski[P]slang/source/../include/slang/syntax/SyntaxVisitor.h
void slang::syntax::SyntaxVisitor<slang::parsing::(anonymous namespace)::MetadataVisitor>::visitDefault<slang::syntax::ElabSystemTaskSyntax const&>(slang::syntax::ElabSystemTaskSyntax const&)	void visitDefault(T&& node) { for (uint32_t i = 0; i < node.getChildCount(); i++) { auto child = node.childNode(i); if (child) child->visit(*DERIVED); else { auto token = node.childToken(i); if (token) DERIVED->visitToken(token); } } }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq %rsi, %rdi callq 0x203670 testq %rax, %rax je 0x2c7ad4 movl $0x1, %ebp xorl %r15d, %r15d movq %rbx, %rdi movq %r15, %rsi callq 0xc9464 testq %rax, %rax je 0x2c7aa7 movq %rax, %rdi movq %r14, %rsi callq 0x2c284f jmp 0x2c7ac2 movq %rbx, %rdi movq %r15, %rsi callq 0xc94d0 testq %rdx, %rdx je 0x2c7ac2 movq %r14, %rdi movq %rax, %rsi callq 0x2c3bf6 movl %ebp, %r15d movq %rbx, %rdi callq 0x203670 incl %ebp cmpq %r15, %rax ja 0x2c7a8a addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq nop	/MikePopoloski[P]slang/source/../include/slang/syntax/SyntaxVisitor.h
void slang::syntax::SyntaxVisitor<slang::parsing::(anonymous namespace)::MetadataVisitor>::visitDefault<slang::syntax::EventControlSyntax const&>(slang::syntax::EventControlSyntax const&)	void visitDefault(T&& node) { for (uint32_t i = 0; i < node.getChildCount(); i++) { auto child = node.childNode(i); if (child) child->visit(*DERIVED); else { auto token = node.childToken(i); if (token) DERIVED->visitToken(token); } } }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq %rsi, %rdi callq 0x203670 testq %rax, %rax je 0x2c8434 movl $0x1, %ebp xorl %r15d, %r15d movq %rbx, %rdi movq %r15, %rsi callq 0xc9464 testq %rax, %rax je 0x2c8407 movq %rax, %rdi movq %r14, %rsi callq 0x2c284f jmp 0x2c8422 movq %rbx, %rdi movq %r15, %rsi callq 0xc94d0 testq %rdx, %rdx je 0x2c8422 movq %r14, %rdi movq %rax, %rsi callq 0x2c3bf6 movl %ebp, %r15d movq %rbx, %rdi callq 0x203670 incl %ebp cmpq %r15, %rax ja 0x2c83ea addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq nop	/MikePopoloski[P]slang/source/../include/slang/syntax/SyntaxVisitor.h
void slang::syntax::SyntaxVisitor<slang::parsing::(anonymous namespace)::MetadataVisitor>::visitDefault<slang::syntax::ExplicitAnsiPortSyntax const&>(slang::syntax::ExplicitAnsiPortSyntax const&)	void visitDefault(T&& node) { for (uint32_t i = 0; i < node.getChildCount(); i++) { auto child = node.childNode(i); if (child) child->visit(*DERIVED); else { auto token = node.childToken(i); if (token) DERIVED->visitToken(token); } } }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq %rsi, %rdi callq 0x203670 testq %rax, %rax je 0x2c8524 movl $0x1, %ebp xorl %r15d, %r15d movq %rbx, %rdi movq %r15, %rsi callq 0xc9464 testq %rax, %rax je 0x2c84f7 movq %rax, %rdi movq %r14, %rsi callq 0x2c284f jmp 0x2c8512 movq %rbx, %rdi movq %r15, %rsi callq 0xc94d0 testq %rdx, %rdx je 0x2c8512 movq %r14, %rdi movq %rax, %rsi callq 0x2c3bf6 movl %ebp, %r15d movq %rbx, %rdi callq 0x203670 incl %ebp cmpq %r15, %rax ja 0x2c84da addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq nop	/MikePopoloski[P]slang/source/../include/slang/syntax/SyntaxVisitor.h
void slang::syntax::SyntaxVisitor<slang::parsing::(anonymous namespace)::MetadataVisitor>::visitDefault<slang::syntax::ForeachLoopListSyntax const&>(slang::syntax::ForeachLoopListSyntax const&)	void visitDefault(T&& node) { for (uint32_t i = 0; i < node.getChildCount(); i++) { auto child = node.childNode(i); if (child) child->visit(*DERIVED); else { auto token = node.childToken(i); if (token) DERIVED->visitToken(token); } } }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq %rsi, %rdi callq 0x203670 testq %rax, %rax je 0x2c8ca4 movl $0x1, %ebp xorl %r15d, %r15d movq %rbx, %rdi movq %r15, %rsi callq 0xc9464 testq %rax, %rax je 0x2c8c77 movq %rax, %rdi movq %r14, %rsi callq 0x2c284f jmp 0x2c8c92 movq %rbx, %rdi movq %r15, %rsi callq 0xc94d0 testq %rdx, %rdx je 0x2c8c92 movq %r14, %rdi movq %rax, %rsi callq 0x2c3bf6 movl %ebp, %r15d movq %rbx, %rdi callq 0x203670 incl %ebp cmpq %r15, %rax ja 0x2c8c5a addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq nop	/MikePopoloski[P]slang/source/../include/slang/syntax/SyntaxVisitor.h
void slang::syntax::SyntaxVisitor<slang::parsing::(anonymous namespace)::MetadataVisitor>::visitDefault<slang::syntax::RangeListSyntax const&>(slang::syntax::RangeListSyntax const&)	void visitDefault(T&& node) { for (uint32_t i = 0; i < node.getChildCount(); i++) { auto child = node.childNode(i); if (child) child->visit(*DERIVED); else { auto token = node.childToken(i); if (token) DERIVED->visitToken(token); } } }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq %rsi, %rdi callq 0x203670 testq %rax, %rax je 0x2cd128 movl $0x1, %ebp xorl %r15d, %r15d movq %rbx, %rdi movq %r15, %rsi callq 0xc9464 testq %rax, %rax je 0x2cd0fb movq %rax, %rdi movq %r14, %rsi callq 0x2c284f jmp 0x2cd116 movq %rbx, %rdi movq %r15, %rsi callq 0xc94d0 testq %rdx, %rdx je 0x2cd116 movq %r14, %rdi movq %rax, %rsi callq 0x2c3bf6 movl %ebp, %r15d movq %rbx, %rdi callq 0x203670 incl %ebp cmpq %r15, %rax ja 0x2cd0de addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq nop	/MikePopoloski[P]slang/source/../include/slang/syntax/SyntaxVisitor.h
void slang::syntax::SyntaxVisitor<slang::parsing::(anonymous namespace)::MetadataVisitor>::visitDefault<slang::syntax::RsRuleSyntax const&>(slang::syntax::RsRuleSyntax const&)	void visitDefault(T&& node) { for (uint32_t i = 0; i < node.getChildCount(); i++) { auto child = node.childNode(i); if (child) child->visit(*DERIVED); else { auto token = node.childToken(i); if (token) DERIVED->visitToken(token); } } }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq %rsi, %rdi callq 0x203670 testq %rax, %rax je 0x2cd5d8 movl $0x1, %ebp xorl %r15d, %r15d movq %rbx, %rdi movq %r15, %rsi callq 0xc9464 testq %rax, %rax je 0x2cd5ab movq %rax, %rdi movq %r14, %rsi callq 0x2c284f jmp 0x2cd5c6 movq %rbx, %rdi movq %r15, %rsi callq 0xc94d0 testq %rdx, %rdx je 0x2cd5c6 movq %r14, %rdi movq %rax, %rsi callq 0x2c3bf6 movl %ebp, %r15d movq %rbx, %rdi callq 0x203670 incl %ebp cmpq %r15, %rax ja 0x2cd58e addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq nop	/MikePopoloski[P]slang/source/../include/slang/syntax/SyntaxVisitor.h
void slang::syntax::SyntaxVisitor<slang::parsing::(anonymous namespace)::MetadataVisitor>::visitDefault<slang::syntax::SequenceRepetitionSyntax const&>(slang::syntax::SequenceRepetitionSyntax const&)	void visitDefault(T&& node) { for (uint32_t i = 0; i < node.getChildCount(); i++) { auto child = node.childNode(i); if (child) child->visit(*DERIVED); else { auto token = node.childToken(i); if (token) DERIVED->visitToken(token); } } }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq %rsi, %rdi callq 0x203670 testq %rax, %rax je 0x2cd7b8 movl $0x1, %ebp xorl %r15d, %r15d movq %rbx, %rdi movq %r15, %rsi callq 0xc9464 testq %rax, %rax je 0x2cd78b movq %rax, %rdi movq %r14, %rsi callq 0x2c284f jmp 0x2cd7a6 movq %rbx, %rdi movq %r15, %rsi callq 0xc94d0 testq %rdx, %rdx je 0x2cd7a6 movq %r14, %rdi movq %rax, %rsi callq 0x2c3bf6 movl %ebp, %r15d movq %rbx, %rdi callq 0x203670 incl %ebp cmpq %r15, %rax ja 0x2cd76e addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq nop	/MikePopoloski[P]slang/source/../include/slang/syntax/SyntaxVisitor.h
void slang::syntax::SyntaxVisitor<slang::parsing::(anonymous namespace)::MetadataVisitor>::visitDefault<slang::syntax::SpecparamDeclaratorSyntax const&>(slang::syntax::SpecparamDeclaratorSyntax const&)	void visitDefault(T&& node) { for (uint32_t i = 0; i < node.getChildCount(); i++) { auto child = node.childNode(i); if (child) child->visit(*DERIVED); else { auto token = node.childToken(i); if (token) DERIVED->visitToken(token); } } }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq %rsi, %rdi callq 0x203670 testq %rax, %rax je 0x2cdd58 movl $0x1, %ebp xorl %r15d, %r15d movq %rbx, %rdi movq %r15, %rsi callq 0xc9464 testq %rax, %rax je 0x2cdd2b movq %rax, %rdi movq %r14, %rsi callq 0x2c284f jmp 0x2cdd46 movq %rbx, %rdi movq %r15, %rsi callq 0xc94d0 testq %rdx, %rdx je 0x2cdd46 movq %r14, %rdi movq %rax, %rsi callq 0x2c3bf6 movl %ebp, %r15d movq %rbx, %rdi callq 0x203670 incl %ebp cmpq %r15, %rax ja 0x2cdd0e addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq nop	/MikePopoloski[P]slang/source/../include/slang/syntax/SyntaxVisitor.h
void slang::syntax::SyntaxVisitor<slang::parsing::(anonymous namespace)::MetadataVisitor>::visitDefault<slang::syntax::SystemNameSyntax const&>(slang::syntax::SystemNameSyntax const&)	void visitDefault(T&& node) { for (uint32_t i = 0; i < node.getChildCount(); i++) { auto child = node.childNode(i); if (child) child->visit(*DERIVED); else { auto token = node.childToken(i); if (token) DERIVED->visitToken(token); } } }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq %rsi, %rdi callq 0x203670 testq %rax, %rax je 0x2ce370 movl $0x1, %ebp xorl %r15d, %r15d movq %rbx, %rdi movq %r15, %rsi callq 0xc9464 testq %rax, %rax je 0x2ce343 movq %rax, %rdi movq %r14, %rsi callq 0x2c284f jmp 0x2ce35e movq %rbx, %rdi movq %r15, %rsi callq 0xc94d0 testq %rdx, %rdx je 0x2ce35e movq %r14, %rdi movq %rax, %rsi callq 0x2c3bf6 movl %ebp, %r15d movq %rbx, %rdi callq 0x203670 incl %ebp cmpq %r15, %rax ja 0x2ce326 addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq nop	/MikePopoloski[P]slang/source/../include/slang/syntax/SyntaxVisitor.h
void slang::syntax::SyntaxVisitor<slang::parsing::(anonymous namespace)::MetadataVisitor>::visitDefault<slang::syntax::TimeScaleDirectiveSyntax const&>(slang::syntax::TimeScaleDirectiveSyntax const&)	void visitDefault(T&& node) { for (uint32_t i = 0; i < node.getChildCount(); i++) { auto child = node.childNode(i); if (child) child->visit(*DERIVED); else { auto token = node.childToken(i); if (token) DERIVED->visitToken(token); } } }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq %rsi, %rdi callq 0x203670 testq %rax, %rax je 0x2ce550 movl $0x1, %ebp xorl %r15d, %r15d movq %rbx, %rdi movq %r15, %rsi callq 0xc9464 testq %rax, %rax je 0x2ce523 movq %rax, %rdi movq %r14, %rsi callq 0x2c284f jmp 0x2ce53e movq %rbx, %rdi movq %r15, %rsi callq 0xc94d0 testq %rdx, %rdx je 0x2ce53e movq %r14, %rdi movq %rax, %rsi callq 0x2c3bf6 movl %ebp, %r15d movq %rbx, %rdi callq 0x203670 incl %ebp cmpq %r15, %rax ja 0x2ce506 addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq nop	/MikePopoloski[P]slang/source/../include/slang/syntax/SyntaxVisitor.h
void slang::syntax::SyntaxVisitor<slang::parsing::(anonymous namespace)::MetadataVisitor>::visitDefault<slang::syntax::TimingControlExpressionSyntax const&>(slang::syntax::TimingControlExpressionSyntax const&)	void visitDefault(T&& node) { for (uint32_t i = 0; i < node.getChildCount(); i++) { auto child = node.childNode(i); if (child) child->visit(*DERIVED); else { auto token = node.childToken(i); if (token) DERIVED->visitToken(token); } } }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq %rsi, %rdi callq 0x203670 testq %rax, %rax je 0x2ce730 movl $0x1, %ebp xorl %r15d, %r15d movq %rbx, %rdi movq %r15, %rsi callq 0xc9464 testq %rax, %rax je 0x2ce703 movq %rax, %rdi movq %r14, %rsi callq 0x2c284f jmp 0x2ce71e movq %rbx, %rdi movq %r15, %rsi callq 0xc94d0 testq %rdx, %rdx je 0x2ce71e movq %r14, %rdi movq %rax, %rsi callq 0x2c3bf6 movl %ebp, %r15d movq %rbx, %rdi callq 0x203670 incl %ebp cmpq %r15, %rax ja 0x2ce6e6 addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq nop	/MikePopoloski[P]slang/source/../include/slang/syntax/SyntaxVisitor.h
slang::ast::builtins::ShortRealToBitsFunction::~ShortRealToBitsFunction()	explicit ShortRealToBitsFunction(const Builtins& builtins) : SimpleSystemSubroutine(KnownSystemName::ShortrealToBits, SubroutineKind::Function, 1, {&builtins.shortRealType}, builtins.uintType, false) {}	pushq %rbx movq %rdi, %rbx leaq 0x1f3351(%rip), %rax # 0x4da078 addq $0x10, %rax movq %rax, (%rdi) movq 0x38(%rdi), %rdi testq %rdi, %rdi je 0x2e6d43 movq 0x48(%rbx), %rsi subq %rdi, %rsi callq 0xe17e8 leaq 0x1f32c6(%rip), %rax # 0x4da010 addq $0x10, %rax movq %rax, (%rbx) movq 0x8(%rbx), %rdi leaq 0x18(%rbx), %rax cmpq %rax, %rdi je 0x2e6d69 movq (%rax), %rsi incq %rsi callq 0xe17e8 movl $0x68, %esi movq %rbx, %rdi popq %rbx jmp 0xe17e8 nop	/MikePopoloski[P]slang/source/ast/builtins/ConversionFuncs.cpp
slang::ast::builtins::CountOnesFunction::eval(slang::ast::EvalContext&, std::span<slang::ast::Expression const* const, 18446744073709551615ul> const&, slang::SourceRange, slang::ast::CallExpression::SystemCallInfo const&) const	ConstantValue eval(EvalContext& context, const Args& args, SourceRange range, const CallExpression::SystemCallInfo&) const final { auto value = Bitstream::convertToBitVector(args[0]->eval(context), range, context); if (!value) return nullptr; const SVInt& iv = value.integer(); uint64_t count = iv.countOnes(); return SVInt(32, count, true); }	pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x50, %rsp movq %r9, %r14 movq %r8, %r15 movq %rdx, %r12 movq %rdi, %rbx movq (%rcx), %rax movq (%rax), %rsi movq %rsp, %r13 movq %r13, %rdi callq 0x1cfafa leaq 0x28(%rsp), %rdi movq %r13, %rsi movq %r15, %rdx movq %r14, %rcx movq %r12, %r8 callq 0x18a3b8 movq %rsp, %rdi callq 0x696ee cmpb $0x0, 0x48(%rsp) je 0x2eb21e leaq 0x28(%rsp), %rdi callq 0x6f607 movq %rax, %rdi callq 0xaf09a movl %eax, %eax movq %rsp, %rdi movl $0x20, 0x8(%rdi) movw $0x1, 0xc(%rdi) movq %rax, (%rdi) callq 0xabbd4 movl 0x8(%rsp), %eax movzwl 0xc(%rsp), %ecx movl %eax, 0x8(%rbx) movw %cx, 0xc(%rbx) movq (%rsp), %rax movq %rax, (%rbx) movb $0x1, 0x20(%rbx) jmp 0x2eb222 movb $0x0, 0x20(%rbx) leaq 0x28(%rsp), %rdi callq 0x696ee movq %rbx, %rax addq $0x50, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq jmp 0x2eb241 jmp 0x2eb241 movq %rax, %rbx leaq 0x28(%rsp), %rdi jmp 0x2eb251 movq %rax, %rbx movq %rsp, %rdi callq 0x696ee movq %rbx, %rdi callq 0x37b10	/MikePopoloski[P]slang/source/ast/builtins/MathFuncs.cpp
slang::ast::builtins::RealMath1Function<&log>::RealMath1Function(slang::ast::builtins::Builtins const&, slang::parsing::KnownSystemName)	RealMath1Function(const Builtins& builtins, KnownSystemName knownNameId) : SimpleSystemSubroutine(knownNameId, SubroutineKind::Function, 1, {&builtins.realType}, builtins.realType, false) {}	pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movl %edx, %ebp movq %rdi, %rbx leaq 0x4d0(%rsi), %r14 leaq 0x20(%rsp), %rsi movq %r14, (%rsi) leaq 0x8(%rsp), %r15 leaq 0x7(%rsp), %rcx movl $0x1, %edx movq %r15, %rdi callq 0x2e62c0 xorl %eax, %eax movl $0x1, %ecx movq %rbx, %rdi movl %ebp, %esi xorl %edx, %edx movq %r15, %r8 movq %r14, %r9 pushq %rax pushq %rax callq 0x2d69fe addq $0x10, %rsp movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x2eb717 movq 0x18(%rsp), %rsi subq %rdi, %rsi callq 0xe17e8 leaq 0x1ea632(%rip), %rax # 0x4d5d50 movq %rax, (%rbx) addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x2eb746 movq 0x18(%rsp), %rsi subq %rdi, %rsi callq 0xe17e8 movq %rbx, %rdi callq 0x37b10	/MikePopoloski[P]slang/source/ast/builtins/MathFuncs.cpp
slang::ast::builtins::RealMath1Function<&exp>::RealMath1Function(slang::ast::builtins::Builtins const&, slang::parsing::KnownSystemName)	RealMath1Function(const Builtins& builtins, KnownSystemName knownNameId) : SimpleSystemSubroutine(knownNameId, SubroutineKind::Function, 1, {&builtins.realType}, builtins.realType, false) {}	pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movl %edx, %ebp movq %rdi, %rbx leaq 0x4d0(%rsi), %r14 leaq 0x20(%rsp), %rsi movq %r14, (%rsi) leaq 0x8(%rsp), %r15 leaq 0x7(%rsp), %rcx movl $0x1, %edx movq %r15, %rdi callq 0x2e62c0 xorl %eax, %eax movl $0x1, %ecx movq %rbx, %rdi movl %ebp, %esi xorl %edx, %edx movq %r15, %r8 movq %r14, %r9 pushq %rax pushq %rax callq 0x2d69fe addq $0x10, %rsp movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x2ebb9f movq 0x18(%rsp), %rsi subq %rdi, %rsi callq 0xe17e8 leaq 0x1ea32a(%rip), %rax # 0x4d5ed0 movq %rax, (%rbx) addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x2ebbce movq 0x18(%rsp), %rsi subq %rdi, %rsi callq 0xe17e8 movq %rbx, %rdi callq 0x37b10	/MikePopoloski[P]slang/source/ast/builtins/MathFuncs.cpp
slang::ast::builtins::createStdPackage(slang::ast::Compilation&)	const PackageSymbol& createStdPackage(Compilation& c) { auto pkg = c.emplace<PackageSymbol>(c, "std", NL, c.getWireNetType(), VariableLifetime::Static); pkg->addMember(createProcessClass(c)); pkg->addMember(createSemaphoreClass(c)); pkg->addMember(createMailboxClass(c)); pkg->addMember(createRandomizeFunc(c)); pkg->addMember(createWeakReference(c)); return *pkg; }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x3a8, %rsp # imm = 0x3A8 movq %rdi, %r12 movq 0x198(%rdi), %r8 movl $0x1, %ebp leaq 0x98(%rsp), %r9 movl %ebp, (%r9) leaq 0x77db0(%rip), %rdx # 0x370e46 leaq 0x7eb2b(%rip), %r14 # 0x377bc8 movq %rdi, %rsi movq %r14, %rcx callq 0x2fa94e movq %rax, 0x70(%rsp) addq $0x40, %rax movq %rax, 0x28(%rsp) leaq 0xa09bb(%rip), %rcx # 0x399a78 leaq 0x18(%rsp), %rbx movl $0x7, %edx movq %rbx, %rdi movq %r12, %rsi callq 0x149ce8 movq 0x8(%rbx), %rax movb $0x1, %cl movb %cl, 0x90(%rax) movb %cl, 0x92(%rax) addq $0x48, %rax leaq 0x230(%rsp), %r8 movq %rax, (%r8) movl %ebp, 0x8(%r8) xorps %xmm0, %xmm0 movups %xmm0, 0x10(%r8) movups %xmm0, 0x20(%r8) movq $0x0, 0x30(%r8) movq 0x158(%r12), %rcx movq %r12, %rdi movq %r12, %rsi movq %r14, %rdx callq 0x2fa9d6 movl $0x7ffff7ff, 0x90(%rax) # imm = 0x7FFFF7FF movq %rax, 0x78(%rsp) addq $0x50, %rax movq %rax, 0xe8(%rsp) xorl %r14d, %r14d leaq 0x48(%rsp), %rbx xorl %r15d, %r15d movq %r12, 0x10(%rsp) leaq 0x1df38c(%rip), %rax # 0x4d84e0 movq (%r15,%rax), %rax movq %rax, 0x2b8(%rsp) movq %r12, %rdi leaq 0x2b8(%rsp), %rsi leaq 0x7ea56(%rip), %rdx # 0x377bc8 callq 0x2faa42 movq %rax, %r12 movq 0x78(%rsp), %rax movq %rax, 0x48(%r12) movq 0x70(%rax), %rdx movq 0xe8(%rsp), %rdi movq %r12, %rsi xorl %ecx, %ecx movl $0x1, %r8d callq 0x1ee400 movl $0x20, 0xa0(%rsp) movw $0x1, 0xa4(%rsp) movq %r14, 0x98(%rsp) leaq 0x98(%rsp), %rdi callq 0xabbd4 movl 0xa0(%rsp), %eax movb 0xa4(%rsp), %cl movb 0xa5(%rsp), %dl movl %eax, 0x50(%rsp) movb %cl, 0x54(%rsp) movb %dl, 0x55(%rsp) cmpl $0x41, %eax setae %al orb %dl, %al testb $0x1, %al je 0x2f920d movq 0x98(%rsp), %rax movq $0x0, 0x98(%rsp) jmp 0x2f9215 movq 0x98(%rsp), %rax movq %rax, 0x48(%rsp) movb $0x1, 0x68(%rsp) movq %r12, %rdi movq %rbx, %rsi callq 0x156944 movq %rbx, %rbp movq %rbx, %rdi callq 0x696ee cmpl $0x40, 0xa0(%rsp) ja 0x2f9249 testb $0x1, 0xa5(%rsp) je 0x2f925b movq 0x98(%rsp), %rdi testq %rdi, %rdi je 0x2f925b callq 0xe17c5 movq 0x20(%rsp), %rbx leaq 0x48(%rbx), %r13 movq 0x10(%rsp), %rdi movq %r12, %rsi movq %rdi, %r12 callq 0x2faaa6 movq 0x68(%rbx), %rdx movq %r13, %rdi movq %rax, %rsi xorl %ecx, %ecx movl $0x1, %r8d callq 0x1ee400 addq $0x8, %r15 incq %r14 cmpq $0x28, %r15 movq %rbp, %rbx jne 0x2f914d leaq 0x7963d(%rip), %rsi # 0x3728e3 leaq 0x7e91b(%rip), %rdx # 0x377bc8 movq %r12, %rdi callq 0x2fab0a movq %rax, %rbx movq 0x78(%rsp), %rax movq %rax, 0x50(%rbx) leaq 0x18(%rsp), %r14 movq 0x8(%r14), %rdi movq 0x68(%rdi), %rdx addq $0x48, %rdi movq %rbx, %rsi xorl %ecx, %ecx movl $0x1, %r8d callq 0x1ee400 movq 0x188(%r12), %r13 movq 0x8(%r14), %r8 leaq 0x9789b(%rip), %rcx # 0x390b90 leaq 0x98(%rsp), %r15 movl $0x4, %edx movq %r15, %rdi movq %r14, %rsi xorl %r9d, %r9d callq 0x149d22 movq %r15, %rdi movl $0x4, %esi callq 0x149cdc leaq 0xb404e(%rip), %rcx # 0x3ad372 leaq 0x2b8(%rsp), %rdi leaq 0x18(%rsp), %rsi movl $0x6, %edx movq %rbx, %r8 xorl %r9d, %r9d callq 0x149d22 leaq 0x2b8(%rsp), %rdi callq 0x149b14 leaq 0xb72d3(%rip), %rcx # 0x3b0628 leaq 0x358(%rsp), %rdi leaq 0x18(%rsp), %rsi movl $0x4, %edx movq %r13, %r8 xorl %r9d, %r9d callq 0x149d22 leaq 0x358(%rsp), %rdi callq 0x149b14 leaq 0xb3ff3(%rip), %rcx # 0x3ad379 leaq 0x308(%rsp), %rdi leaq 0x18(%rsp), %rsi movl $0x5, %edx movq %r13, %r8 movl $0x1, %r9d callq 0x149d22 leaq 0x308(%rsp), %rdi callq 0x149b14 leaq 0xb3fc5(%rip), %rcx # 0x3ad37f leaq 0x1e0(%rsp), %rdi leaq 0x18(%rsp), %rsi movl $0x7, %edx movq %r13, %r8 xorl %r9d, %r9d callq 0x149d22 leaq 0x1e0(%rsp), %rdi callq 0x149b14 leaq 0xb3f9c(%rip), %rcx # 0x3ad387 leaq 0x190(%rsp), %rdi leaq 0x18(%rsp), %rsi movl $0x6, %edx movq %r13, %r8 xorl %r9d, %r9d callq 0x149d22 leaq 0x190(%rsp), %rdi callq 0x149b14 movq 0x180(%r12), %r8 leaq 0x7ee25(%rip), %rcx # 0x378249 leaq 0x140(%rsp), %rdi leaq 0x18(%rsp), %rsi movl $0xd, %edx xorl %r9d, %r9d callq 0x149d22 leaq 0x140(%rsp), %rdi callq 0x149b14 leaq 0x7ee13(%rip), %rcx # 0x378265 leaq 0xf0(%rsp), %rdi leaq 0x18(%rsp), %rsi movl $0x7, %edx movq %r13, %r8 xorl %r9d, %r9d callq 0x149d22 movq 0x70(%rsp), %r15 movq 0x158(%r12), %rcx leaq 0x30(%rsp), %r9 movb $0x0, 0x10(%r9) leaq 0xba2ed(%rip), %rdx # 0x3b377a leaq 0xf0(%rsp), %rdi movl $0x4, %esi xorl %r8d, %r8d callq 0x149b78 cmpb $0x1, 0x40(%rsp) movq 0x28(%rsp), %r12 jne 0x2f94d0 movb $0x0, 0x40(%rsp) cmpl $0x40, 0x38(%rsp) ja 0x2f94c1 testb $0x1, 0x3d(%rsp) je 0x2f94d0 movq 0x30(%rsp), %rdi testq %rdi, %rdi je 0x2f94d0 callq 0xe17c5 leaq 0x7ed80(%rip), %rcx # 0x378257 leaq 0x268(%rsp), %rdi leaq 0x18(%rsp), %rsi movl $0xd, %edx movq %r13, %r8 xorl %r9d, %r9d callq 0x149d22 movq 0x10(%rsp), %rax movq 0x180(%rax), %rcx leaq 0x90(%rsp), %r14 movb $0x0, (%r14) leaq 0x793d0(%rip), %rdx # 0x3728e3 leaq 0x268(%rsp), %rdi leaq 0x80(%rsp), %r9 movl $0x5, %esi xorl %r8d, %r8d callq 0x149b78 cmpb $0x1, 0x90(%rsp) jne 0x2f9568 movb $0x0, 0x90(%rsp) cmpl $0x40, 0x88(%rsp) ja 0x2f9556 testb $0x1, 0x8d(%rsp) je 0x2f9568 movq 0x80(%rsp), %rdi testq %rdi, %rdi je 0x2f9568 callq 0xe17c5 movq 0x20(%rsp), %rbx leaq 0x268(%rsp), %rdi callq 0x149b14 leaq 0xf0(%rsp), %rdi callq 0x149b14 leaq 0x98(%rsp), %rdi callq 0x149b14 movq 0x60(%r15), %rdx movq %r12, %rdi movq %rbx, %rsi xorl %ecx, %ecx movl $0x1, %r8d callq 0x1ee400 leaq 0xb3ddc(%rip), %rcx # 0x3ad38e leaq 0x268(%rsp), %rdi movl $0x9, %edx movq 0x10(%rsp), %rbx movq %rbx, %rsi callq 0x149ce8 movq 0x158(%rbx), %r13 movq 0x188(%rbx), %rbp movl $0x20, %ebx leaq 0x230(%rsp), %rdi movl %ebx, 0x8(%rdi) movw $0x1, %r14w movw %r14w, 0xc(%rdi) movq $0x0, (%rdi) callq 0xabbd4 leaq 0x48(%rsp), %rdi movl %ebx, 0x8(%rdi) movw %r14w, 0xc(%rdi) movq $0x1, (%rdi) callq 0xabbd4 leaq 0x7ec72(%rip), %rcx # 0x378292 leaq 0x98(%rsp), %rdi leaq 0x268(%rsp), %rsi movl $0x3, %edx movq %rbp, %r8 xorl %r9d, %r9d callq 0x149d22 leaq 0x98(%rsp), %rdi movl $0x8, %esi callq 0x149cdc leaq 0x1e0(%rsp), %rdi leaq 0x230(%rsp), %rsi callq 0x6b72e leaq 0x1e0(%rsp), %r9 movb $0x1, 0x10(%r9) leaq 0xb3d1d(%rip), %rdx # 0x3ad398 leaq 0x98(%rsp), %rdi movl $0x8, %esi movq %r13, %rcx xorl %r8d, %r8d callq 0x149b78 cmpb $0x1, 0x1f0(%rsp) jne 0x2f96cb movb $0x0, 0x1f0(%rsp) cmpl $0x40, 0x1e8(%rsp) ja 0x2f96b9 testb $0x1, 0x1ed(%rsp) je 0x2f96cb movq 0x1e0(%rsp), %rdi testq %rdi, %rdi je 0x2f96cb callq 0xe17c5 leaq 0xb3ce9(%rip), %rcx # 0x3ad3bb leaq 0x2b8(%rsp), %rdi leaq 0x268(%rsp), %rsi movl $0x3, %edx movq %rbp, %r8 xorl %r9d, %r9d callq 0x149d22 leaq 0x190(%rsp), %rdi leaq 0x48(%rsp), %rsi callq 0x6b72e leaq 0x190(%rsp), %r9 movb $0x1, 0x10(%r9) leaq 0xb3c80(%rip), %rdx # 0x3ad398 leaq 0x2b8(%rsp), %rdi movl $0x8, %esi movq %r13, %rcx xorl %r8d, %r8d callq 0x149b78 cmpb $0x1, 0x1a0(%rsp) jne 0x2f9768 movb $0x0, 0x1a0(%rsp) cmpl $0x40, 0x198(%rsp) ja 0x2f9756 testb $0x1, 0x19d(%rsp) je 0x2f9768 movq 0x190(%rsp), %rdi testq %rdi, %rdi je 0x2f9768 callq 0xe17c5 leaq 0xb6af2(%rip), %rcx # 0x3b0261 leaq 0x358(%rsp), %rdi leaq 0x268(%rsp), %rsi movl $0x3, %edx movq %rbp, %r8 movl $0x1, %r9d callq 0x149d22 leaq 0x140(%rsp), %rdi leaq 0x48(%rsp), %rsi callq 0x6b72e leaq 0x140(%rsp), %r9 movb $0x1, 0x10(%r9) leaq 0xb3be0(%rip), %rdx # 0x3ad398 leaq 0x358(%rsp), %rdi movl $0x8, %esi movq %r13, %rcx xorl %r8d, %r8d callq 0x149b78 cmpb $0x1, 0x150(%rsp) jne 0x2f9808 movb $0x0, 0x150(%rsp) cmpl $0x40, 0x148(%rsp) ja 0x2f97f6 testb $0x1, 0x14d(%rsp) je 0x2f9808 movq 0x140(%rsp), %rdi testq %rdi, %rdi je 0x2f9808 callq 0xe17c5 leaq 0xb3b92(%rip), %rcx # 0x3ad3a1 leaq 0x308(%rsp), %rdi leaq 0x268(%rsp), %rsi movl $0x7, %edx movq %r13, %r8 xorl %r9d, %r9d callq 0x149d22 leaq 0xf0(%rsp), %rdi leaq 0x48(%rsp), %rsi callq 0x6b72e leaq 0xf0(%rsp), %r9 movb $0x1, 0x10(%r9) leaq 0xb3b43(%rip), %rdx # 0x3ad398 leaq 0x308(%rsp), %rdi movl $0x8, %esi movq %r13, %rcx xorl %r8d, %r8d callq 0x149b78 cmpb $0x1, 0x100(%rsp) jne 0x2f98a5 movb $0x0, 0x100(%rsp) cmpl $0x40, 0xf8(%rsp) ja 0x2f9893 testb $0x1, 0xfd(%rsp) je 0x2f98a5 movq 0xf0(%rsp), %rdi testq %rdi, %rdi je 0x2f98a5 callq 0xe17c5 movq 0x270(%rsp), %rbx leaq 0x308(%rsp), %rdi callq 0x149b14 leaq 0x358(%rsp), %rdi callq 0x149b14 leaq 0x2b8(%rsp), %r14 movq %r14, %rdi callq 0x149b14 leaq 0x98(%rsp), %rdi callq 0x149b14 cmpl $0x40, 0x50(%rsp) ja 0x2f98f2 testb $0x1, 0x55(%rsp) je 0x2f9901 movq 0x48(%rsp), %rdi testq %rdi, %rdi je 0x2f9901 callq 0xe17c5 cmpl $0x40, 0x238(%rsp) ja 0x2f9915 testb $0x1, 0x23d(%rsp) je 0x2f9927 movq 0x230(%rsp), %rdi testq %rdi, %rdi je 0x2f9927 callq 0xe17c5 movq 0x60(%r15), %rdx movq %r12, %rdi movq %rbx, %rsi xorl %ecx, %ecx movl $0x1, %r8d callq 0x1ee400 movq 0x10(%rsp), %rdx leaq 0x4f0(%rdx), %rbp movq 0x4f0(%rdx), %rax movq 0x8(%rax), %rbx addq $0x7, %rbx andq $-0x8, %rbx leaq 0x2f0(%rbx), %rcx cmpq 0x4f8(%rdx), %rcx jbe 0x2f9984 movl $0x2f0, %esi # imm = 0x2F0 movl $0x8, %edx movq %rbp, %rdi callq 0xd7432 movq %rax, %rbx jmp 0x2f9988 movq %rcx, 0x8(%rax) leaq 0x7e239(%rip), %rsi # 0x377bc8 movq (%rsi), %rax movl $0x43, (%rbx) movq $0x7, 0x8(%rbx) leaq 0xb3a02(%rip), %rcx # 0x3ad3a9 movq %rcx, 0x10(%rbx) movq %rax, 0x18(%rbx) xorl %eax, %eax movq %rax, 0x38(%rbx) xorps %xmm0, %xmm0 movups %xmm0, 0x20(%rbx) movl %eax, 0x30(%rbx) movb %al, 0x40(%rbx) leaq 0x60(%rbx), %rcx movq %rcx, 0x48(%rbx) movq %rax, 0x50(%rbx) movq $0x8, 0x58(%rbx) movl $0x3f, %ecx movq %rcx, 0x260(%rbx) movl $0x1, %edx movq %rdx, 0x268(%rbx) movq %rax, 0x278(%rbx) leaq 0x77134(%rip), %r12 # 0x370b30 movq %r12, 0x270(%rbx) movups %xmm0, 0x280(%rbx) movq %rcx, 0x290(%rbx) movq %rdx, 0x298(%rbx) movq %rax, 0x2a8(%rbx) movq %r12, 0x2a0(%rbx) movups %xmm0, 0x2b0(%rbx) movb %al, 0x2c8(%rbx) movq %rax, 0x2d0(%rbx) movl %eax, 0x2d8(%rbx) leaq 0x4ab(%rip), %rax # 0x2f9ef2 movq %rax, 0x2e0(%rbx) movq %r14, 0x2e8(%rbx) movq (%rsi), %r14 movq 0x10(%rsp), %r13 movq %r13, %rdi movl $0x1ff, %esi # imm = 0x1FF callq 0x19e75c movq %rax, (%rsp) leaq 0x7a398(%rip), %rdx # 0x373e0d leaq 0x98(%rsp), %r15 movl $0x1, %esi movq %r15, %rdi movq %r14, %rcx xorl %r8d, %r8d movl $0x1, %r9d callq 0x34253c movq %rbx, %rdi movq %r15, %rsi callq 0xe937e movq 0x70(%rsp), %r15 movq 0x60(%r15), %rdx movq 0x28(%rsp), %r14 movq %r14, %rdi movq %rbx, %rsi xorl %ecx, %ecx movl $0x1, %r8d callq 0x1ee400 movq 0x158(%r13), %r8 leaq 0x7e760(%rip), %rcx # 0x378230 leaq 0x98(%rsp), %rbx movl $0x9, %edx movq %rbx, %rdi movq %r13, %rsi xorl %r9d, %r9d callq 0x149a48 movq %rbx, %rdi movl $0x400, %esi # imm = 0x400 callq 0x149cdc leaq 0x98(%rsp), %rdi movq 0x8(%rdi), %rbx callq 0x149b14 movq 0x60(%r15), %rdx movq %r14, %rdi movq %rbx, %rsi xorl %ecx, %ecx movl $0x1, %r8d callq 0x1ee400 movq 0x4f0(%r13), %rax movq 0x8(%rax), %rbx addq $0x7, %rbx andq $-0x8, %rbx leaq 0x2f0(%rbx), %rcx cmpq 0x4f8(%r13), %rcx jbe 0x2f9b5a movl $0x2f0, %esi # imm = 0x2F0 movl $0x8, %edx movq %rbp, %rdi callq 0xd7432 movq %rax, %rbx jmp 0x2f9b5e movq %rcx, 0x8(%rax) leaq 0x2b8(%rsp), %rdi leaq 0x7e05b(%rip), %rsi # 0x377bc8 movq (%rsi), %rax movl $0x43, (%rbx) movq $0xe, 0x8(%rbx) leaq 0xb3843(%rip), %rcx # 0x3ad3c8 movq %rcx, 0x10(%rbx) movq %rax, 0x18(%rbx) xorl %eax, %eax movq %rax, 0x38(%rbx) xorps %xmm0, %xmm0 movups %xmm0, 0x20(%rbx) movl %eax, 0x30(%rbx) movb %al, 0x40(%rbx) leaq 0x60(%rbx), %rcx movq %rcx, 0x48(%rbx) movq %rax, 0x50(%rbx) movq $0x8, 0x58(%rbx) movl $0x3f, %ecx movq %rcx, 0x260(%rbx) movl $0x1, %edx movq %rdx, 0x268(%rbx) movq %rax, 0x278(%rbx) movq %r12, 0x270(%rbx) movups %xmm0, 0x280(%rbx) movq %rcx, 0x290(%rbx) movq %rdx, 0x298(%rbx) movq %rax, 0x2a8(%rbx) movq %r12, 0x2a0(%rbx) movups %xmm0, 0x2b0(%rbx) movb %al, 0x2c8(%rbx) movq %rax, 0x2d0(%rbx) movl %eax, 0x2d8(%rbx) leaq 0xa3e(%rip), %rcx # 0x2fa65c movq %rcx, 0x2e0(%rbx) movq %rdi, 0x2e8(%rbx) movq (%rsi), %rcx movq %rax, (%rsp) leaq 0x7a1d3(%rip), %rdx # 0x373e0d leaq 0x98(%rsp), %r14 movl $0x1, %esi movq %r14, %rdi xorl %r8d, %r8d movl $0x1, %r9d callq 0x34253c movq %rbx, %rdi movq %r14, %rsi callq 0xe937e movq 0x60(%r15), %rdx movq 0x28(%rsp), %rdi movq %rbx, %rsi xorl %ecx, %ecx movl $0x1, %r8d callq 0x1ee400 movq %r15, %rax addq $0x3a8, %rsp # imm = 0x3A8 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x2f9ea4 movq %rax, %rbx cmpb $0x1, 0x100(%rsp) jne 0x2f9cd6 movb $0x0, 0x100(%rsp) cmpl $0x40, 0xf8(%rsp) ja 0x2f9cbf testb $0x1, 0xfd(%rsp) je 0x2f9cd6 movq 0xf0(%rsp), %rdi testq %rdi, %rdi je 0x2f9cd6 callq 0xe17c5 jmp 0x2f9cd6 movq %rax, %rbx leaq 0x308(%rsp), %rdi callq 0x149b14 jmp 0x2f9d27 jmp 0x2f9d24 movq %rax, %rbx cmpb $0x1, 0x150(%rsp) jne 0x2f9d27 movb $0x0, 0x150(%rsp) cmpl $0x40, 0x148(%rsp) ja 0x2f9d10 testb $0x1, 0x14d(%rsp) je 0x2f9d27 movq 0x140(%rsp), %rdi testq %rdi, %rdi je 0x2f9d27 callq 0xe17c5 jmp 0x2f9d27 movq %rax, %rbx leaq 0x358(%rsp), %rdi callq 0x149b14 jmp 0x2f9d78 jmp 0x2f9d75 movq %rax, %rbx cmpb $0x1, 0x1a0(%rsp) jne 0x2f9d78 movb $0x0, 0x1a0(%rsp) cmpl $0x40, 0x198(%rsp) ja 0x2f9d61 testb $0x1, 0x19d(%rsp) je 0x2f9d78 movq 0x190(%rsp), %rdi testq %rdi, %rdi je 0x2f9d78 callq 0xe17c5 jmp 0x2f9d78 movq %rax, %rbx leaq 0x2b8(%rsp), %rdi callq 0x149b14 jmp 0x2f9e5c jmp 0x2f9e59 movq %rax, %rbx cmpb $0x1, 0x1f0(%rsp) jne 0x2f9e5c movb $0x0, 0x1f0(%rsp) cmpl $0x40, 0x1e8(%rsp) ja 0x2f9dc0 testb $0x1, 0x1ed(%rsp) je 0x2f9e5c movq 0x1e0(%rsp), %rdi testq %rdi, %rdi je 0x2f9e5c callq 0xe17c5 jmp 0x2f9e5c movq %rax, %rbx jmp 0x2f9e69 movq %rax, %rbx jmp 0x2f9e86 movq %rax, %rbx cmpb $0x1, 0x90(%rsp) jne 0x2f9e08 leaq 0x80(%rsp), %rsi movq %r14, %rdi callq 0x450a9 leaq 0x268(%rsp), %rdi callq 0x149b14 jmp 0x2f9e48 movq %rax, %rbx jmp 0x2f9e48 movq %rax, %rbx cmpb $0x1, 0x40(%rsp) jne 0x2f9e48 movb $0x0, 0x40(%rsp) cmpl $0x40, 0x38(%rsp) ja 0x2f9e39 testb $0x1, 0x3d(%rsp) je 0x2f9e48 movq 0x30(%rsp), %rdi testq %rdi, %rdi je 0x2f9e48 callq 0xe17c5 leaq 0xf0(%rsp), %rdi callq 0x149b14 jmp 0x2f9ea7 jmp 0x2f9ea4 movq %rax, %rbx leaq 0x98(%rsp), %rdi callq 0x149b14 cmpl $0x40, 0x50(%rsp) ja 0x2f9e77 testb $0x1, 0x55(%rsp) je 0x2f9e86 movq 0x48(%rsp), %rdi testq %rdi, %rdi je 0x2f9e86 callq 0xe17c5 cmpl $0x40, 0x238(%rsp) ja 0x2f9e9a testb $0x1, 0x23d(%rsp) je 0x2f9ee9 movq 0x230(%rsp), %rdi jmp 0x2f9edf movq %rax, %rbx leaq 0x98(%rsp), %rdi callq 0x149b14 jmp 0x2f9ee9 movq %rax, %rbx leaq 0x48(%rsp), %rdi callq 0x696ee cmpl $0x40, 0xa0(%rsp) ja 0x2f9ed7 testb $0x1, 0xa5(%rsp) je 0x2f9ee9 movq 0x98(%rsp), %rdi testq %rdi, %rdi je 0x2f9ee9 callq 0xe17c5 movq %rbx, %rdi callq 0x37b10 nop	/MikePopoloski[P]slang/source/ast/builtins/StdPackage.cpp
slang::ast::SimpleAssertionExpr::checkNondegeneracyImpl() const	AssertionExpr::NondegeneracyCheckResult SimpleAssertionExpr::checkNondegeneracyImpl() const { // If simple sequence expression can be evaluated to false // then it admits no possible match. NondegeneracyCheckResult result; if (isNullExpr) { result.status \|= NondegeneracyStatus::AdmitsNoMatch; if (syntax) { result.noMatchRange = syntax->sourceRange(); result.isAlwaysFalse = true; } } if (repetition) result \|= repetition->checkNondegeneracy(); if (expr.kind == ExpressionKind::AssertionInstance) { auto& aie = expr.as<AssertionInstanceExpression>(); if (aie.type->isSequenceType()) result \|= aie.body.checkNondegeneracy(); } return result; }	pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x20, %rsp movq %rsi, %r14 movq %rdi, %rbx movl $0x0, (%rdi) xorps %xmm0, %xmm0 movups %xmm0, 0x8(%rdi) movb $0x0, 0x18(%rdi) xorl %ebp, %ebp movb $0x1, %al cmpb $0x1, 0x2c(%rsi) jne 0x30728c movl $0x4, (%rbx) movq 0x8(%r14), %rdi movl $0x4, %ebp testq %rdi, %rdi je 0x30728c callq 0xc9084 movq %rax, 0x8(%rbx) movq %rdx, 0x10(%rbx) movb $0x1, 0x18(%rbx) testl $0xfffffff, %eax # imm = 0xFFFFFFF sete %al leaq 0x8(%rbx), %r15 cmpb $0x1, 0x28(%r14) jne 0x3072ca xorl %ecx, %ecx cmpl $0x0, 0x1c(%r14) jne 0x3072b6 cmpl $0x0, 0x20(%r14) sete %cl andb 0x24(%r14), %cl movzbl %cl, %ecx leal 0x1(,%rcx,2), %ecx orl %ecx, %ebp movl %ebp, (%rbx) testb %al, %al je 0x3072ca xorps %xmm0, %xmm0 movups %xmm0, (%r15) movb $0x0, 0x10(%r15) movq 0x10(%r14), %r12 cmpl $0x27, (%r12) jne 0x307322 movq 0x8(%r12), %r14 movq 0x40(%r14), %rax testq %rax, %rax jne 0x3072ef movq %r14, %rdi callq 0x15f6a6 movq 0x40(%r14), %rax cmpl $0x20, (%rax) jne 0x307322 movq 0x38(%r12), %rsi movq %rsp, %r14 movq %r14, %rdi callq 0x306a0c orl (%r14), %ebp movl %ebp, (%rbx) testl $0xfffffff, 0x8(%rbx) # imm = 0xFFFFFFF jne 0x307322 movups 0x8(%rsp), %xmm0 movups %xmm0, (%r15) movb 0x18(%rsp), %al movb %al, 0x18(%rbx) movq %rbx, %rax addq $0x20, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq	/MikePopoloski[P]slang/source/ast/expressions/AssertionExpr.cpp
slang::ast::SequenceConcatExpr::serializeTo(slang::ast::ASTSerializer&) const	void SequenceConcatExpr::serializeTo(ASTSerializer& serializer) const { serializer.startArray("elements"); for (auto& elem : elements) { serializer.startObject(); serializer.write("sequence", *elem.sequence); elem.delay.serializeTo(serializer); serializer.endObject(); } serializer.endArray(); }	pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 leaq 0xa74e3(%rip), %rdx # 0x3aec50 movl $0x8, %esi movq %rbx, %rdi callq 0x161e18 movq 0x18(%r14), %rax testq %rax, %rax je 0x3077cf movq 0x10(%r14), %r14 shlq $0x3, %rax leaq (%rax,%rax,4), %r12 leaq 0x8e201(%rip), %r15 # 0x395997 movq %rbx, %rdi callq 0x161e3a movq 0x20(%r14), %rcx movl $0x8, %esi movq %rbx, %rdi movq %r15, %rdx callq 0x161b0e movq %r14, %rdi movq %rbx, %rsi callq 0x306f2a movq %rbx, %rdi callq 0x161e44 addq $0x28, %r14 addq $-0x28, %r12 jne 0x307796 movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 jmp 0x161e30	/MikePopoloski[P]slang/source/ast/expressions/AssertionExpr.cpp
slang::ast::SequenceWithMatchExpr::serializeTo(slang::ast::ASTSerializer&) const	void SequenceWithMatchExpr::serializeTo(ASTSerializer& serializer) const { serializer.write("expr", expr); if (repetition) { serializer.writeProperty("repetition"); repetition->serializeTo(serializer); } serializer.startArray("matchItems"); for (auto item : matchItems) serializer.serialize(*item); serializer.endArray(); }	pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq 0x10(%rdi), %rcx leaq 0x93e4e(%rip), %rdx # 0x39ba1d movl $0x4, %esi movq %rbx, %rdi callq 0x161b0e cmpb $0x1, 0x28(%r14) jne 0x307c06 leaq 0x18(%r14), %r15 leaq 0x9b475(%rip), %rdx # 0x3a3063 movl $0xa, %esi movq %rbx, %rdi callq 0x161e4e movq %r15, %rdi movq %rbx, %rsi callq 0x3070ba leaq 0xa704c(%rip), %rdx # 0x3aec59 movl $0xa, %esi movq %rbx, %rdi callq 0x161e18 movq 0x38(%r14), %r15 testq %r15, %r15 je 0x307c43 movq 0x30(%r14), %r14 shlq $0x3, %r15 xorl %r12d, %r12d movq (%r14,%r12), %rsi movq %rbx, %rdi callq 0x161856 addq $0x8, %r12 cmpq %r12, %r15 jne 0x307c2e movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 jmp 0x161e30	/MikePopoloski[P]slang/source/ast/expressions/AssertionExpr.cpp
boost::unordered::detail::foa::table_core<boost::unordered::detail::foa::flat_map_types<slang::ConstantValue, slang::SourceRange>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::table_arrays, boost::unordered::detail::foa::plain_size_control, slang::hash<slang::ConstantValue, void>, std::equal_to<slang::ConstantValue>, slang::detail::hashing::StackAllocator<std::pair<slang::ConstantValue const, slang::SourceRange>, 448ul, 16ul>>::nosize_transfer_element(std::pair<slang::ConstantValue const, slang::SourceRange>*, unsigned long, boost::unordered::detail::foa::table_arrays<std::pair<slang::ConstantValue const, slang::SourceRange>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::pow2_size_policy, slang::detail::hashing::StackAllocator<std::pair<slang::ConstantValue const, slang::SourceRange>, 448ul, 16ul>> const&, unsigned long&, std::integral_constant<bool, true>)	void nosize_transfer_element(element_type* p, std::size_t hash, const arrays_type& arrays_, std::size_t& num_destroyed, std::true_type /* ->move /) { / Destroy p even if an an exception is thrown in the middle of move * construction, which could leave the source half-moved. / ++num_destroyed; destroy_element_on_exit d{this, p}; (void)d; nosize_unchecked_emplace_at(arrays_, position_for(hash, arrays_), hash, type_policy::move(p)); }	pushq %r14 pushq %rbx subq $0x28, %rsp movq %rcx, %rax movq %rdx, %r10 incq (%r8) movq %rsi, %rbx movq %rdi, %rsi movb (%rcx), %cl movq %rdx, %r8 shrq %cl, %r8 leaq 0x28(%rbx), %rcx movq %rsp, %r9 movq %rbx, (%r9) movq %rcx, 0x8(%r9) leaq 0x10(%rsp), %rdi movq %rax, %rdx movq %r8, %rcx movq %r10, %r8 callq 0x3142f8 movq %rbx, %rdi callq 0x696ee addq $0x28, %rsp popq %rbx popq %r14 retq movq %rax, %r14 movq %rbx, %rdi callq 0x696ee movq %r14, %rdi callq 0x37b10	/MikePopoloski[P]slang/source/../external/boost_unordered.hpp
main	int main(){ int n; int all_nums[10] = {}; cin >> n; for (int i =0; i <n; i++){ int num; cin >> num; all_nums[num] ++; } for (int i = 0; i < 10; i++) if (all_nums[i]) cout << i << ':' << all_nums[i] << endl; return 0; }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x38, %rsp xorps %xmm0, %xmm0 movaps %xmm0, 0x20(%rsp) movaps %xmm0, 0x10(%rsp) andq $0x0, 0x30(%rsp) movq 0x2e00(%rip), %rbx # 0x3fe0 leaq 0xc(%rsp), %rsi movq %rbx, %rdi callq 0x1040 xorl %ebp, %ebp leaq 0x8(%rsp), %r14 cmpl 0xc(%rsp), %ebp jge 0x1212 movq %rbx, %rdi movq %r14, %rsi callq 0x1040 movslq 0x8(%rsp), %rax incl 0x10(%rsp,%rax,4) incl %ebp jmp 0x11f4 xorl %ebx, %ebx movq 0x2db5(%rip), %r14 # 0x3fd0 pushq $0x3a popq %rbp cmpq $0xa, %rbx je 0x125a movl 0x10(%rsp,%rbx,4), %r15d testl %r15d, %r15d je 0x1255 movq %r14, %rdi movl %ebx, %esi callq 0x1080 movq %rax, %rdi movl %ebp, %esi callq 0x1060 movq %rax, %rdi movl %r15d, %esi callq 0x1080 movq %rax, %rdi callq 0x1030 incq %rbx jmp 0x121e xorl %eax, %eax addq $0x38, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq	/vladimirlisovskij[P]prog/Tasks/Task19/task19.cpp
doctest::Context::parseArgs(int, char const* const*, bool)	void Context::parseArgs(int argc, const char* const* argv, bool withDefaults) { using namespace detail; // clang-format off parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "source-file=", p->filters[0]); parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sf=", p->filters[0]); parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "source-file-exclude=",p->filters[1]); parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sfe=", p->filters[1]); parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-suite=", p->filters[2]); parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "ts=", p->filters[2]); parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-suite-exclude=", p->filters[3]); parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tse=", p->filters[3]); parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-case=", p->filters[4]); parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tc=", p->filters[4]); parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-case-exclude=", p->filters[5]); parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tce=", p->filters[5]); parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "subcase=", p->filters[6]); parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sc=", p->filters[6]); parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "subcase-exclude=", p->filters[7]); parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sce=", p->filters[7]); parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "reporters=", p->filters[8]); parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "r=", p->filters[8]); // clang-format on int intRes = 0; String strRes; #define DOCTEST_PARSE_AS_BOOL_OR_FLAG(name, sname, var, default) \ if(parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name "=", option_bool, intRes) \|\| \ parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname "=", option_bool, intRes)) \ p->var = static_cast<bool>(intRes); \ else if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name) \|\| \ parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname)) \ p->var = true; \ else if(withDefaults) \ p->var = default #define DOCTEST_PARSE_INT_OPTION(name, sname, var, default) \ if(parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name "=", option_int, intRes) \|\| \ parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname "=", option_int, intRes)) \ p->var = intRes; \ else if(withDefaults) \ p->var = default #define DOCTEST_PARSE_STR_OPTION(name, sname, var, default) \ if(parseOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name "=", &strRes, default) \|\| \ parseOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname "=", &strRes, default) \|\| \ withDefaults) \ p->var = strRes // clang-format off DOCTEST_PARSE_STR_OPTION("out", "o", out, ""); DOCTEST_PARSE_STR_OPTION("order-by", "ob", order_by, "file"); DOCTEST_PARSE_INT_OPTION("rand-seed", "rs", rand_seed, 0); DOCTEST_PARSE_INT_OPTION("first", "f", first, 0); DOCTEST_PARSE_INT_OPTION("last", "l", last, UINT_MAX); DOCTEST_PARSE_INT_OPTION("abort-after", "aa", abort_after, 0); DOCTEST_PARSE_INT_OPTION("subcase-filter-levels", "scfl", subcase_filter_levels, INT_MAX); DOCTEST_PARSE_AS_BOOL_OR_FLAG("success", "s", success, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("case-sensitive", "cs", case_sensitive, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("exit", "e", exit, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("duration", "d", duration, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("minimal", "m", minimal, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("quiet", "q", quiet, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-throw", "nt", no_throw, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-exitcode", "ne", no_exitcode, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-run", "nr", no_run, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-intro", "ni", no_intro, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-version", "nv", no_version, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-colors", "nc", no_colors, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("force-colors", "fc", force_colors, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-breaks", "nb", no_breaks, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-skip", "ns", no_skip, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("gnu-file-line", "gfl", gnu_file_line, !bool(DOCTEST_MSVC)); DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-path-filenames", "npf", no_path_in_filenames, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-line-numbers", "nln", no_line_numbers, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-debug-output", "ndo", no_debug_output, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-skipped-summary", "nss", no_skipped_summary, false); DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-time-in-output", "ntio", no_time_in_output, false); // clang-format on if(withDefaults) { p->help = false; p->version = false; p->count = false; p->list_test_cases = false; p->list_test_suites = false; p->list_reporters = false; } if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "help") \|\| parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "h") \|\| parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "?")) { p->help = true; p->exit = true; } if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "version") \|\| parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "v")) { p->version = true; p->exit = true; } if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "count") \|\| parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "c")) { p->count = true; p->exit = true; } if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "list-test-cases") \|\| parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "ltc")) { p->list_test_cases = true; p->exit = true; } if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "list-test-suites") \|\| parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "lts")) { p->list_test_suites = true; p->exit = true; } if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "list-reporters") \|\| parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "lr")) { p->list_reporters = true; p->exit = true; } }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movl %ecx, %r15d movq %rdx, %r14 movl %esi, %ebp movq %rdi, %rbx movq (%rdi), %rax movq 0x10b8(%rax), %rcx leaq 0x2a05f(%rip), %rdx # 0x37d59 movl %esi, %edi movq %r14, %rsi callq 0xf17b movq (%rbx), %rax movq 0x10b8(%rax), %rcx leaq 0x2a054(%rip), %rdx # 0x37d69 movl %ebp, %edi movq %r14, %rsi callq 0xf17b movq (%rbx), %rax movq 0x10b8(%rax), %rcx addq $0x18, %rcx leaq 0x2a03c(%rip), %rdx # 0x37d70 movl %ebp, %edi movq %r14, %rsi callq 0xf17b movq (%rbx), %rax movq 0x10b8(%rax), %rcx addq $0x18, %rcx leaq 0x2a035(%rip), %rdx # 0x37d88 movl %ebp, %edi movq %r14, %rsi callq 0xf17b movq (%rbx), %rax movq 0x10b8(%rax), %rcx addq $0x30, %rcx leaq 0x2a01e(%rip), %rdx # 0x37d90 movl %ebp, %edi movq %r14, %rsi callq 0xf17b movq (%rbx), %rax movq 0x10b8(%rax), %rcx addq $0x30, %rcx leaq 0x2a00e(%rip), %rdx # 0x37d9f movl %ebp, %edi movq %r14, %rsi callq 0xf17b movq (%rbx), %rax movq 0x10b8(%rax), %rcx addq $0x48, %rcx leaq 0x29ff6(%rip), %rdx # 0x37da6 movl %ebp, %edi movq %r14, %rsi callq 0xf17b movq (%rbx), %rax movq 0x10b8(%rax), %rcx addq $0x48, %rcx leaq 0x29fee(%rip), %rdx # 0x37dbd movl %ebp, %edi movq %r14, %rsi callq 0xf17b movq (%rbx), %rax movq 0x10b8(%rax), %rcx addq $0x60, %rcx leaq 0x29fd7(%rip), %rdx # 0x37dc5 movl %ebp, %edi movq %r14, %rsi callq 0xf17b movq (%rbx), %rax movq 0x10b8(%rax), %rcx addq $0x60, %rcx leaq 0x29fc6(%rip), %rdx # 0x37dd3 movl %ebp, %edi movq %r14, %rsi callq 0xf17b movq (%rbx), %rax movq 0x10b8(%rax), %rcx addq $0x78, %rcx leaq 0x29fae(%rip), %rdx # 0x37dda movl %ebp, %edi movq %r14, %rsi callq 0xf17b movq (%rbx), %rax movq 0x10b8(%rax), %rcx addq $0x78, %rcx leaq 0x29fa5(%rip), %rdx # 0x37df0 movl %ebp, %edi movq %r14, %rsi callq 0xf17b movq (%rbx), %rax movl $0x90, %r12d movq 0x10b8(%rax), %rcx addq %r12, %rcx leaq 0x29f89(%rip), %rdx # 0x37df8 movl %ebp, %edi movq %r14, %rsi callq 0xf17b movq (%rbx), %rax addq 0x10b8(%rax), %r12 leaq 0x29f7a(%rip), %rdx # 0x37e04 movl %ebp, %edi movq %r14, %rsi movq %r12, %rcx callq 0xf17b movq (%rbx), %rax movl $0xa8, %r12d movq 0x10b8(%rax), %rcx addq %r12, %rcx leaq 0x29f5a(%rip), %rdx # 0x37e0b movl %ebp, %edi movq %r14, %rsi callq 0xf17b movq (%rbx), %rax addq 0x10b8(%rax), %r12 leaq 0x29f53(%rip), %rdx # 0x37e1f movl %ebp, %edi movq %r14, %rsi movq %r12, %rcx callq 0xf17b movq (%rbx), %rax movl $0xc0, %r12d movq 0x10b8(%rax), %rcx addq %r12, %rcx leaq 0x29f34(%rip), %rdx # 0x37e27 movl %ebp, %edi movq %r14, %rsi callq 0xf17b movq (%rbx), %rax addq 0x10b8(%rax), %r12 leaq 0x29f27(%rip), %rdx # 0x37e35 movl %ebp, %edi movq %r14, %rsi movq %r12, %rcx callq 0xf17b movl $0x0, 0x4(%rsp) movb $0x0, 0x20(%rsp) movb $0x17, 0x37(%rsp) leaq 0x29e12(%rip), %rsi # 0x37d46 leaq 0x8(%rsp), %rdi xorl %edx, %edx callq 0xadba leaq 0x29ef4(%rip), %rdx # 0x37e3b leaq 0x20(%rsp), %rcx leaq 0x8(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi callq 0xf33b movl %eax, %r13d movb $0x1, %r12b testb %al, %al jne 0xdf99 leaq 0x29dda(%rip), %rsi # 0x37d46 leaq 0x50(%rsp), %rdi xorl %edx, %edx callq 0xadba leaq 0x29ec4(%rip), %rdx # 0x37e43 leaq 0x20(%rsp), %rcx leaq 0x50(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi callq 0xf33b movl %eax, %r12d orb %r15b, %r12b testb %r13b, %r13b jne 0xdfb4 cmpb $0x0, 0x67(%rsp) jns 0xdfb4 movq 0x50(%rsp), %rdi testq %rdi, %rdi je 0xdfb4 callq 0x75e0 cmpb $0x0, 0x1f(%rsp) jns 0xdfca movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0xdfca callq 0x75e0 testb %r12b, %r12b je 0xdfe0 movq (%rbx), %rdi addq $0x28, %rdi leaq 0x20(%rsp), %rsi callq 0xae32 leaq 0x29e6f(%rip), %rsi # 0x37e56 leaq 0x8(%rsp), %rdi movl $0x4, %edx callq 0xadba leaq 0x29e4c(%rip), %rdx # 0x37e49 leaq 0x20(%rsp), %rcx leaq 0x8(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi callq 0xf33b movl %eax, %r13d movb $0x1, %r12b testb %al, %al jne 0xe052 leaq 0x29e34(%rip), %rsi # 0x37e56 leaq 0x38(%rsp), %rdi movl $0x4, %edx callq 0xadba leaq 0x29e23(%rip), %rdx # 0x37e5b leaq 0x20(%rsp), %rcx leaq 0x38(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi callq 0xf33b movl %eax, %r12d orb %r15b, %r12b testb %r13b, %r13b jne 0xe06d cmpb $0x0, 0x4f(%rsp) jns 0xe06d movq 0x38(%rsp), %rdi testq %rdi, %rdi je 0xe06d callq 0x75e0 cmpb $0x0, 0x1f(%rsp) jns 0xe083 movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0xe083 callq 0x75e0 testb %r12b, %r12b je 0xe099 movq (%rbx), %rdi addq $0x40, %rdi leaq 0x20(%rsp), %rsi callq 0xae32 leaq 0x29dc2(%rip), %rdx # 0x37e62 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi movl $0x1, %ecx callq 0xf399 testb %al, %al jne 0xe0db leaq 0x29db1(%rip), %rdx # 0x37e70 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi movl $0x1, %ecx callq 0xf399 testb %al, %al je 0xe69a movl 0x4(%rsp), %eax movq (%rbx), %rcx movl %eax, 0x58(%rcx) leaq 0x29d8b(%rip), %rdx # 0x37e77 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi movl $0x1, %ecx callq 0xf399 testb %al, %al jne 0xe127 leaq 0x29d76(%rip), %rdx # 0x37e81 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi movl $0x1, %ecx callq 0xf399 testb %al, %al je 0xe6aa movl 0x4(%rsp), %eax movq (%rbx), %rcx movl %eax, 0x5c(%rcx) leaq 0x29d4f(%rip), %rdx # 0x37e87 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi movl $0x1, %ecx callq 0xf399 testb %al, %al jne 0xe173 leaq 0x29d39(%rip), %rdx # 0x37e90 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi movl $0x1, %ecx callq 0xf399 testb %al, %al je 0xe6ba movl 0x4(%rsp), %eax movq (%rbx), %rcx movl %eax, 0x60(%rcx) leaq 0x29d12(%rip), %rdx # 0x37e96 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi movl $0x1, %ecx callq 0xf399 testb %al, %al jne 0xe1bf leaq 0x29d03(%rip), %rdx # 0x37ea6 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi movl $0x1, %ecx callq 0xf399 testb %al, %al je 0xe6cd movl 0x4(%rsp), %eax movq (%rbx), %rcx movl %eax, 0x64(%rcx) leaq 0x29cdd(%rip), %rdx # 0x37ead leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi movl $0x1, %ecx callq 0xf399 testb %al, %al jne 0xe20b leaq 0x29cd8(%rip), %rdx # 0x37ec7 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi movl $0x1, %ecx callq 0xf399 testb %al, %al je 0xe6dd movl 0x4(%rsp), %eax movq (%rbx), %rcx movl %eax, 0x68(%rcx) leaq 0x29cb4(%rip), %rdx # 0x37ed0 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xe251 leaq 0x29ca4(%rip), %rdx # 0x37edc leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xe6f0 cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x6c(%rax) leaq 0x29c8e(%rip), %rdx # 0x37ef2 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xe299 leaq 0x29c85(%rip), %rdx # 0x37f05 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xe72a cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x6d(%rax) leaq 0x29c78(%rip), %rdx # 0x37f24 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xe2e1 leaq 0x29c65(%rip), %rdx # 0x37f2d leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xe764 cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x6e(%rax) leaq 0x29c4c(%rip), %rdx # 0x37f40 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xe329 leaq 0x29c3d(%rip), %rdx # 0x37f4d leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xe79e cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x6f(%rax) leaq 0x29c28(%rip), %rdx # 0x37f64 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xe371 leaq 0x29c18(%rip), %rdx # 0x37f70 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xe7d8 cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x70(%rax) leaq 0x29c02(%rip), %rdx # 0x37f86 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xe3b9 leaq 0x29bf0(%rip), %rdx # 0x37f90 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xe812 cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x71(%rax) leaq 0x29bd8(%rip), %rdx # 0x37fa4 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xe401 leaq 0x29bc9(%rip), %rdx # 0x37fb1 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xe84c cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x72(%rax) leaq 0x29bb6(%rip), %rdx # 0x37fca leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xe449 leaq 0x29baa(%rip), %rdx # 0x37fda leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xe886 cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x73(%rax) leaq 0x29b9a(%rip), %rdx # 0x37ff6 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xe491 leaq 0x29b89(%rip), %rdx # 0x38001 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xe8c0 cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x74(%rax) leaq 0x29b74(%rip), %rdx # 0x38018 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xe4d9 leaq 0x29b65(%rip), %rdx # 0x38025 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xe8fa cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x75(%rax) leaq 0x29b52(%rip), %rdx # 0x3803e leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xe521 leaq 0x29b45(%rip), %rdx # 0x3804d leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xe934 cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x76(%rax) leaq 0x29b34(%rip), %rdx # 0x38068 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xe569 leaq 0x29b26(%rip), %rdx # 0x38076 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xe96e cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x77(%rax) leaq 0x29b14(%rip), %rdx # 0x38090 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xe5b1 leaq 0x29b09(%rip), %rdx # 0x380a1 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xe9a8 cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x78(%rax) leaq 0x29afa(%rip), %rdx # 0x380be leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xe5f9 leaq 0x29aec(%rip), %rdx # 0x380cc leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xe9e2 cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x79(%rax) leaq 0x29ada(%rip), %rdx # 0x380e6 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xe641 leaq 0x29aca(%rip), %rdx # 0x380f2 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xea1c cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x7a(%rax) leaq 0x29ab6(%rip), %rdx # 0x3810a leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xe689 leaq 0x29aac(%rip), %rdx # 0x3811c leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xea56 cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x7b(%rax) jmp 0xea8c xorl %eax, %eax testb %r15b, %r15b jne 0xe0df jmp 0xe0e5 xorl %eax, %eax testb %r15b, %r15b jne 0xe12b jmp 0xe131 movl $0xffffffff, %eax # imm = 0xFFFFFFFF testb %r15b, %r15b jne 0xe177 jmp 0xe17d xorl %eax, %eax testb %r15b, %r15b jne 0xe1c3 jmp 0xe1c9 movl $0x7fffffff, %eax # imm = 0x7FFFFFFF testb %r15b, %r15b jne 0xe20f jmp 0xe215 leaq 0x297eb(%rip), %rdx # 0x37ee2 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xe71e leaq 0x297e1(%rip), %rdx # 0x37eed movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xeec1 movq (%rbx), %rax movb $0x1, 0x6c(%rax) jmp 0xe25d leaq 0x297db(%rip), %rdx # 0x37f0c movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xe758 leaq 0x297d8(%rip), %rdx # 0x37f1e movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xeed6 movq (%rbx), %rax movb $0x1, 0x6d(%rax) jmp 0xe2a5 leaq 0x297c8(%rip), %rdx # 0x37f33 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xe792 leaq 0x297bb(%rip), %rdx # 0x37f3b movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xeeeb movq (%rbx), %rax movb $0x1, 0x6e(%rax) jmp 0xe2ed leaq 0x297ae(%rip), %rdx # 0x37f53 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xe7cc leaq 0x297a5(%rip), %rdx # 0x37f5f movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xef00 movq (%rbx), %rax movb $0x1, 0x6f(%rax) jmp 0xe335 leaq 0x29797(%rip), %rdx # 0x37f76 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xe806 leaq 0x2978d(%rip), %rdx # 0x37f81 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xef15 movq (%rbx), %rax movb $0x1, 0x70(%rax) jmp 0xe37d leaq 0x2977d(%rip), %rdx # 0x37f96 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xe840 leaq 0x29771(%rip), %rdx # 0x37f9f movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xef2a movq (%rbx), %rax movb $0x1, 0x71(%rax) jmp 0xe3c5 leaq 0x29765(%rip), %rdx # 0x37fb8 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xe87a leaq 0x2975c(%rip), %rdx # 0x37fc4 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xef3f movq (%rbx), %rax movb $0x1, 0x72(%rax) jmp 0xe40d leaq 0x29754(%rip), %rdx # 0x37fe1 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xe8b4 leaq 0x2974e(%rip), %rdx # 0x37ff0 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xef54 movq (%rbx), %rax movb $0x1, 0x73(%rax) jmp 0xe455 leaq 0x29741(%rip), %rdx # 0x38008 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xe8ee leaq 0x29736(%rip), %rdx # 0x38012 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xef69 movq (%rbx), %rax movb $0x1, 0x74(%rax) jmp 0xe49d leaq 0x2972b(%rip), %rdx # 0x3802c movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xe928 leaq 0x29722(%rip), %rdx # 0x38038 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xef7e movq (%rbx), %rax movb $0x1, 0x75(%rax) jmp 0xe4e5 leaq 0x29719(%rip), %rdx # 0x38054 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xe962 leaq 0x29712(%rip), %rdx # 0x38062 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xef93 movq (%rbx), %rax movb $0x1, 0x76(%rax) jmp 0xe52d leaq 0x29708(%rip), %rdx # 0x3807d movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xe99c leaq 0x29700(%rip), %rdx # 0x3808a movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xefa8 movq (%rbx), %rax movb $0x1, 0x77(%rax) jmp 0xe575 leaq 0x296f9(%rip), %rdx # 0x380a8 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xe9d6 leaq 0x296f4(%rip), %rdx # 0x380b8 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xefbd movq (%rbx), %rax movb $0x1, 0x78(%rax) jmp 0xe5bd leaq 0x296ea(%rip), %rdx # 0x380d3 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xea10 leaq 0x296e2(%rip), %rdx # 0x380e0 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xefd2 movq (%rbx), %rax movb $0x1, 0x79(%rax) jmp 0xe605 leaq 0x296d6(%rip), %rdx # 0x380f9 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xea4a leaq 0x296cc(%rip), %rdx # 0x38104 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xefe7 movq (%rbx), %rax movb $0x1, 0x7a(%rax) jmp 0xe64d leaq 0x296c7(%rip), %rdx # 0x38124 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xea85 leaq 0x296c3(%rip), %rdx # 0x38135 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xea85 testb %r15b, %r15b je 0xea8c movq (%rbx), %rax movb $0x1, 0x7b(%rax) leaq 0x296a9(%rip), %rdx # 0x3813c leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xeac8 leaq 0x296a3(%rip), %rdx # 0x38152 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xed9c cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x7c(%rax) leaq 0x2969b(%rip), %rdx # 0x38176 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xeb10 leaq 0x29693(%rip), %rdx # 0x3818a leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xedd6 cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x7d(%rax) leaq 0x29689(%rip), %rdx # 0x381ac leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xeb58 leaq 0x29681(%rip), %rdx # 0x381c0 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xee10 cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x7e(%rax) leaq 0x29677(%rip), %rdx # 0x381e2 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xeba0 leaq 0x29672(%rip), %rdx # 0x381f9 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xee4a cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x7f(%rax) leaq 0x2966b(%rip), %rdx # 0x3821e leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al jne 0xebe8 leaq 0x29665(%rip), %rdx # 0x38234 leaq 0x4(%rsp), %r8 movl %ebp, %edi movq %r14, %rsi xorl %ecx, %ecx callq 0xf399 testb %al, %al je 0xee84 cmpl $0x0, 0x4(%rsp) movq (%rbx), %rax setne 0x80(%rax) testb %r15b, %r15b je 0xec12 movq (%rbx), %rax movw $0x0, 0x85(%rax) movl $0x0, 0x81(%rax) leaq 0x29641(%rip), %rdx # 0x3825a movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xec51 leaq 0x29634(%rip), %rdx # 0x38262 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xec51 leaq 0x29624(%rip), %rdx # 0x38267 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xec5f movq (%rbx), %rax movb $0x1, %cl movb %cl, 0x81(%rax) movb %cl, 0x6e(%rax) leaq 0x29606(%rip), %rdx # 0x3826c movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xec89 leaq 0x295fc(%rip), %rdx # 0x38277 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xec97 movq (%rbx), %rax movb $0x1, %cl movb %cl, 0x82(%rax) movb %cl, 0x6e(%rax) leaq 0x295de(%rip), %rdx # 0x3827c movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xecc1 leaq 0x295d2(%rip), %rdx # 0x38285 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xeccf movq (%rbx), %rax movb $0x1, %cl movb %cl, 0x83(%rax) movb %cl, 0x6e(%rax) leaq 0x295b4(%rip), %rdx # 0x3828a movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xecf9 leaq 0x295b2(%rip), %rdx # 0x3829d movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xed07 movq (%rbx), %rax movb $0x1, %cl movb %cl, 0x84(%rax) movb %cl, 0x6e(%rax) leaq 0x29596(%rip), %rdx # 0x382a4 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xed31 leaq 0x29595(%rip), %rdx # 0x382b8 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xed3f movq (%rbx), %rax movb $0x1, %cl movb %cl, 0x85(%rax) movb %cl, 0x6e(%rax) leaq 0x29579(%rip), %rdx # 0x382bf movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xed69 leaq 0x29576(%rip), %rdx # 0x382d1 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xed77 movq (%rbx), %rax movb $0x1, %cl movb %cl, 0x86(%rax) movb %cl, 0x6e(%rax) cmpb $0x0, 0x37(%rsp) jns 0xed8d movq 0x20(%rsp), %rdi testq %rdi, %rdi je 0xed8d callq 0x75e0 addq $0x68, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq leaq 0x293b7(%rip), %rdx # 0x3815a movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xedca leaq 0x293b7(%rip), %rdx # 0x3816f movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xeffc movq (%rbx), %rax movb $0x1, 0x7c(%rax) jmp 0xead4 leaq 0x293b5(%rip), %rdx # 0x38192 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xee04 leaq 0x293b3(%rip), %rdx # 0x381a5 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xf011 movq (%rbx), %rax movb $0x1, 0x7d(%rax) jmp 0xeb1c leaq 0x293b1(%rip), %rdx # 0x381c8 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xee3e leaq 0x293af(%rip), %rdx # 0x381db movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xf026 movq (%rbx), %rax movb $0x1, 0x7e(%rax) jmp 0xeb64 leaq 0x293b0(%rip), %rdx # 0x38201 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xee78 leaq 0x293b1(%rip), %rdx # 0x38217 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xf03b movq (%rbx), %rax movb $0x1, 0x7f(%rax) jmp 0xebac leaq 0x293b2(%rip), %rdx # 0x3823d movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al jne 0xeeb2 leaq 0x293b2(%rip), %rdx # 0x38252 movl %ebp, %edi movq %r14, %rsi callq 0xf4c8 testb %al, %al je 0xf050 movq (%rbx), %rax movb $0x1, 0x80(%rax) jmp 0xebf7 testb %r15b, %r15b je 0xe25d movq (%rbx), %rax movb $0x0, 0x6c(%rax) jmp 0xe25d testb %r15b, %r15b je 0xe2a5 movq (%rbx), %rax movb $0x0, 0x6d(%rax) jmp 0xe2a5 testb %r15b, %r15b je 0xe2ed movq (%rbx), %rax movb $0x0, 0x6e(%rax) jmp 0xe2ed testb %r15b, %r15b je 0xe335 movq (%rbx), %rax movb $0x0, 0x6f(%rax) jmp 0xe335 testb %r15b, %r15b je 0xe37d movq (%rbx), %rax movb $0x0, 0x70(%rax) jmp 0xe37d testb %r15b, %r15b je 0xe3c5 movq (%rbx), %rax movb $0x0, 0x71(%rax) jmp 0xe3c5 testb %r15b, %r15b je 0xe40d movq (%rbx), %rax movb $0x0, 0x72(%rax) jmp 0xe40d testb %r15b, %r15b je 0xe455 movq (%rbx), %rax movb $0x0, 0x73(%rax) jmp 0xe455 testb %r15b, %r15b je 0xe49d movq (%rbx), %rax movb $0x0, 0x74(%rax) jmp 0xe49d testb %r15b, %r15b je 0xe4e5 movq (%rbx), %rax movb $0x0, 0x75(%rax) jmp 0xe4e5 testb %r15b, %r15b je 0xe52d movq (%rbx), %rax movb $0x0, 0x76(%rax) jmp 0xe52d testb %r15b, %r15b je 0xe575 movq (%rbx), %rax movb $0x0, 0x77(%rax) jmp 0xe575 testb %r15b, %r15b je 0xe5bd movq (%rbx), %rax movb $0x0, 0x78(%rax) jmp 0xe5bd testb %r15b, %r15b je 0xe605 movq (%rbx), %rax movb $0x0, 0x79(%rax) jmp 0xe605 testb %r15b, %r15b je 0xe64d movq (%rbx), %rax movb $0x0, 0x7a(%rax) jmp 0xe64d testb %r15b, %r15b je 0xead4 movq (%rbx), %rax movb $0x0, 0x7c(%rax) jmp 0xead4 testb %r15b, %r15b je 0xeb1c movq (%rbx), %rax movb $0x0, 0x7d(%rax) jmp 0xeb1c testb %r15b, %r15b je 0xeb64 movq (%rbx), %rax movb $0x0, 0x7e(%rax) jmp 0xeb64 testb %r15b, %r15b je 0xebac movq (%rbx), %rax movb $0x0, 0x7f(%rax) jmp 0xebac testb %r15b, %r15b je 0xec12 movq (%rbx), %rax movb $0x0, 0x80(%rax) jmp 0xebf7 movq %rax, %rbx cmpb $0x0, 0x4f(%rsp) jns 0xf09f movq 0x38(%rsp), %rdi jmp 0xf08a jmp 0xf09c movq %rax, %rbx cmpb $0x0, 0x67(%rsp) jns 0xf09f movq 0x50(%rsp), %rdi testq %rdi, %rdi je 0xf09f callq 0x75e0 jmp 0xf09f jmp 0xf09c jmp 0xf09c jmp 0xf0b9 movq %rax, %rbx cmpb $0x0, 0x1f(%rsp) jns 0xf0bc movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0xf0bc callq 0x75e0 jmp 0xf0bc jmp 0xf0b9 movq %rax, %rbx cmpb $0x0, 0x37(%rsp) jns 0xf0d2 movq 0x20(%rsp), %rdi testq %rdi, %rdi je 0xf0d2 callq 0x75e0 movq %rbx, %rdi callq 0x7860	/taskflow[P]taskflow/3rd-party/doctest/doctest.h
doctest::Context::applyCommandLine(int, char const* const*)	void Context::applyCommandLine(int argc, const char* const* argv) { parseArgs(argc, argv); if(argc) p->binary_name = argv[0]; }	pushq %rbp pushq %r14 pushq %rbx subq $0x20, %rsp movq %rdx, %r14 movl %esi, %ebp movq %rdi, %rbx xorl %ecx, %ecx callq 0xdcd0 testl %ebp, %ebp je 0xf172 movq (%r14), %r14 movq %r14, %rdi callq 0x71b0 leaq 0x8(%rsp), %rdi movq %r14, %rsi movl %eax, %edx callq 0xadba movq (%rbx), %rax leaq 0x8(%rax), %rbx cmpb $0x0, 0x1f(%rax) jns 0xf161 movq (%rbx), %rdi testq %rdi, %rdi je 0xf161 callq 0x75e0 movq 0x18(%rsp), %rax movq %rax, 0x10(%rbx) movups 0x8(%rsp), %xmm0 movups %xmm0, (%rbx) addq $0x20, %rsp popq %rbx popq %r14 popq %rbp retq	/taskflow[P]taskflow/3rd-party/doctest/doctest.h
doctest::(anonymous namespace)::parseCommaSepArgs(int, char const* const, char const, std::vector<doctest::String, std::allocator<doctest::String>>&)	bool parseCommaSepArgs(int argc, const char* const* argv, const char* pattern, std::vector<String>& res) { String filtersString; if(parseOption(argc, argv, pattern, &filtersString)) { // tokenize with "," as a separator, unless escaped with backslash std::ostringstream s; auto flush = [&s, &res]() { auto string = s.str(); if(string.size() > 0) { res.push_back(string.c_str()); } s.str(""); }; bool seenBackslash = false; const char* current = filtersString.c_str(); const char* end = current + strlen(current); while(current != end) { char character = *current++; if(seenBackslash) { seenBackslash = false; if(character == ',') { s.put(','); continue; } s.put('\\'); } if(character == '\\') { seenBackslash = true; } else if(character == ',') { flush(); } else { s.put(character); } } if(seenBackslash) { s.put('\\'); } flush(); return true; } return false; }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x1a8, %rsp # imm = 0x1A8 movq %rcx, %r14 xorl %eax, %eax leaq 0x8(%rsp), %rbx movb %al, (%rbx) movb $0x17, %cl movb %cl, 0x17(%rbx) leaq 0x30(%rsp), %r8 movb %al, (%r8) movb %cl, 0x17(%r8) movq %rbx, %rcx callq 0xf33b movl %eax, %ebp cmpb $0x0, 0x47(%rsp) jns 0xf1c9 movq 0x30(%rsp), %rdi testq %rdi, %rdi je 0xf1c9 callq 0x75e0 testb %bpl, %bpl je 0xf2b2 leaq 0x30(%rsp), %r15 movq %r15, %rdi callq 0x7660 movq %r15, 0x20(%rsp) movq %r14, 0x28(%rsp) cmpb $0x0, 0x1f(%rsp) jns 0xf1f5 movq 0x8(%rsp), %rbx movq %rbx, %rdi callq 0x71b0 testq %rax, %rax je 0xf28a movq %rax, %r14 xorl %r13d, %r13d leaq 0x30(%rsp), %r15 xorl %ebp, %ebp movzbl (%rbx,%r13), %r12d testb $0x1, %bpl je 0xf244 cmpl $0x2c, %r12d jne 0xf235 movq %r15, %rdi movl $0x2c, %esi callq 0x7040 xorl %ebp, %ebp jmp 0xf26d movq %r15, %rdi movl $0x5c, %esi callq 0x7040 xorl %ebp, %ebp cmpl $0x5c, %r12d je 0xf25c cmpl $0x2c, %r12d jne 0xf261 leaq 0x20(%rsp), %rdi callq 0x153ae jmp 0xf26d movb $0x1, %bpl jmp 0xf26d movsbl %r12b, %esi movq %r15, %rdi callq 0x7040 incq %r13 cmpq %r13, %r14 jne 0xf213 testb $0x1, %bpl je 0xf28a leaq 0x30(%rsp), %rdi movl $0x5c, %esi callq 0x7040 leaq 0x20(%rsp), %rdi callq 0x153ae movq 0x3bced(%rip), %rsi # 0x4af88 leaq 0x30(%rsp), %rdi callq 0x7230 leaq 0xa0(%rsp), %rdi callq 0x7160 cmpb $0x0, 0x1f(%rsp) jns 0xf2c8 movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0xf2c8 callq 0x75e0 addq $0x1a8, %rsp # imm = 0x1A8 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx jmp 0xf31d jmp 0xf2fc movq %rax, %rbx cmpb $0x0, 0x47(%rsp) jns 0xf31d movq 0x30(%rsp), %rdi testq %rdi, %rdi je 0xf31d callq 0x75e0 jmp 0xf31d movq %rax, %rbx movq 0x3bc82(%rip), %rsi # 0x4af88 leaq 0x30(%rsp), %rdi callq 0x7230 leaq 0xa0(%rsp), %rdi callq 0x7160 cmpb $0x0, 0x1f(%rsp) jns 0xf333 movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0xf333 callq 0x75e0 movq %rbx, %rdi callq 0x7860	/taskflow[P]taskflow/3rd-party/doctest/doctest.h
doctest::(anonymous namespace)::parseOption(int, char const* const, char const, doctest::String*, doctest::String const&)	bool parseOption(int argc, const char* const* argv, const char* pattern, String* value = nullptr, const String& defaultVal = String()) { if(value) *value = defaultVal; #ifndef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS // offset (normally 3 for "dt-") to skip prefix if(parseOptionImpl(argc, argv, pattern + strlen(DOCTEST_CONFIG_OPTIONS_PREFIX), value)) return true; #endif // DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS return parseOptionImpl(argc, argv, pattern, value); }	pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rcx, %rbx movq %rdx, %r14 movq %rsi, %r15 movl %edi, %ebp testq %rcx, %rcx je 0xf35d movq %rbx, %rdi movq %r8, %rsi callq 0xae32 leaq 0x3(%r14), %rdx movl %ebp, %edi movq %r15, %rsi movq %rbx, %rcx callq 0x154d8 testb %al, %al je 0xf37f movb $0x1, %al addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movl %ebp, %edi movq %r15, %rsi movq %r14, %rdx movq %rbx, %rcx addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp jmp 0x154d8	/taskflow[P]taskflow/3rd-party/doctest/doctest.h
doctest::(anonymous namespace)::parseIntOption(int, char const* const, char const, doctest::(anonymous namespace)::optionType, int&)	bool parseIntOption(int argc, const char* const* argv, const char* pattern, optionType type, int& res) { String parsedValue; if(!parseOption(argc, argv, pattern, &parsedValue)) return false; if(type == 0) { // boolean const char positive[][5] = {"1", "true", "on", "yes"}; // 5 - strlen("true") + 1 const char negative[][6] = {"0", "false", "off", "no"}; // 6 - strlen("false") + 1 // if the value matches any of the positive/negative possibilities for(unsigned i = 0; i < 4; i++) { if(parsedValue.compare(positive[i], true) == 0) { res = 1; //!OCLINT parameter reassignment return true; } if(parsedValue.compare(negative[i], true) == 0) { res = 0; //!OCLINT parameter reassignment return true; } } } else { // integer // TODO: change this to use std::stoi or something else! currently it uses undefined behavior - assumes '0' on failed parse... int theInt = std::atoi(parsedValue.c_str()); // NOLINT if(theInt != 0) { res = theInt; //!OCLINT parameter reassignment return true; } } return false; }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %r8, %rbx movl %ecx, %ebp xorl %eax, %eax leaq 0x8(%rsp), %r14 movb %al, (%r14) movb $0x17, %cl movb %cl, 0x17(%r14) leaq 0x20(%rsp), %r8 movb %al, (%r8) movb %cl, 0x17(%r8) movq %r14, %rcx callq 0xf33b movl %eax, %r15d cmpb $0x0, 0x37(%rsp) jns 0xf3e9 movq 0x20(%rsp), %rdi testq %rdi, %rdi je 0xf3e9 callq 0x75e0 testb %r15b, %r15b je 0xf460 testl %ebp, %ebp je 0xf40e cmpb $0x0, 0x1f(%rsp) jns 0xf3fe movq 0x8(%rsp), %r14 movq %r14, %rdi callq 0x7720 movl %eax, %ebp testl %eax, %eax jne 0xf466 jmp 0xf460 leaq 0x27d9b(%rip), %r14 # 0x371b0 xorl %r12d, %r12d leaq 0x8(%rsp), %r15 leaq 0x27dac(%rip), %r13 # 0x371d0 movl $0x1, %ebp movq %r15, %rdi movq %r14, %rsi movl $0x1, %edx callq 0xb056 testl %eax, %eax je 0xf466 leaq (%r12,%r13), %rsi movq %r15, %rdi movl $0x1, %edx callq 0xb056 testl %eax, %eax je 0xf464 addq $0x5, %r14 addq $0x6, %r12 cmpq $0x18, %r12 jne 0xf429 xorl %ebx, %ebx jmp 0xf46a xorl %ebp, %ebp movl %ebp, (%rbx) movb $0x1, %bl cmpb $0x0, 0x1f(%rsp) jns 0xf480 movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0xf480 callq 0x75e0 movl %ebx, %eax addq $0x38, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx cmpb $0x0, 0x37(%rsp) jns 0xf4aa movq 0x20(%rsp), %rdi testq %rdi, %rdi je 0xf4aa callq 0x75e0 cmpb $0x0, 0x1f(%rsp) jns 0xf4c0 movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0xf4c0 callq 0x75e0 movq %rbx, %rdi callq 0x7860	/taskflow[P]taskflow/3rd-party/doctest/doctest.h
doctest::(anonymous namespace)::parseFlag(int, char const* const, char const)	bool parseFlag(int argc, const char* const* argv, const char* pattern) { return parseOption(argc, argv, pattern); }	pushq %rbx subq $0x20, %rsp leaq 0x8(%rsp), %r8 movb $0x0, (%r8) movb $0x17, 0x17(%r8) xorl %ecx, %ecx callq 0xf33b movl %eax, %ebx cmpb $0x0, 0x1f(%rsp) jns 0xf4fa movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0xf4fa callq 0x75e0 movl %ebx, %eax addq $0x20, %rsp popq %rbx retq movq %rax, %rbx cmpb $0x0, 0x1f(%rsp) jns 0xf51b movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0xf51b callq 0x75e0 movq %rbx, %rdi callq 0x7860 nop	/taskflow[P]taskflow/3rd-party/doctest/doctest.h
doctest::Context::setOption(char const, char const)	void Context::setOption(const char* option, const char* value) { auto argv = String("-") + option + "=" + value; auto lvalue = argv.c_str(); parseArgs(1, &lvalue); }	pushq %r15 pushq %r14 pushq %rbx subq $0xb0, %rsp movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %rbx leaq 0x299aa(%rip), %rsi # 0x38ef0 leaq 0x80(%rsp), %rdi movl $0x1, %edx callq 0xadba movq %r15, %rdi callq 0x71b0 leaq 0x68(%rsp), %rdi movq %r15, %rsi movl %eax, %edx callq 0xadba leaq 0x98(%rsp), %rdi leaq 0x80(%rsp), %rsi leaq 0x68(%rsp), %rdx callq 0xb10a leaq 0x2891b(%rip), %rsi # 0x37eab leaq 0x50(%rsp), %rdi movl $0x1, %edx callq 0xadba leaq 0x8(%rsp), %rdi leaq 0x98(%rsp), %rsi leaq 0x50(%rsp), %rdx callq 0xb10a movq %r14, %rdi callq 0x71b0 leaq 0x38(%rsp), %rdi movq %r14, %rsi movl %eax, %edx callq 0xadba leaq 0x20(%rsp), %r14 leaq 0x8(%rsp), %rsi leaq 0x38(%rsp), %rdx movq %r14, %rdi callq 0xb10a cmpb $0x0, 0x4f(%rsp) jns 0xf5fa movq 0x38(%rsp), %rdi testq %rdi, %rdi je 0xf5fa callq 0x75e0 cmpb $0x0, 0x1f(%rsp) jns 0xf610 movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0xf610 callq 0x75e0 cmpb $0x0, 0x67(%rsp) jns 0xf626 movq 0x50(%rsp), %rdi testq %rdi, %rdi je 0xf626 callq 0x75e0 cmpb $0x0, 0xaf(%rsp) jns 0xf642 movq 0x98(%rsp), %rdi testq %rdi, %rdi je 0xf642 callq 0x75e0 cmpb $0x0, 0x7f(%rsp) jns 0xf658 movq 0x68(%rsp), %rdi testq %rdi, %rdi je 0xf658 callq 0x75e0 cmpb $0x0, 0x97(%rsp) jns 0xf674 movq 0x80(%rsp), %rdi testq %rdi, %rdi je 0xf674 callq 0x75e0 cmpb $0x0, 0x37(%rsp) jns 0xf680 movq 0x20(%rsp), %r14 leaq 0x8(%rsp), %rdx movq %r14, (%rdx) movq %rbx, %rdi movl $0x1, %esi xorl %ecx, %ecx callq 0xdcd0 cmpb $0x0, 0x37(%rsp) jns 0xf6ad movq 0x20(%rsp), %rdi testq %rdi, %rdi je 0xf6ad callq 0x75e0 addq $0xb0, %rsp popq %rbx popq %r14 popq %r15 retq movq %rax, %rbx cmpb $0x0, 0x37(%rsp) jns 0xf77e movq 0x20(%rsp), %rdi jmp 0xf774 movq %rax, %rbx cmpb $0x0, 0x4f(%rsp) jns 0xf6f0 movq 0x38(%rsp), %rdi testq %rdi, %rdi je 0xf6f0 callq 0x75e0 jmp 0xf6f0 movq %rax, %rbx cmpb $0x0, 0x1f(%rsp) jns 0xf70b movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0xf70b callq 0x75e0 jmp 0xf70b movq %rax, %rbx cmpb $0x0, 0x67(%rsp) jns 0xf726 movq 0x50(%rsp), %rdi testq %rdi, %rdi je 0xf726 callq 0x75e0 jmp 0xf726 movq %rax, %rbx cmpb $0x0, 0xaf(%rsp) jns 0xf747 movq 0x98(%rsp), %rdi testq %rdi, %rdi je 0xf747 callq 0x75e0 jmp 0xf747 movq %rax, %rbx cmpb $0x0, 0x7f(%rsp) jns 0xf762 movq 0x68(%rsp), %rdi testq %rdi, %rdi je 0xf762 callq 0x75e0 jmp 0xf762 movq %rax, %rbx cmpb $0x0, 0x97(%rsp) jns 0xf77e movq 0x80(%rsp), %rdi testq %rdi, %rdi je 0xf77e callq 0x75e0 movq %rbx, %rdi callq 0x7860	/taskflow[P]taskflow/3rd-party/doctest/doctest.h
doctest::(anonymous namespace)::XmlReporter::test_case_end(doctest::CurrentTestCaseStats const&)	void test_case_end(const CurrentTestCaseStats& st) override { xml.startElement("OverallResultsAsserts") .writeAttribute("successes", st.numAssertsCurrentTest - st.numAssertsFailedCurrentTest) .writeAttribute("failures", st.numAssertsFailedCurrentTest) .writeAttribute("test_case_success", st.testCaseSuccess); if(opt.duration) xml.writeAttribute("duration", st.seconds); if(tc->m_expected_failures) xml.writeAttribute("expected_failures", tc->m_expected_failures); xml.endElement(); xml.endElement(); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x88, %rsp movq %rsi, %r15 movq %rdi, %r14 leaq 0x10(%rsp), %r13 movq %r13, -0x10(%r13) leaq 0x224c4(%rip), %rsi # 0x391b3 leaq 0x224d2(%rip), %rdx # 0x391c8 movq %rsp, %rdi callq 0x337dc leaq 0x8(%r14), %rbx movq %rsp, %rsi movq %rbx, %rdi callq 0x17e9e leaq 0x78(%rsp), %rbp movq %rbp, -0x10(%rbp) leaq 0x224ac(%rip), %rsi # 0x391c9 leaq 0x224ae(%rip), %rdx # 0x391d2 leaq 0x68(%rsp), %rdi callq 0x337dc movl (%r15), %eax subl 0x4(%r15), %eax leaq 0x44(%rsp), %rdx movl %eax, (%rdx) leaq 0x68(%rsp), %rsi movq %rbx, %rdi callq 0x17fb8 leaq 0x30(%rsp), %rax movq %rax, -0x10(%rax) leaq 0x224be(%rip), %rsi # 0x39217 leaq 0x224bf(%rip), %rdx # 0x3921f leaq 0x20(%rsp), %rdi callq 0x337dc leaq 0x4(%r15), %rdx leaq 0x20(%rsp), %rsi movq %rbx, %rdi callq 0x17fb8 leaq 0x58(%rsp), %r12 movq %r12, -0x10(%r12) leaq 0x22470(%rip), %rsi # 0x391fc leaq 0x2247a(%rip), %rdx # 0x3920d leaq 0x48(%rsp), %rdi callq 0x337dc movzbl 0x14(%r15), %edx leaq 0x48(%rsp), %rsi movq %rbx, %rdi callq 0x1884a movq 0x48(%rsp), %rdi cmpq %r12, %rdi je 0x16dc6 movq 0x58(%rsp), %rsi incq %rsi callq 0x74c0 movq 0x20(%rsp), %rdi leaq 0x30(%rsp), %rax cmpq %rax, %rdi je 0x16de2 movq 0x30(%rsp), %rsi incq %rsi callq 0x74c0 movq 0x68(%rsp), %rdi cmpq %rbp, %rdi je 0x16df9 movq 0x78(%rsp), %rsi incq %rsi callq 0x74c0 movq (%rsp), %rdi cmpq %r13, %rdi je 0x16e0f movq 0x10(%rsp), %rsi incq %rsi callq 0x74c0 movq 0x78(%r14), %rax cmpb $0x1, 0x6f(%rax) jne 0x16e5a movq %rsp, %rdi movq %r13, (%rdi) leaq 0x21130(%rip), %rsi # 0x37f56 leaq 0x21131(%rip), %rdx # 0x37f5e callq 0x337dc addq $0x8, %r15 movq %rsp, %rsi movq %rbx, %rdi movq %r15, %rdx callq 0x18d42 movq (%rsp), %rdi cmpq %r13, %rdi je 0x16e5a movq 0x10(%rsp), %rsi incq %rsi callq 0x74c0 movq 0x80(%r14), %rax cmpl $0x0, 0x40(%rax) je 0x16eac movq %rsp, %rdi movq %r13, (%rdi) leaq 0x2239a(%rip), %rsi # 0x3920e leaq 0x223a4(%rip), %rdx # 0x3921f callq 0x337dc movq 0x80(%r14), %rdx addq $0x40, %rdx movq %rsp, %rsi movq %rbx, %rdi callq 0x17fb8 movq (%rsp), %rdi cmpq %r13, %rdi je 0x16eac movq 0x10(%rsp), %rsi incq %rsi callq 0x74c0 movq %rbx, %rdi callq 0x17d84 movq %rbx, %rdi callq 0x17d84 addq $0x88, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x16f35 jmp 0x16f50 jmp 0x16f35 jmp 0x16f50 movq %rax, %rbx movq 0x48(%rsp), %rdi cmpq %r12, %rdi je 0x16ef7 movq 0x58(%rsp), %rsi incq %rsi callq 0x74c0 jmp 0x16ef7 jmp 0x16ef4 movq %rax, %rbx movq 0x20(%rsp), %rdi leaq 0x30(%rsp), %rax cmpq %rax, %rdi je 0x16f1a movq 0x30(%rsp), %rsi incq %rsi callq 0x74c0 jmp 0x16f1a jmp 0x16f17 movq %rax, %rbx movq 0x68(%rsp), %rdi cmpq %rbp, %rdi je 0x16f38 movq 0x78(%rsp), %rsi incq %rsi callq 0x74c0 jmp 0x16f38 jmp 0x16f35 movq %rax, %rbx movq (%rsp), %rdi cmpq %r13, %rdi je 0x16f53 movq 0x10(%rsp), %rsi incq %rsi callq 0x74c0 jmp 0x16f53 movq %rax, %rbx movq %rbx, %rdi callq 0x7860 nop	/taskflow[P]taskflow/3rd-party/doctest/doctest.h
doctest::(anonymous namespace)::XmlWriter::endElement()	XmlWriter& XmlWriter::endElement() { newlineIfNecessary(); m_indent = m_indent.substr( 0, m_indent.size()-2 ); if( m_tagIsOpen ) { m_os << "/>"; m_tagIsOpen = false; } else { m_os << m_indent << "</" << m_tags.back() << ">"; } m_os << std::endl; m_tags.pop_back(); return *this; }	pushq %r15 pushq %r14 pushq %rbx subq $0x20, %rsp movq %rdi, %rbx callq 0x17f74 leaq 0x20(%rbx), %r14 movq 0x28(%rbx), %rcx addq $-0x2, %rcx movq %rsp, %r15 movq %r15, %rdi movq %r14, %rsi xorl %edx, %edx callq 0x74e0 movq %r14, %rdi movq %r15, %rsi callq 0x75c0 movq (%r15), %rdi leaq 0x10(%rsp), %rax cmpq %rax, %rdi je 0x17dd6 movq 0x10(%rsp), %rsi incq %rsi callq 0x74c0 movq 0x40(%rbx), %rdi cmpb $0x1, (%rbx) jne 0x17df5 leaq 0x2134a(%rip), %rsi # 0x39130 movl $0x2, %edx callq 0x7550 movb $0x0, (%rbx) jmp 0x17e41 movq 0x20(%rbx), %rsi movq 0x28(%rbx), %rdx callq 0x7550 movq %rax, %r14 leaq 0x21327(%rip), %rsi # 0x39133 movl $0x2, %edx movq %rax, %rdi callq 0x7550 movq 0x10(%rbx), %rax movq -0x20(%rax), %rsi movq -0x18(%rax), %rdx movq %r14, %rdi callq 0x7550 leaq 0x212fd(%rip), %rsi # 0x39131 movl $0x1, %edx movq %rax, %rdi callq 0x7550 movq 0x40(%rbx), %r14 movq (%r14), %rax movq -0x18(%rax), %rdi addq %r14, %rdi movl $0xa, %esi callq 0x7480 movsbl %al, %esi movq %r14, %rdi callq 0x7040 movq %rax, %rdi callq 0x72f0 movq 0x10(%rbx), %rax leaq -0x20(%rax), %rcx movq %rcx, 0x10(%rbx) movq -0x20(%rax), %rdi addq $-0x10, %rax cmpq %rax, %rdi je 0x17e90 movq (%rax), %rsi incq %rsi callq 0x74c0 movq %rbx, %rax addq $0x20, %rsp popq %rbx popq %r14 popq %r15 retq nop	/taskflow[P]taskflow/3rd-party/doctest/doctest.h
doctest::(anonymous namespace)::XmlWriter::writeAttribute(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&)	XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) { if( !name.empty() && !attribute.empty() ) m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"'; return *this; }	pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rdi, %rbx cmpq $0x0, 0x8(%rsi) je 0x1815e movq %rdx, %r14 cmpq $0x0, 0x8(%rdx) je 0x1815e movq %rsi, %r15 movq 0x40(%rbx), %rdi leaq 0x10(%rsp), %rsi movb $0x20, (%rsi) movl $0x1, %edx callq 0x7550 movq (%r15), %rsi movq 0x8(%r15), %rdx movq %rax, %rdi callq 0x7550 movq %rax, %r15 leaq 0x20f6f(%rip), %rsi # 0x39060 movl $0x2, %edx movq %rax, %rdi callq 0x7550 leaq 0x20(%rsp), %r12 movq %r12, -0x10(%r12) movq (%r14), %rsi movq 0x8(%r14), %rdx addq %rsi, %rdx leaq 0x10(%rsp), %r14 movq %r14, %rdi callq 0x2feb6 movl $0x1, 0x20(%r14) movq %r15, %rdi movq %r14, %rsi callq 0x1818f leaq 0xf(%rsp), %rsi movb $0x22, (%rsi) movl $0x1, %edx movq %r15, %rdi callq 0x7550 movq 0x10(%rsp), %rdi cmpq %r12, %rdi je 0x1815e movq 0x20(%rsp), %rsi incq %rsi callq 0x74c0 movq %rbx, %rax addq $0x38, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq movq %rax, %rbx movq 0x10(%rsp), %rdi cmpq %r12, %rdi je 0x18187 movq 0x20(%rsp), %rsi incq %rsi callq 0x74c0 movq %rbx, %rdi callq 0x7860	/taskflow[P]taskflow/3rd-party/doctest/doctest.h
doctest::(anonymous namespace)::ConsoleReporter::report_query(doctest::QueryData const&)	void report_query(const QueryData& in) override { if(opt.version) { printVersion(); } else if(opt.help) { printHelp(); } else if(opt.list_reporters) { printRegisteredReporters(); } else if(opt.count \|\| opt.list_test_cases) { if(opt.list_test_cases) { s << Color::Cyan << "[doctest] " << Color::None << "listing all test case names\n"; separator_to_stream(); } for(unsigned i = 0; i < in.num_data; ++i) s << Color::None << in.data[i]->m_name << "\n"; separator_to_stream(); s << Color::Cyan << "[doctest] " << Color::None << "unskipped test cases passing the current filters: " << g_cs->numTestCasesPassingFilters << "\n"; } else if(opt.list_test_suites) { s << Color::Cyan << "[doctest] " << Color::None << "listing all test suites\n"; separator_to_stream(); for(unsigned i = 0; i < in.num_data; ++i) s << Color::None << in.data[i]->m_test_suite << "\n"; separator_to_stream(); s << Color::Cyan << "[doctest] " << Color::None << "unskipped test cases passing the current filters: " << g_cs->numTestCasesPassingFilters << "\n"; s << Color::Cyan << "[doctest] " << Color::None << "test suites with unskipped test cases passing the current filters: " << g_cs->numTestSuitesPassingFilters << "\n"; } }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdi, %rbx movq 0x60(%rdi), %rax cmpb $0x1, 0x82(%rax) jne 0x1b597 movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp jmp 0x1d0fe cmpb $0x1, 0x81(%rax) jne 0x1bfcb movq %rbx, %rdi callq 0x1d0fe movq 0x8(%rbx), %r14 movq %r14, %rdi movl $0x5, %esi callq 0xb2cb leaq 0x1deb8(%rip), %r15 # 0x3947c movl $0xa, %edx movq %r14, %rdi movq %r15, %rsi callq 0x7550 movq %r14, %rdi xorl %esi, %esi callq 0xb2cb movq 0x8(%rbx), %r12 movq %r12, %rdi movl $0x5, %esi callq 0xb2cb leaq 0x1e70b(%rip), %r14 # 0x39d01 movl $0xa, %edx movq %r12, %rdi movq %r14, %rsi callq 0x7550 movq %r12, %rdi xorl %esi, %esi callq 0xb2cb movq 0x8(%rbx), %rdi leaq 0x1de6c(%rip), %rsi # 0x39487 movl $0x34, %edx callq 0x7550 movq 0x8(%rbx), %r12 movq %r12, %rdi movl $0x5, %esi callq 0xb2cb movl $0xa, %edx movq %r12, %rdi movq %r14, %rsi callq 0x7550 movq %r12, %rdi xorl %esi, %esi callq 0xb2cb movq 0x8(%rbx), %rdi leaq 0x1de61(%rip), %rsi # 0x394bc movl $0x3b, %edx callq 0x7550 movq 0x8(%rbx), %r12 movq %r12, %rdi movl $0x5, %esi callq 0xb2cb movl $0xa, %edx movq %r12, %rdi movq %r15, %rsi callq 0x7550 movq %r12, %rdi xorl %esi, %esi callq 0xb2cb movq 0x8(%rbx), %r12 movq %r12, %rdi movl $0x5, %esi callq 0xb2cb movl $0xa, %edx movq %r12, %rdi movq %r14, %rsi callq 0x7550 movq %r12, %rdi xorl %esi, %esi callq 0xb2cb movq 0x8(%rbx), %rdi leaq 0x1de32(%rip), %rsi # 0x394f8 movl $0x2b, %edx callq 0x7550 movq 0x8(%rbx), %r12 movq %r12, %rdi movl $0x5, %esi callq 0xb2cb movl $0xa, %edx movq %r12, %rdi movq %r14, %rsi callq 0x7550 movq %r12, %rdi xorl %esi, %esi callq 0xb2cb movq 0x8(%rbx), %rdi leaq 0x1de1e(%rip), %rsi # 0x39524 movl $0x44, %edx callq 0x7550 movq 0x8(%rbx), %r12 movq %r12, %rdi movl $0x5, %esi callq 0xb2cb movl $0xa, %edx movq %r12, %rdi movq %r15, %rsi callq 0x7550 movq %r12, %rdi xorl %esi, %esi callq 0xb2cb movq 0x8(%rbx), %r12 movq %r12, %rdi movl $0x5, %esi callq 0xb2cb movl $0xa, %edx movq %r12, %rdi movq %r14, %rsi callq 0x7550 movq %r12, %rdi xorl %esi, %esi callq 0xb2cb movq 0x8(%rbx), %rdi leaq 0x1ddf8(%rip), %rsi # 0x39569 movl $0x45, %edx callq 0x7550 movq 0x8(%rbx), %r12 movq %r12, %rdi movl $0x5, %esi callq 0xb2cb movl $0xa, %edx movq %r12, %rdi movq %r15, %rsi callq 0x7550 movq %r12, %rdi xorl %esi, %esi callq 0xb2cb movq 0x8(%rbx), %r15 movq %r15, %rdi movl $0x5, %esi callq 0xb2cb movl $0xa, %edx movq %r15, %rdi movq %r14, %rsi callq 0x7550 movq %r15, %rdi xorl %esi, %esi callq 0xb2cb movq 0x8(%rbx), %rdi leaq 0x1ddd3(%rip), %rsi # 0x395af movl $0x38, %edx callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1ddf7(%rip), %rsi # 0x395e8 movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1de0b(%rip), %rsi # 0x39610 movl $0x14, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1de08(%rip), %rsi # 0x39625 movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1de1c(%rip), %rsi # 0x3964d movl $0x13, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1de18(%rip), %rsi # 0x39661 movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1de2c(%rip), %rsi # 0x39689 movl $0x24, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1de39(%rip), %rsi # 0x396ae movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1de4d(%rip), %rsi # 0x396d6 movl $0x21, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1de57(%rip), %rsi # 0x396f8 movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1de6b(%rip), %rsi # 0x39720 movl $0x1f, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1de73(%rip), %rsi # 0x39740 movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1de87(%rip), %rsi # 0x39768 movl $0x20, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 movq %r15, %rdi movl $0x5, %esi callq 0xb2cb movl $0xa, %edx movq %r15, %rdi movq %r14, %rsi callq 0x7550 movq %r15, %rdi xorl %esi, %esi callq 0xb2cb movq 0x8(%rbx), %rdi leaq 0x1de65(%rip), %rsi # 0x39789 movl $0x33, %edx callq 0x7550 movq 0x8(%rbx), %r14 leaq 0x1de84(%rip), %rsi # 0x397bd movl $0x27, %edx movq %r14, %rdi callq 0x7550 leaq 0x1de98(%rip), %rsi # 0x397e5 movl $0x20, %edx movq %r14, %rdi callq 0x7550 movq 0x8(%rbx), %r14 leaq 0x1dea1(%rip), %rsi # 0x39806 movl $0x27, %edx movq %r14, %rdi callq 0x7550 leaq 0x1deb5(%rip), %rsi # 0x3982e movl $0x20, %edx movq %r14, %rdi callq 0x7550 movq 0x8(%rbx), %r14 leaq 0x1debe(%rip), %rsi # 0x3984f movl $0x27, %edx movq %r14, %rdi callq 0x7550 leaq 0x1ded2(%rip), %rsi # 0x39877 movl $0x20, %edx movq %r14, %rdi callq 0x7550 movq 0x8(%rbx), %r14 leaq 0x1dedb(%rip), %rsi # 0x39898 movl $0x27, %edx movq %r14, %rdi callq 0x7550 leaq 0x1deef(%rip), %rsi # 0x398c0 movl $0x20, %edx movq %r14, %rdi callq 0x7550 movq 0x8(%rbx), %r14 leaq 0x1def8(%rip), %rsi # 0x398e1 movl $0x27, %edx movq %r14, %rdi callq 0x7550 leaq 0x1df0c(%rip), %rsi # 0x39909 movl $0x26, %edx movq %r14, %rdi callq 0x7550 movq 0x8(%rbx), %r14 leaq 0x1df1b(%rip), %rsi # 0x39930 movl $0x27, %edx movq %r14, %rdi callq 0x7550 leaq 0x1df2f(%rip), %rsi # 0x39958 movl $0x26, %edx movq %r14, %rdi callq 0x7550 movq 0x8(%rbx), %r14 leaq 0x1df3e(%rip), %rsi # 0x3997f movl $0x27, %edx movq %r14, %rdi callq 0x7550 leaq 0x1df52(%rip), %rsi # 0x399a7 movl $0x23, %edx movq %r14, %rdi callq 0x7550 movq 0x8(%rbx), %r14 leaq 0x1df5e(%rip), %rsi # 0x399cb movl $0x27, %edx movq %r14, %rdi callq 0x7550 leaq 0x1df72(%rip), %rsi # 0x399f3 movl $0x23, %edx movq %r14, %rdi callq 0x7550 movq 0x8(%rbx), %r14 leaq 0x1df7e(%rip), %rsi # 0x39a17 movl $0x27, %edx movq %r14, %rdi callq 0x7550 leaq 0x1df92(%rip), %rsi # 0x39a3f movl $0x26, %edx movq %r14, %rdi callq 0x7550 movq 0x8(%rbx), %r14 leaq 0x1dfa1(%rip), %rsi # 0x39a66 movl $0x27, %edx movq %r14, %rdi callq 0x7550 leaq 0x1dfb5(%rip), %rsi # 0x39a8e movl $0x10, %edx movq %r14, %rdi callq 0x7550 movq 0x8(%rbx), %r14 leaq 0x1dfae(%rip), %rsi # 0x39a9f movl $0x27, %edx movq %r14, %rdi callq 0x7550 leaq 0x1dfc2(%rip), %rsi # 0x39ac7 movl $0x20, %edx movq %r14, %rdi callq 0x7550 movq 0x8(%rbx), %rdi leaq 0x1dfcb(%rip), %rsi # 0x39ae8 movl $0x4e, %edx callq 0x7550 movq 0x8(%rbx), %r14 leaq 0x1e005(%rip), %rsi # 0x39b37 movl $0x27, %edx movq %r14, %rdi callq 0x7550 leaq 0x1e019(%rip), %rsi # 0x39b5f movl $0x19, %edx movq %r14, %rdi callq 0x7550 movq 0x8(%rbx), %r14 leaq 0x1e01b(%rip), %rsi # 0x39b79 movl $0x27, %edx movq %r14, %rdi callq 0x7550 leaq 0x1e02f(%rip), %rsi # 0x39ba1 movl $0x26, %edx movq %r14, %rdi callq 0x7550 movq 0x8(%rbx), %rdi leaq 0x1e03e(%rip), %r14 # 0x39bc8 movl $0x4b, %edx movq %r14, %rsi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e072(%rip), %rsi # 0x39c14 movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e086(%rip), %rsi # 0x39c3c movl $0x25, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %rdi movl $0x4b, %edx movq %r14, %rsi callq 0x7550 movq 0x8(%rbx), %r14 leaq 0x1e083(%rip), %rsi # 0x39c62 movl $0x27, %edx movq %r14, %rdi callq 0x7550 leaq 0x1e097(%rip), %rsi # 0x39c8a movl $0x23, %edx movq %r14, %rdi callq 0x7550 movq 0x8(%rbx), %r14 leaq 0x1e0a3(%rip), %rsi # 0x39cae movl $0x27, %edx movq %r14, %rdi callq 0x7550 leaq 0x1e0b7(%rip), %rsi # 0x39cd6 movl $0x29, %edx movq %r14, %rdi callq 0x7550 movq 0x8(%rbx), %r15 movq %r15, %rdi movl $0x5, %esi callq 0xb2cb leaq 0x1e0bc(%rip), %r14 # 0x39d00 movl $0xb, %edx movq %r15, %rdi movq %r14, %rsi callq 0x7550 movq %r15, %rdi xorl %esi, %esi callq 0xb2cb movq 0x8(%rbx), %rdi leaq 0x1e0a3(%rip), %rsi # 0x39d0c movl $0x47, %edx callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e0d6(%rip), %rsi # 0x39d54 movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e0ea(%rip), %rsi # 0x39d7c movl $0x28, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e0fb(%rip), %rsi # 0x39da5 movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e10f(%rip), %rsi # 0x39dcd movl $0x28, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e120(%rip), %rsi # 0x39df6 movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e134(%rip), %rsi # 0x39e1e movl $0x1d, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e13a(%rip), %rsi # 0x39e3c movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e14e(%rip), %rsi # 0x39e64 movl $0x26, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e15d(%rip), %rsi # 0x39e8b movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e171(%rip), %rsi # 0x39eb3 movl $0x27, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e181(%rip), %rsi # 0x39edb movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e195(%rip), %rsi # 0x39f03 movl $0x12, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e190(%rip), %rsi # 0x39f16 movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e1a4(%rip), %rsi # 0x39f3e movl $0x27, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e1b4(%rip), %rsi # 0x39f66 movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e1c8(%rip), %rsi # 0x39f8e movl $0x27, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e1d8(%rip), %rsi # 0x39fb6 movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e1ec(%rip), %rsi # 0x39fde movl $0x25, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e1fa(%rip), %rsi # 0x3a004 movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e20e(%rip), %rsi # 0x3a02c movl $0x27, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e21e(%rip), %rsi # 0x3a054 movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e232(%rip), %rsi # 0x3a07c movl $0x29, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e244(%rip), %rsi # 0x3a0a6 movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e258(%rip), %rsi # 0x3a0ce movl $0x1a, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e25b(%rip), %rsi # 0x3a0e9 movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e26f(%rip), %rsi # 0x3a111 movl $0x22, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e27a(%rip), %rsi # 0x3a134 movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e28e(%rip), %rsi # 0x3a15c movl $0x22, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e299(%rip), %rsi # 0x3a17f movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e2ad(%rip), %rsi # 0x3a1a7 movl $0x25, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e2bb(%rip), %rsi # 0x3a1cd movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e2cf(%rip), %rsi # 0x3a1f5 movl $0x27, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e2df(%rip), %rsi # 0x3a21d movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e2f3(%rip), %rsi # 0x3a245 movl $0x26, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 leaq 0x1e302(%rip), %rsi # 0x3a26c movl $0x27, %edx movq %r15, %rdi callq 0x7550 leaq 0x1e316(%rip), %rsi # 0x3a294 movl $0x29, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 movq %r15, %rdi movl $0x5, %esi callq 0xb2cb movl $0xb, %edx movq %r15, %rdi movq %r14, %rsi callq 0x7550 movq %r15, %rdi xorl %esi, %esi callq 0xb2cb movq 0x8(%rbx), %rdi leaq 0x1e2fd(%rip), %rsi # 0x3a2be movl $0x36, %edx jmp 0x1c1b9 cmpb $0x1, 0x86(%rax) jne 0x1c027 movq %rbx, %rdi callq 0x1d0fe movq %rsp, %r14 movq %rbx, (%r14) callq 0x10713 leaq 0x2fc4a(%rip), %rsi # 0x4bc38 leaq 0x1e300(%rip), %rdx # 0x3a2f5 movq %r14, %rdi callq 0x1d19e callq 0x106fd leaq 0x2fbf7(%rip), %rsi # 0x4bc00 leaq 0x1c2b7(%rip), %rdx # 0x382c7 movq %r14, %rdi callq 0x1d19e addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rsi, %r14 cmpb $0x0, 0x83(%rax) jne 0x1c040 cmpb $0x1, 0x84(%rax) jne 0x1c1cc cmpb $0x1, 0x84(%rax) jne 0x1c0b1 movq 0x8(%rbx), %r15 movq %r15, %rdi movl $0x5, %esi callq 0xb2cb leaq 0x1dca0(%rip), %rsi # 0x39d01 movl $0xa, %edx movq %r15, %rdi callq 0x7550 movq %r15, %rdi xorl %esi, %esi callq 0xb2cb leaq 0x1d36e(%rip), %rsi # 0x393ed movl $0x1c, %edx movq %r15, %rdi callq 0x7550 movq 0x8(%rbx), %r15 movq %r15, %rdi movl $0x6, %esi callq 0xb2cb leaq 0x1e286(%rip), %rsi # 0x3a32a movl $0x50, %edx movq %r15, %rdi callq 0x7550 cmpl $0x0, 0x10(%r14) je 0x1c12d xorl %ebp, %ebp leaq 0x1dc91(%rip), %r15 # 0x39d52 movq 0x8(%rbx), %r12 movq %r12, %rdi xorl %esi, %esi callq 0xb2cb movq 0x8(%r14), %rax movq (%rax,%rbp,8), %rax movq 0x20(%rax), %r13 testq %r13, %r13 je 0x1c0f8 movq %r13, %rdi callq 0x71b0 movq %r12, %rdi movq %r13, %rsi movq %rax, %rdx callq 0x7550 jmp 0x1c111 movq (%r12), %rax movq -0x18(%rax), %rax leaq (%r12,%rax), %rdi movl 0x20(%r12,%rax), %esi orl $0x1, %esi callq 0x77f0 movl $0x1, %edx movq %r12, %rdi movq %r15, %rsi callq 0x7550 incq %rbp movl 0x10(%r14), %eax cmpq %rax, %rbp jb 0x1c0c1 movq 0x8(%rbx), %r14 movq %r14, %rdi movl $0x6, %esi callq 0xb2cb leaq 0x1e1e5(%rip), %rsi # 0x3a32a movl $0x50, %edx movq %r14, %rdi callq 0x7550 movq 0x8(%rbx), %rbx movq %rbx, %rdi movl $0x5, %esi callq 0xb2cb leaq 0x1db97(%rip), %rsi # 0x39d01 movl $0xa, %edx movq %rbx, %rdi callq 0x7550 movq %rbx, %rdi xorl %esi, %esi callq 0xb2cb leaq 0x1d2ac(%rip), %rsi # 0x39434 movl $0x32, %edx movq %rbx, %rdi callq 0x7550 movq 0x2f36c(%rip), %rax # 0x4b508 movl 0x8c(%rax), %esi movq %rbx, %rdi callq 0x72e0 leaq 0x1dba1(%rip), %rsi # 0x39d52 movl $0x1, %edx movq %rax, %rdi addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp jmp 0x7550 cmpb $0x1, 0x85(%rax) jne 0x1c018 movq 0x8(%rbx), %r15 movq %r15, %rdi movl $0x5, %esi callq 0xb2cb leaq 0x1db10(%rip), %rsi # 0x39d01 movl $0xa, %edx movq %r15, %rdi callq 0x7550 movq %r15, %rdi xorl %esi, %esi callq 0xb2cb leaq 0x1d1fb(%rip), %rsi # 0x3940a movl $0x18, %edx movq %r15, %rdi callq 0x7550 movq %rbx, %rdi callq 0x1d176 cmpl $0x0, 0x10(%r14) je 0x1c2a0 xorl %ebp, %ebp leaq 0x1db1e(%rip), %r15 # 0x39d52 movq 0x8(%rbx), %r12 movq %r12, %rdi xorl %esi, %esi callq 0xb2cb movq 0x8(%r14), %rax movq (%rax,%rbp,8), %rax movq 0x28(%rax), %r13 testq %r13, %r13 je 0x1c26b movq %r13, %rdi callq 0x71b0 movq %r12, %rdi movq %r13, %rsi movq %rax, %rdx callq 0x7550 jmp 0x1c284 movq (%r12), %rax movq -0x18(%rax), %rax leaq (%r12,%rax), %rdi movl 0x20(%r12,%rax), %esi orl $0x1, %esi callq 0x77f0 movl $0x1, %edx movq %r12, %rdi movq %r15, %rsi callq 0x7550 incq %rbp movl 0x10(%r14), %eax cmpq %rax, %rbp jb 0x1c234 movq %rbx, %rdi callq 0x1d176 movq 0x8(%rbx), %r15 movq %r15, %rdi movl $0x5, %esi callq 0xb2cb leaq 0x1da41(%rip), %r14 # 0x39d01 movl $0xa, %edx movq %r15, %rdi movq %r14, %rsi callq 0x7550 movq %r15, %rdi xorl %esi, %esi callq 0xb2cb leaq 0x1d153(%rip), %rsi # 0x39434 movl $0x32, %edx movq %r15, %rdi callq 0x7550 movq 0x2f213(%rip), %rax # 0x4b508 movl 0x8c(%rax), %esi movq %r15, %rdi callq 0x72e0 leaq 0x1da48(%rip), %r15 # 0x39d52 movl $0x1, %edx movq %rax, %rdi movq %r15, %rsi callq 0x7550 movq 0x8(%rbx), %rbx movq %rbx, %rdi movl $0x5, %esi callq 0xb2cb movl $0xa, %edx movq %rbx, %rdi movq %r14, %rsi callq 0x7550 movq %rbx, %rdi xorl %esi, %esi callq 0xb2cb leaq 0x1d0d7(%rip), %rsi # 0x39423 movl $0x43, %edx movq %rbx, %rdi callq 0x7550 movq 0x2f1a8(%rip), %rax # 0x4b508 movl 0x90(%rax), %esi movq %rbx, %rdi callq 0x72e0 movl $0x1, %edx movq %rax, %rdi movq %r15, %rsi jmp 0x1c1b9	/taskflow[P]taskflow/3rd-party/doctest/doctest.h
tf::Executor::_tear_down_dependent_async(tf::Worker&, tf::Node, tf::Node&)	inline void Executor::_tear_down_dependent_async(Worker& worker, Node* node, Node*& cache) { auto handle = std::get_if<Node::DependentAsync>(&(node->_handle)); // this async task comes from Executor auto target = ASTATE::UNFINISHED; while(!handle->state.compare_exchange_weak(target, ASTATE::FINISHED, std::memory_order_acq_rel, std::memory_order_relaxed)) { target = ASTATE::UNFINISHED; } // spawn successors whenever their dependencies are resolved for(size_t i=0; i<node->_edges.size(); ++i) { if(auto s = node->_edges[i]; s->_join_counter.fetch_sub(1, std::memory_order_acq_rel) == 1 ) { _update_cache(worker, cache, s); } } // now the executor no longer needs to retain ownership if(handle->use_count.fetch_sub(1, std::memory_order_acq_rel) == 1) { recycle(node); } _decrement_topology(); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rcx, %r12 movq %rdx, %r14 movq %rsi, 0x10(%rsp) movq %rdi, %r13 xorl %ebp, %ebp cmpb $0x8, 0xc0(%rdx) leaq 0x88(%rdx), %rax movq %rax, 0x8(%rsp) cmoveq %rax, %rbp movl $0x2, %ecx xorl %eax, %eax lock cmpxchgl %ecx, 0x30(%rbp) jne 0x2b8d4 movq 0x48(%r14), %rax cmpq %rax, 0x50(%r14) je 0x2b929 xorl %r15d, %r15d movq (%rax,%r15,8), %rbx lock decq 0x80(%rbx) jne 0x2b912 movq (%r12), %rdx testq %rdx, %rdx je 0x2b90e movq %r13, %rdi movq 0x10(%rsp), %rsi callq 0x275f2 movq %rbx, (%r12) incq %r15 movq 0x48(%r14), %rax movq 0x50(%r14), %rcx subq %rax, %rcx sarq $0x3, %rcx cmpq %rcx, %r15 jb 0x2b8ea lock decq 0x28(%rbp) setne %al testq %r14, %r14 je 0x2b9b4 testb %al, %al jne 0x2b9b4 cmpq $0x0, 0xd0(%r14) je 0x2b950 leaq 0xd0(%r14), %rdi callq 0x73c0 movq 0xc8(%r14), %rsi testq %rsi, %rsi je 0x2b968 leaq 0xc8(%r14), %rdi callq 0x28090 movq $0x0, 0xc8(%r14) movq 0x8(%rsp), %rdi callq 0x28058 movq 0x48(%r14), %rdi leaq 0x60(%r14), %rax cmpq %rax, %rdi je 0x2b98f callq 0x7590 movq 0x8(%r14), %rdi leaq 0x18(%r14), %rax cmpq %rax, %rdi je 0x2b9a7 movq (%rax), %rsi incq %rsi callq 0x74c0 movl $0xd8, %esi movq %r14, %rdi callq 0x74c0 leaq 0x90(%r13), %r14 movq %r14, %rdi callq 0x76f0 testl %eax, %eax jne 0x2b9f2 decq 0xb8(%r13) jne 0x2b9dc addq $0x60, %r13 movq %r13, %rdi callq 0x7800 movq %r14, %rdi addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp jmp 0x7370 movl %eax, %edi callq 0x72c0 nop	/taskflow[P]taskflow/taskflow/core/async.hpp
tf::NonblockingNotifierV2::notify_n(unsigned long)	void notify_n(size_t n) { if(n >= _waiters.size()) { _notify<true>(); } else { for(size_t k=0; k<n; ++k) { _notify<false>(); } } }	pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq 0x10(%rdi), %rax subq 0x8(%rdi), %rax sarq $0x7, %rax cmpq %rsi, %rax jbe 0x2c26d movq %rsi, %r14 testq %rsi, %rsi je 0x2c265 movq %rbx, %rdi callq 0x27794 decq %r14 jne 0x2c258 addq $0x8, %rsp popq %rbx popq %r14 retq movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %r14 jmp 0x2c318	/taskflow[P]taskflow/taskflow/core/nonblocking_notifier.hpp
tf::Node** tf::SmallVectorImpl<tf::Node>::insert<tf::Node>(tf::Node, tf::Node, tf::Node*)	iterator insert(iterator I, ItTy From, ItTy To) { // Convert iterator to elt# to avoid invalidating iterator when we reserve() size_t InsertElt = I - this->begin(); if (I == this->end()) { // Important special case for empty vector. append(From, To); return this->begin()+InsertElt; } //assert(I >= this->begin() && "Insertion iterator is out of bounds."); //assert(I <= this->end() && "Inserting past the end of the vector."); size_t NumToInsert = std::distance(From, To); // Ensure there is enough space. reserve(this->size() + NumToInsert); // Uninvalidate the iterator. I = this->begin()+InsertElt; // If there are more elements between the insertion point and the end of the // range than there are being inserted, we can use a simple approach to // insertion. Since we already reserved space, we know that this won't // reallocate the vector. if (size_t(this->end()-I) >= NumToInsert) { T OldEnd = this->end(); append(std::move_iterator<iterator>(this->end() - NumToInsert), std::move_iterator<iterator>(this->end())); // Copy the existing elements that get replaced. std::move_backward(I, OldEnd-NumToInsert, OldEnd); std::copy(From, To, I); return I; } // Otherwise, we're inserting more elements than exist already, and we're // not inserting at the end. // Move over the elements that we're about to overwrite. T OldEnd = this->end(); this->setEnd(this->end() + NumToInsert); size_t NumOverwritten = OldEnd-I; this->uninitialized_move(I, OldEnd, this->end()-NumOverwritten); // Replace the overwritten part. for (T J = I; NumOverwritten > 0; --NumOverwritten) { J = *From; ++J; ++From; } // Insert the non-overwritten middle part. this->uninitialized_copy(From, To, OldEnd); return I; }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r14 movq %rdi, %rbp movq (%rdi), %rax movq 0x8(%rdi), %rdx movq %rsi, %rbx subq %rax, %rbx cmpq %rsi, %rdx je 0x2cd2a movq %rcx, (%rsp) movq %rcx, %r15 subq %r14, %r15 movq %r15, %r12 sarq $0x3, %r12 subq %rax, %rdx sarq $0x3, %rdx addq %r12, %rdx movq 0x10(%rbp), %rcx subq %rax, %rcx sarq $0x3, %rcx cmpq %rdx, %rcx jae 0x2ccaf shlq $0x3, %rdx leaq 0x18(%rbp), %rsi movl $0x8, %ecx movq %rbp, %rdi callq 0x2c8f2 addq (%rbp), %rbx movq 0x8(%rbp), %r8 movq %r8, %rdx subq %rbx, %rdx movq %rdx, %r13 sarq $0x3, %r13 cmpq %r12, %r13 jae 0x2cd3e addq %r8, %r15 movq %r15, 0x8(%rbp) cmpq %r8, %rbx je 0x2ccf1 leaq (,%r13,8), %rax subq %rax, %r15 movq %r15, %rdi movq %rbx, %rsi movq %r8, %r15 callq 0x73a0 movq %r15, %r8 cmpq %rbx, %r8 je 0x2cd11 xorl %eax, %eax xorl %ecx, %ecx movq (%r14,%rcx,8), %rdx movq %rdx, (%rbx,%rcx,8) incq %rcx addq $-0x8, %rax cmpq %rcx, %r13 jne 0x2ccfa subq %rax, %r14 movq (%rsp), %rdx cmpq %rdx, %r14 je 0x2cd91 subq %r14, %rdx movq %r8, %rdi movq %r14, %rsi callq 0x73a0 jmp 0x2cd91 movq %rbp, %rdi movq %r14, %rsi movq %rcx, %rdx callq 0x2cda4 addq (%rbp), %rbx jmp 0x2cd91 shlq $0x3, %r12 movq %r8, %r13 subq %r12, %r13 movq %rbp, %rdi movq %r13, %rsi movq %r8, %rdx movq %r8, %r12 callq 0x2ce0a subq %rbx, %r13 je 0x2cd6f subq %r13, %r12 movq %r12, %rdi movq %rbx, %rsi movq %r13, %rdx callq 0x7780 cmpq %r14, (%rsp) je 0x2cd91 movq %rbx, %rdi movq %r14, %rsi movq %r15, %rdx addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp jmp 0x7780 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq nop	/taskflow[P]taskflow/taskflow/core/../utility/small_vector.hpp
void tf::SmallVectorImpl<int>::append<int const>(int const, int const*)	void append(in_iter in_start, in_iter in_end) { size_type NumInputs = std::distance(in_start, in_end); // Grow allocated space if needed. if (NumInputs > size_type(this->capacity_ptr()-this->end())) this->grow(this->size()+NumInputs); // Copy the new elements over. this->uninitialized_copy(in_start, in_end, this->end()); this->setEnd(this->end() + NumInputs); }	pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r12 movq %rsi, %r15 movq %rdi, %rbx movq %rdx, %r14 subq %rsi, %r14 movq 0x8(%rdi), %rdx movq 0x10(%rdi), %rax subq %rdx, %rax cmpq %rax, %r14 jbe 0x2d17c addq %r14, %rdx subq (%rbx), %rdx andq $-0x4, %rdx leaq 0x18(%rbx), %rsi movl $0x4, %ecx movq %rbx, %rdi callq 0x2c8f2 cmpq %r12, %r15 je 0x2d190 movq 0x8(%rbx), %rdi movq %r15, %rsi movq %r14, %rdx callq 0x73a0 addq %r14, 0x8(%rbx) addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq	/taskflow[P]taskflow/taskflow/core/../utility/small_vector.hpp
tf::SmallVectorImpl<int>::operator=(tf::SmallVectorImpl<int>&&)	SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) { // Avoid self-assignment. if (this == &RHS) return this; // If the RHS isn't small, clear this vector and then steal its buffer. if (!RHS.isSmall()) { this->destroy_range(this->begin(), this->end()); if (!this->isSmall()) std::free(this->begin()); this->BeginX = RHS.BeginX; this->EndX = RHS.EndX; this->CapacityX = RHS.CapacityX; RHS.resetToSmall(); return this; } // If we already have sufficient space, assign the common elements, then // destroy any excess. size_t RHSSize = RHS.size(); size_t CurSize = this->size(); if (CurSize >= RHSSize) { // Assign common elements. iterator NewEnd = this->begin(); if (RHSSize) NewEnd = std::move(RHS.begin(), RHS.end(), NewEnd); // Destroy excess elements and trim the bounds. this->destroy_range(NewEnd, this->end()); this->setEnd(NewEnd); // Clear the RHS. RHS.clear(); return this; } // If we have to grow to have enough elements, destroy the current elements. // This allows us to avoid copying them during the grow. // FIXME: this may not actually make any sense if we can efficiently move // elements. if (this->capacity() < RHSSize) { // Destroy current elements. this->destroy_range(this->begin(), this->end()); this->setEnd(this->begin()); CurSize = 0; this->grow(RHSSize); } else if (CurSize) { // Otherwise, use assignment for the already-constructed elements. std::move(RHS.begin(), RHS.begin()+CurSize, this->begin()); } // Move-construct the new elements in place. this->uninitialized_move(RHS.begin()+CurSize, RHS.end(), this->begin()+CurSize); // Set end. this->setEnd(this->begin()+RHSSize); RHS.clear(); return this; }	pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rdi, %rbx cmpq %rsi, %rdi je 0x2d297 movq %rsi, %r14 movq (%rsi), %rsi leaq 0x18(%r14), %r15 cmpq %r15, %rsi je 0x2d1f4 movq (%rbx), %rdi leaq 0x18(%rbx), %rax cmpq %rax, %rdi je 0x2d1d5 callq 0x7590 movups (%r14), %xmm0 movups %xmm0, (%rbx) movq 0x10(%r14), %rax movq %rax, 0x10(%rbx) movq %r15, 0x10(%r14) movq %r15, 0x8(%r14) movq %r15, (%r14) jmp 0x2d297 movq 0x8(%r14), %rcx movq %rcx, %r15 subq %rsi, %r15 movq (%rbx), %r12 movq 0x8(%rbx), %rax movq %rax, %rdx subq %r12, %rdx cmpq %r15, %rdx jae 0x2d236 movq 0x10(%rbx), %rcx subq %r12, %rcx cmpq %r15, %rcx jae 0x2d24f movq %r12, 0x8(%rbx) leaq 0x18(%rbx), %rsi movl $0x4, %ecx movq %rbx, %rdi movq %r15, %rdx callq 0x2c8f2 jmp 0x2d265 cmpq %rsi, %rcx je 0x2d249 movq %r12, %rdi movq %r15, %rdx callq 0x7780 addq %r15, %r12 movq %r12, 0x8(%rbx) jmp 0x2d290 cmpq %r12, %rax je 0x2d265 movq %rdx, %r13 sarq $0x2, %r13 movq %r12, %rdi callq 0x7780 jmp 0x2d268 xorl %r13d, %r13d shlq $0x2, %r13 movq (%r14), %rsi addq %r13, %rsi movq 0x8(%r14), %rdx cmpq %rdx, %rsi je 0x2d289 addq (%rbx), %r13 subq %rsi, %rdx movq %r13, %rdi callq 0x73a0 addq (%rbx), %r15 movq %r15, 0x8(%rbx) movq (%r14), %rax movq %rax, 0x8(%r14) movq %rbx, %rax popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq	/taskflow[P]taskflow/taskflow/core/../utility/small_vector.hpp
auto tf::Executor::_async<tf::DefaultTaskParams, auto tf::make_sort_task<__gnu_cxx::__normal_iterator<int, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int, std::vector<int, std::allocator<int>>>, std::less<int>>(__gnu_cxx::__normal_iterator<int, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int, std::vector<int, std::allocator<int>>>, std::less<int>)::'lambda'(tf::Runtime&)>(__gnu_cxx::__normal_iterator<int, std::vector<int, std::allocator<int>>>&&, __gnu_cxx::__normal_iterator<int, std::vector<int, std::allocator<int>>>&&, tf::Topology, tf::Node)	auto Executor::_async(P&& params, F&& f, Topology* tpg, Node* parent) { // async task with runtime: [] (tf::Runtime&) -> void {} if constexpr (is_runtime_task_v<F>) { std::promise<void> p; auto fu{p.get_future()}; _schedule_async_task(animate( NSTATE::NONE, ESTATE::ANCHORED, std::forward<P>(params), tpg, parent, 0, std::in_place_type_t<Node::Async>{}, [p=MoC{std::move(p)}, f=std::forward<F>(f)](Runtime& rt, bool reentered) mutable { if(!reentered) { f(rt); } else { auto& eptr = rt._parent->_exception_ptr; eptr ? p.object.set_exception(eptr) : p.object.set_value(); } } )); return fu; } // async task with closure: [] () -> auto { return ... } else if constexpr (std::is_invocable_v<F>){ using R = std::invoke_result_t<F>; std::packaged_task<R()> p(std::forward<F>(f)); auto fu{p.get_future()}; _schedule_async_task(animate( NSTATE::NONE, ESTATE::NONE, std::forward<P>(params), tpg, parent, 0, std::in_place_type_t<Node::Async>{}, [p=make_moc(std::move(p))]() mutable { p.object(); } )); return fu; } else { static_assert(dependent_false_v<F>, "invalid async target - must be one of the following types:\n\ (1) [] (tf::Runtime&) -> void {}\n\ (2) [] () -> auto { ... return ... }\n" ); } }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x88, %rsp movq %r9, %r12 movq %r8, %r13 movq %rcx, %r15 movq %rdx, %rbp movq %rsi, %r14 movq %rdi, 0x48(%rsp) leaq 0x10(%rsp), %rbx movq %rbx, %rdi callq 0x3216a leaq 0x30(%rsp), %rdi movq %rbx, %rsi callq 0x32372 movaps 0x10(%rsp), %xmm0 movaps %xmm0, 0x50(%rsp) xorps %xmm0, %xmm0 movaps %xmm0, 0x10(%rsp) movq 0x20(%rsp), %rax movq %rax, 0x60(%rsp) movq $0x0, 0x20(%rsp) movups (%r15), %xmm0 movups %xmm0, 0x68(%rsp) movb 0x10(%r15), %al movb %al, 0x78(%rsp) movl $0xd8, %edi callq 0x74a0 movq %rax, %r15 subq $0x8, %rsp leaq 0x58(%rsp), %rax leaq 0x17(%rsp), %r10 movq %r15, %rdi xorl %esi, %esi movl $0x40000000, %edx # imm = 0x40000000 movq %rbp, %rcx movq %r13, %r8 movq %r12, %r9 pushq %rax pushq %r10 pushq $0x0 callq 0x32e1e addq $0x20, %rsp movq %fs:-0x8, %rsi testq %rsi, %rsi je 0x32d14 movq %r14, %rdi movq %r15, %rdx callq 0x275f2 jmp 0x32d84 movq 0xd8(%r14), %r12 movq 0xe0(%r14), %rax subq %r12, %rax sarq $0x7, %rax movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB imulq %rax, %rcx movq %r15, %rax xorl %edx, %edx divq %rcx leaq (%rdx,%rdx,2), %rbx shlq $0x7, %rbx addq %rbx, %r12 movq %r12, %rdi callq 0x76f0 testl %eax, %eax jne 0x32dc5 movq 0xd8(%r14), %rax leaq (%rax,%rbx), %rdi addq $0x80, %rdi movq %r15, %rsi callq 0x2796c movq %r12, %rdi callq 0x7370 addq $0x40, %r14 movq %r14, %rdi callq 0x27794 leaq 0x50(%rsp), %rdi callq 0x3221a xorl %eax, %eax movq 0x48(%rsp), %rbx movq %rax, 0x8(%rbx) movaps 0x30(%rsp), %xmm0 movq %rax, 0x38(%rsp) movups %xmm0, (%rbx) leaq 0x10(%rsp), %rdi callq 0x3221a movq %rbx, %rax addq $0x88, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movl %eax, %edi callq 0x72c0 movq %rax, %rbx movq %r12, %rdi callq 0x7370 jmp 0x32df3 movq %rax, %rbx movl $0xd8, %esi movq %r15, %rdi callq 0x74c0 jmp 0x32df3 movq %rax, %rbx jmp 0x32e0c movq %rax, %rbx leaq 0x50(%rsp), %rdi callq 0x3221a movq 0x38(%rsp), %rdi testq %rdi, %rdi je 0x32e0c callq 0x2c770 leaq 0x10(%rsp), %rdi callq 0x3221a movq %rbx, %rdi callq 0x7860	/taskflow[P]taskflow/taskflow/core/async.hpp
tf::AsyncTask::_decref()	inline void AsyncTask::_decref() { if(_node && std::get_if<Node::DependentAsync>(&(_node->_handle))->use_count.fetch_sub( 1, std::memory_order_acq_rel ) == 1) { recycle(_node); } }	pushq %rbx movq (%rdi), %rax testq %rax, %rax je 0x336f1 leaq 0x88(%rax), %rcx xorl %edx, %edx cmpb $0x8, 0xc0(%rax) cmoveq %rcx, %rdx lock decq 0x28(%rdx) jne 0x336f1 movq (%rdi), %rbx testq %rbx, %rbx je 0x336f1 cmpq $0x0, 0xd0(%rbx) je 0x3368a leaq 0xd0(%rbx), %rdi callq 0x73c0 movq 0xc8(%rbx), %rsi testq %rsi, %rsi je 0x336a2 leaq 0xc8(%rbx), %rdi callq 0x28090 movq $0x0, 0xc8(%rbx) leaq 0x88(%rbx), %rdi callq 0x28058 movq 0x48(%rbx), %rdi leaq 0x60(%rbx), %rax cmpq %rax, %rdi je 0x336cb callq 0x7590 movq 0x8(%rbx), %rdi leaq 0x18(%rbx), %rax cmpq %rax, %rdi je 0x336e3 movq (%rax), %rsi incq %rsi callq 0x74c0 movl $0xd8, %esi movq %rbx, %rdi popq %rbx jmp 0x74c0 popq %rbx retq	/taskflow[P]taskflow/taskflow/core/async_task.hpp
PrintDebugStream(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&)	void PrintDebugStream(std::stringstream &debugStream) { std::cerr << debugStream.str() << std::endl; debugStream.clear(); debugStream.str(""); }	pushq %rbp movq %rsp, %rbp subq $0x80, %rsp movq %rdi, -0x8(%rbp) movq -0x8(%rbp), %rsi leaq -0x28(%rbp), %rdi movq %rdi, -0x70(%rbp) callq 0x6410 movq -0x70(%rbp), %rsi movq 0x2f1e5(%rip), %rdi # 0x35ff0 callq 0x63b0 movq %rax, -0x68(%rbp) jmp 0x6e16 movq -0x68(%rbp), %rdi movq 0x2f18f(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x6e28 leaq -0x28(%rbp), %rdi callq 0x62d0 movq -0x8(%rbp), %rdi movq (%rdi), %rax movq -0x18(%rax), %rax addq %rax, %rdi xorl %esi, %esi callq 0x6790 movq -0x8(%rbp), %rax movq %rax, -0x80(%rbp) leaq -0x59(%rbp), %rdi movq %rdi, -0x78(%rbp) callq 0x67f0 movq -0x78(%rbp), %rdx leaq 0x219d1(%rip), %rsi # 0x28837 leaq -0x58(%rbp), %rdi callq 0xbb90 jmp 0x6e71 movq -0x80(%rbp), %rdi leaq -0x58(%rbp), %rsi callq 0x6520 jmp 0x6e80 leaq -0x58(%rbp), %rdi callq 0x62d0 leaq -0x59(%rbp), %rdi callq 0x64c0 addq $0x80, %rsp popq %rbp retq movq %rax, %rcx movl %edx, %eax movq %rcx, -0x30(%rbp) movl %eax, -0x34(%rbp) leaq -0x28(%rbp), %rdi callq 0x62d0 jmp 0x6ede movq %rax, %rcx movl %edx, %eax movq %rcx, -0x30(%rbp) movl %eax, -0x34(%rbp) jmp 0x6ed5 movq %rax, %rcx movl %edx, %eax movq %rcx, -0x30(%rbp) movl %eax, -0x34(%rbp) leaq -0x58(%rbp), %rdi callq 0x62d0 leaq -0x59(%rbp), %rdi callq 0x64c0 movq -0x30(%rbp), %rdi callq 0x67e0 nopw (%rax,%rax)	/jhu-cisst[P]mechatronics-software/tests/qladisp.cpp
CollectFileConvert(char const, char const)	bool CollectFileConvert(const char inFilename, const char outFilename) { std::cerr << "Converting data collection file " << inFilename << " to " << outFilename << std::endl; std::ifstream inFile(inFilename, std::ifstream::binary); if (!inFile.good()) { std::cerr << "Failed to open input data collection file " << inFilename << std::endl; return false; } std::ofstream outFile(outFilename, std::ofstream::trunc); if (!outFile.good()) { std::cerr << "Failed to open output data collection file " << outFilename << std::endl; return false; } quadlet_t value; while (inFile.good()) { inFile.read(reinterpret_cast<char *>(&value), sizeof(quadlet_t)); outFile << std::dec << ((value&0x80000000)>>31) << ", " // type (0->commanded current, 1-> measured current) << ((value&0x40000000)>>30) << ", " // timer overflow << ((value&0x3FFF0000)>>16) << ", " // timer (14-bits) << (value&0x0000FFFF) // data << std::endl; } inFile.close(); outFile.close(); return true; }	pushq %rbp movq %rsp, %rbp subq $0x4b0, %rsp # imm = 0x4B0 movq %rdi, -0x10(%rbp) movq %rsi, -0x18(%rbp) movq 0x2f096(%rip), %rdi # 0x35ff0 leaq 0x210ef(%rip), %rsi # 0x28050 callq 0x6420 movq %rax, %rdi movq -0x10(%rbp), %rsi callq 0x6420 movq %rax, %rdi leaq 0x23ce7(%rip), %rsi # 0x2ac63 callq 0x6420 movq %rax, %rdi movq -0x18(%rbp), %rsi callq 0x6420 movq %rax, %rdi movq 0x2f019(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x10(%rbp), %rsi leaq -0x220(%rbp), %rdi movl $0x4, %edx callq 0x6830 movq -0x220(%rbp), %rax movq -0x18(%rax), %rax leaq -0x220(%rbp,%rax), %rdi callq 0x67a0 movb %al, -0x435(%rbp) jmp 0x6fd1 movb -0x435(%rbp), %al testb $0x1, %al jne 0x7051 jmp 0x6fdd movq 0x2f00c(%rip), %rdi # 0x35ff0 leaq 0x21086(%rip), %rsi # 0x28071 callq 0x6420 movq %rax, -0x440(%rbp) jmp 0x6ff9 movq -0x440(%rbp), %rdi movq -0x10(%rbp), %rsi callq 0x6420 movq %rax, -0x448(%rbp) jmp 0x7012 movq -0x448(%rbp), %rdi movq 0x2ef90(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x7027 movb $0x0, -0x1(%rbp) movl $0x1, -0x230(%rbp) jmp 0x72a2 movq %rax, %rcx movl %edx, %eax movq %rcx, -0x228(%rbp) movl %eax, -0x22c(%rbp) jmp 0x72bc movq -0x18(%rbp), %rsi leaq -0x430(%rbp), %rdi movl $0x20, %edx callq 0x64d0 jmp 0x7068 movq -0x430(%rbp), %rax movq -0x18(%rax), %rax leaq -0x430(%rbp,%rax), %rdi callq 0x67a0 movb %al, -0x449(%rbp) jmp 0x7088 movb -0x449(%rbp), %al testb $0x1, %al jne 0x7118 jmp 0x7098 movq 0x2ef51(%rip), %rdi # 0x35ff0 leaq 0x20ff6(%rip), %rsi # 0x2809c callq 0x6420 movq %rax, -0x458(%rbp) jmp 0x70b4 movq -0x458(%rbp), %rdi movq -0x18(%rbp), %rsi callq 0x6420 movq %rax, -0x460(%rbp) jmp 0x70cd movq -0x460(%rbp), %rdi movq 0x2eed5(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x70e2 movb $0x0, -0x1(%rbp) movl $0x1, -0x230(%rbp) jmp 0x7296 movq %rax, %rcx movl %edx, %eax movq %rcx, -0x228(%rbp) movl %eax, -0x22c(%rbp) leaq -0x430(%rbp), %rdi callq 0x68f8 jmp 0x72bc jmp 0x711a movq -0x220(%rbp), %rax movq -0x18(%rax), %rax leaq -0x220(%rbp,%rax), %rdi callq 0x67a0 movb %al, -0x461(%rbp) jmp 0x713a movb -0x461(%rbp), %al testb $0x1, %al jne 0x7149 jmp 0x726c leaq -0x220(%rbp), %rdi leaq -0x434(%rbp), %rsi movl $0x4, %edx callq 0x6580 jmp 0x7163 leaq 0x4ad6(%rip), %rsi # 0xbc40 leaq -0x430(%rbp), %rdi callq 0x61f0 movq %rax, -0x470(%rbp) jmp 0x717f movq -0x470(%rbp), %rdi movl -0x434(%rbp), %esi shrl $0x1f, %esi callq 0x65d0 movq %rax, -0x478(%rbp) jmp 0x719d movq -0x478(%rbp), %rdi leaq 0x221b6(%rip), %rsi # 0x29361 callq 0x6420 movq %rax, -0x480(%rbp) jmp 0x71b9 movq -0x480(%rbp), %rdi movl -0x434(%rbp), %esi shrl $0x1e, %esi andl $0x1, %esi callq 0x65d0 movq %rax, -0x488(%rbp) jmp 0x71da movq -0x488(%rbp), %rdi leaq 0x22179(%rip), %rsi # 0x29361 callq 0x6420 movq %rax, -0x490(%rbp) jmp 0x71f6 movq -0x490(%rbp), %rdi movl -0x434(%rbp), %esi andl $0x3fff0000, %esi # imm = 0x3FFF0000 shrl $0x10, %esi callq 0x65d0 movq %rax, -0x498(%rbp) jmp 0x721a movq -0x498(%rbp), %rdi leaq 0x22139(%rip), %rsi # 0x29361 callq 0x6420 movq %rax, -0x4a0(%rbp) jmp 0x7236 movq -0x4a0(%rbp), %rdi movzwl -0x434(%rbp), %esi callq 0x65d0 movq %rax, -0x4a8(%rbp) jmp 0x7252 movq -0x4a8(%rbp), %rdi movq 0x2ed50(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x7267 jmp 0x711a leaq -0x220(%rbp), %rdi callq 0x60f0 jmp 0x727a leaq -0x430(%rbp), %rdi callq 0x6680 jmp 0x7288 movb $0x1, -0x1(%rbp) movl $0x1, -0x230(%rbp) leaq -0x430(%rbp), %rdi callq 0x68f8 leaq -0x220(%rbp), %rdi callq 0x6140 movb -0x1(%rbp), %al andb $0x1, %al addq $0x4b0, %rsp # imm = 0x4B0 popq %rbp retq leaq -0x220(%rbp), %rdi callq 0x6140 movq -0x228(%rbp), %rdi callq 0x67e0 nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/tests/qladisp.cpp
BasePort::BroadcastReadInfo::BroadcastReadInfo()	BroadcastReadInfo() : readSizeQuads(0), readSequence(0), updateStartTime(0.0), updateFinishTime(0.0), updateOverflow(false), readStartTime(0.0), readFinishTime(0.0), readOverflow(false), gapTime(0.0) { Clear(); }	pushq %rbp movq %rsp, %rbp subq $0x50, %rsp movq %rdi, -0x8(%rbp) movq -0x8(%rbp), %rax movq %rax, -0x38(%rbp) movl $0x0, (%rax) movl $0x0, 0x4(%rax) xorps %xmm0, %xmm0 movsd %xmm0, 0x8(%rax) xorps %xmm0, %xmm0 movsd %xmm0, 0x10(%rax) movb $0x0, 0x18(%rax) xorps %xmm0, %xmm0 movsd %xmm0, 0x20(%rax) xorps %xmm0, %xmm0 movsd %xmm0, 0x28(%rax) movb $0x0, 0x30(%rax) xorps %xmm0, %xmm0 movsd %xmm0, 0x38(%rax) addq $0x50, %rax movq %rax, -0x30(%rbp) movq %rax, %rcx addq $0x200, %rcx # imm = 0x200 movq %rcx, -0x28(%rbp) movq %rax, -0x20(%rbp) movq -0x20(%rbp), %rdi movq %rdi, -0x40(%rbp) callq 0xc7a0 jmp 0xc26a movq -0x28(%rbp), %rcx movq -0x40(%rbp), %rax addq $0x20, %rax cmpq %rcx, %rax movq %rax, -0x20(%rbp) jne 0xc25b movq -0x38(%rbp), %rdi callq 0xc770 addq $0x50, %rsp popq %rbp retq movq -0x30(%rbp), %rcx movq %rax, %rsi movq -0x40(%rbp), %rax movq %rsi, -0x10(%rbp) movl %edx, -0x14(%rbp) cmpq %rax, %rcx movq %rax, -0x48(%rbp) je 0xc2cb movq -0x48(%rbp), %rdi addq $-0x20, %rdi movq %rdi, -0x50(%rbp) callq 0xc7e0 movq -0x30(%rbp), %rcx movq -0x50(%rbp), %rax cmpq %rcx, %rax movq %rax, -0x48(%rbp) jne 0xc2a9 jmp 0xc2cd movq -0x10(%rbp), %rdi callq 0x67e0 nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/BasePort.h
BoardIO::GetFpgaVersionMajorFromStatus(unsigned int)	unsigned int BoardIO::GetFpgaVersionMajorFromStatus(uint32_t status) { // FPGA V1: all bits are 0 // FPGA V2: bit 31 is 1 // FPGA V3: bits[31:30] are 01 unsigned int fpga_ver = 0; if (status == 0) fpga_ver = 1; else if (status&0x80000000) fpga_ver = 2; else if ((status&0x40000000) == 0x40000000) fpga_ver = 3; return fpga_ver; }	pushq %rbp movq %rsp, %rbp movl %edi, -0x4(%rbp) movl $0x0, -0x8(%rbp) cmpl $0x0, -0x4(%rbp) jne 0xde1d movl $0x1, -0x8(%rbp) jmp 0xde4d movl -0x4(%rbp), %eax andl $0x80000000, %eax # imm = 0x80000000 cmpl $0x0, %eax je 0xde33 movl $0x2, -0x8(%rbp) jmp 0xde4b movl -0x4(%rbp), %eax andl $0x40000000, %eax # imm = 0x40000000 cmpl $0x40000000, %eax # imm = 0x40000000 jne 0xde49 movl $0x3, -0x8(%rbp) jmp 0xde4b jmp 0xde4d movl -0x8(%rbp), %eax popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/BoardIO.cpp
AmpIO::DisplayReadBuffer(std::ostream&) const	void AmpIO::DisplayReadBuffer(std::ostream &out) const { // first two quadlets are timestamp and status, resp. out << std::hex << ReadBuffer[TIMESTAMP_OFFSET] << std::endl; out << std::hex << ReadBuffer[STATUS_OFFSET] << std::endl; // next two quadlets are digital I/O and amplifier temperature out << std::hex << ReadBuffer[DIGIO_OFFSET] << std::endl; out << std::hex << ReadBuffer[TEMP_OFFSET] << std::endl; // remaining quadlets are in groups of NumMotors/NumEncoders as follows: // - motor current and analog pot per channel // - encoder position per channel // - encoder velocity per channel // - encoder acceleration data (depends on firmware version) unsigned int i; for (i = MOTOR_CURR_OFFSET; i < ENC_POS_OFFSET; i++) out << std::hex << ReadBuffer[i] << " "; out << std::endl; for (i = ENC_POS_OFFSET; i < ENC_VEL_OFFSET; i++) out << std::hex << ReadBuffer[i] << " "; out << std::endl; for (i = ENC_VEL_OFFSET; i < ENC_QTR1_OFFSET; i++) out << std::hex << ReadBuffer[i] << " "; out << std::endl; for (i = ENC_QTR1_OFFSET; i < ENC_QTR5_OFFSET; i++) out << std::hex << ReadBuffer[i] << " "; out << std::endl; for (i = ENC_QTR5_OFFSET; i < ENC_RUN_OFFSET; i++) out << std::hex << ReadBuffer[i] << " "; out << std::endl; for (i = ENC_RUN_OFFSET; i < MOTOR_STATUS_OFFSET; i++) out << std::hex << ReadBuffer[i] << " "; out << std::endl; if (GetFirmwareVersion() >= 8) { for (i = MOTOR_STATUS_OFFSET; i < GetReadNumBytes()/sizeof(quadlet_t); i++) out << std::hex << ReadBuffer[i] << " "; out << std::endl; } out << std::dec; }	pushq %rbp movq %rsp, %rbp subq $0x30, %rsp movq %rdi, -0x8(%rbp) movq %rsi, -0x10(%rbp) movq -0x8(%rbp), %rax movq %rax, -0x20(%rbp) movq -0x10(%rbp), %rdi leaq 0x565d(%rip), %rsi # 0x146c0 callq 0x61f0 movq %rax, %rdi movq -0x20(%rbp), %rax movl 0x3c(%rax), %esi callq 0x65d0 movq %rax, %rdi movq 0x26f2f(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x10(%rbp), %rdi leaq 0x562f(%rip), %rsi # 0x146c0 callq 0x61f0 movq %rax, %rdi movq -0x20(%rbp), %rax movl 0x40(%rax), %esi callq 0x65d0 movq %rax, %rdi movq 0x26f01(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x10(%rbp), %rdi leaq 0x5601(%rip), %rsi # 0x146c0 callq 0x61f0 movq %rax, %rdi movq -0x20(%rbp), %rax movl 0x44(%rax), %esi callq 0x65d0 movq %rax, %rdi movq 0x26ed3(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x10(%rbp), %rdi leaq 0x55d3(%rip), %rsi # 0x146c0 callq 0x61f0 movq %rax, %rdi movq -0x20(%rbp), %rax movl 0x48(%rax), %esi callq 0x65d0 movq %rax, %rdi movq 0x26ea5(%rip), %rsi # 0x35fb0 callq 0x6490 movl $0x4, -0x14(%rbp) movq -0x20(%rbp), %rcx movl -0x14(%rbp), %eax cmpl 0xe2c(%rcx), %eax jae 0xf163 movq -0x10(%rbp), %rdi leaq 0x558f(%rip), %rsi # 0x146c0 callq 0x61f0 movq %rax, %rdi movq -0x20(%rbp), %rax movl -0x14(%rbp), %ecx movl 0x3c(%rax,%rcx,4), %esi callq 0x65d0 movq %rax, %rdi leaq 0x196e3(%rip), %rsi # 0x28836 callq 0x6420 movl -0x14(%rbp), %eax addl $0x1, %eax movl %eax, -0x14(%rbp) jmp 0xf117 movq -0x10(%rbp), %rdi movq 0x26e42(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x20(%rbp), %rax movl 0xe2c(%rax), %eax movl %eax, -0x14(%rbp) movq -0x20(%rbp), %rcx movl -0x14(%rbp), %eax cmpl 0xe30(%rcx), %eax jae 0xf1cc movq -0x10(%rbp), %rdi leaq 0x5526(%rip), %rsi # 0x146c0 callq 0x61f0 movq %rax, %rdi movq -0x20(%rbp), %rax movl -0x14(%rbp), %ecx movl 0x3c(%rax,%rcx,4), %esi callq 0x65d0 movq %rax, %rdi leaq 0x1967a(%rip), %rsi # 0x28836 callq 0x6420 movl -0x14(%rbp), %eax addl $0x1, %eax movl %eax, -0x14(%rbp) jmp 0xf180 movq -0x10(%rbp), %rdi movq 0x26dd9(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x20(%rbp), %rax movl 0xe30(%rax), %eax movl %eax, -0x14(%rbp) movq -0x20(%rbp), %rcx movl -0x14(%rbp), %eax cmpl 0xe38(%rcx), %eax jae 0xf235 movq -0x10(%rbp), %rdi leaq 0x54bd(%rip), %rsi # 0x146c0 callq 0x61f0 movq %rax, %rdi movq -0x20(%rbp), %rax movl -0x14(%rbp), %ecx movl 0x3c(%rax,%rcx,4), %esi callq 0x65d0 movq %rax, %rdi leaq 0x19611(%rip), %rsi # 0x28836 callq 0x6420 movl -0x14(%rbp), %eax addl $0x1, %eax movl %eax, -0x14(%rbp) jmp 0xf1e9 movq -0x10(%rbp), %rdi movq 0x26d70(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x20(%rbp), %rax movl 0xe38(%rax), %eax movl %eax, -0x14(%rbp) movq -0x20(%rbp), %rcx movl -0x14(%rbp), %eax cmpl 0xe3c(%rcx), %eax jae 0xf29e movq -0x10(%rbp), %rdi leaq 0x5454(%rip), %rsi # 0x146c0 callq 0x61f0 movq %rax, %rdi movq -0x20(%rbp), %rax movl -0x14(%rbp), %ecx movl 0x3c(%rax,%rcx,4), %esi callq 0x65d0 movq %rax, %rdi leaq 0x195a8(%rip), %rsi # 0x28836 callq 0x6420 movl -0x14(%rbp), %eax addl $0x1, %eax movl %eax, -0x14(%rbp) jmp 0xf252 movq -0x10(%rbp), %rdi movq 0x26d07(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x20(%rbp), %rax movl 0xe3c(%rax), %eax movl %eax, -0x14(%rbp) movq -0x20(%rbp), %rcx movl -0x14(%rbp), %eax cmpl 0xe40(%rcx), %eax jae 0xf307 movq -0x10(%rbp), %rdi leaq 0x53eb(%rip), %rsi # 0x146c0 callq 0x61f0 movq %rax, %rdi movq -0x20(%rbp), %rax movl -0x14(%rbp), %ecx movl 0x3c(%rax,%rcx,4), %esi callq 0x65d0 movq %rax, %rdi leaq 0x1953f(%rip), %rsi # 0x28836 callq 0x6420 movl -0x14(%rbp), %eax addl $0x1, %eax movl %eax, -0x14(%rbp) jmp 0xf2bb movq -0x10(%rbp), %rdi movq 0x26c9e(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x20(%rbp), %rax movl 0xe40(%rax), %eax movl %eax, -0x14(%rbp) movq -0x20(%rbp), %rcx movl -0x14(%rbp), %eax cmpl 0xe44(%rcx), %eax jae 0xf370 movq -0x10(%rbp), %rdi leaq 0x5382(%rip), %rsi # 0x146c0 callq 0x61f0 movq %rax, %rdi movq -0x20(%rbp), %rax movl -0x14(%rbp), %ecx movl 0x3c(%rax,%rcx,4), %esi callq 0x65d0 movq %rax, %rdi leaq 0x194d6(%rip), %rsi # 0x28836 callq 0x6420 movl -0x14(%rbp), %eax addl $0x1, %eax movl %eax, -0x14(%rbp) jmp 0xf324 movq -0x10(%rbp), %rdi movq 0x26c35(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x20(%rbp), %rdi callq 0xdd60 cmpl $0x8, %eax jb 0xf40a movq -0x20(%rbp), %rax movl 0xe44(%rax), %eax movl %eax, -0x14(%rbp) movq -0x20(%rbp), %rdi movl -0x14(%rbp), %eax movq %rax, -0x28(%rbp) movq (%rdi), %rax callq *0x8(%rax) movl %eax, %ecx movq -0x28(%rbp), %rax movl %ecx, %ecx shrq $0x2, %rcx cmpq %rcx, %rax jae 0xf3fa movq -0x10(%rbp), %rdi leaq 0x52f8(%rip), %rsi # 0x146c0 callq 0x61f0 movq %rax, %rdi movq -0x20(%rbp), %rax movl -0x14(%rbp), %ecx movl 0x3c(%rax,%rcx,4), %esi callq 0x65d0 movq %rax, %rdi leaq 0x1944c(%rip), %rsi # 0x28836 callq 0x6420 movl -0x14(%rbp), %eax addl $0x1, %eax movl %eax, -0x14(%rbp) jmp 0xf39b movq -0x10(%rbp), %rdi movq 0x26bab(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x10(%rbp), %rdi leaq -0x37d5(%rip), %rsi # 0xbc40 callq 0x61f0 addq $0x30, %rsp popq %rbp retq	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::GetEncoderIndex() const	uint8_t AmpIO::GetEncoderIndex(void) const { uint8_t encI; if (GetHardwareVersion() == DQLA_String) { // This also works for QLA with Rev 8+ encI = 0; for (unsigned int i = 0; i < NumEncoders; i++) { if (ReadBuffer[ENC_POS_OFFSET+i]&ENC_I_MASK) encI \|= (1 << i); } } else { encI = static_cast<uint8_t>((this->GetDigitalInput()&0x000f0000)>>16); } return encI; }	pushq %rbp movq %rsp, %rbp subq $0x20, %rsp movq %rdi, -0x8(%rbp) movq -0x8(%rbp), %rdi movq %rdi, -0x18(%rbp) callq 0xde60 movl %eax, %eax cmpq $0x44514c41, %rax # imm = 0x44514C41 jne 0xf8db movb $0x0, -0x9(%rbp) movl $0x0, -0x10(%rbp) movq -0x18(%rbp), %rcx movl -0x10(%rbp), %eax cmpl 0x34(%rcx), %eax jae 0xf8d9 movq -0x18(%rbp), %rax movl 0xe2c(%rax), %ecx addl -0x10(%rbp), %ecx movl %ecx, %ecx movl 0x3c(%rax,%rcx,4), %eax andl $0x40000000, %eax # imm = 0x40000000 cmpl $0x0, %eax je 0xf8cc movl -0x10(%rbp), %ecx movl $0x1, %eax shll %cl, %eax movl %eax, %ecx movzbl -0x9(%rbp), %eax orl %ecx, %eax movb %al, -0x9(%rbp) jmp 0xf8ce movl -0x10(%rbp), %eax addl $0x1, %eax movl %eax, -0x10(%rbp) jmp 0xf88e jmp 0xf8ef movq -0x18(%rbp), %rdi callq 0xf4e0 andl $0xf0000, %eax # imm = 0xF0000 shrl $0x10, %eax movb %al, -0x9(%rbp) movb -0x9(%rbp), %al addq $0x20, %rsp popq %rbp retq nopl (%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::GetMotorCurrent(unsigned int) const	uint32_t AmpIO::GetMotorCurrent(unsigned int index) const { if (index >= NumMotors) return 0L; quadlet_t buff; buff = ReadBuffer[index+MOTOR_CURR_OFFSET]; buff &= MOTOR_CURR_MASK; // mask for applicable bits return static_cast<uint32_t>(buff) & ADC_MASK; }	pushq %rbp movq %rsp, %rbp movq %rdi, -0x10(%rbp) movl %esi, -0x14(%rbp) movq -0x10(%rbp), %rcx movq %rcx, -0x20(%rbp) movl -0x14(%rbp), %eax cmpl 0x30(%rcx), %eax jb 0xf9d4 movl $0x0, -0x4(%rbp) jmp 0xf9fd movq -0x20(%rbp), %rax movl -0x14(%rbp), %ecx addl $0x4, %ecx movl %ecx, %ecx movl 0x3c(%rax,%rcx,4), %eax movl %eax, -0x18(%rbp) movl -0x18(%rbp), %eax andl $0xffff, %eax # imm = 0xFFFF movl %eax, -0x18(%rbp) movl -0x18(%rbp), %eax andl $0xffff, %eax # imm = 0xFFFF movl %eax, -0x4(%rbp) movl -0x4(%rbp), %eax popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::GetMotorVoltageRatio(unsigned int) const	double AmpIO::GetMotorVoltageRatio(unsigned int index) const { if (GetHardwareVersion() != dRA1_String) return 0.0; if (index >= NumMotors) { return 0.0; } quadlet_t buff; buff = ReadBuffer[index+MOTOR_STATUS_OFFSET]; int16_t raw = buff & 0xffff; return (raw >> 5) / 1023.0l; }	pushq %rbp movq %rsp, %rbp subq $0x30, %rsp movq %rdi, -0x10(%rbp) movl %esi, -0x14(%rbp) movq -0x10(%rbp), %rdi movq %rdi, -0x30(%rbp) callq 0xde60 movl %eax, %eax cmpq $0x64524131, %rax # imm = 0x64524131 je 0xfb20 xorps %xmm0, %xmm0 movsd %xmm0, -0x8(%rbp) jmp 0xfb76 movq -0x30(%rbp), %rcx movl -0x14(%rbp), %eax cmpl 0x30(%rcx), %eax jb 0xfb36 xorps %xmm0, %xmm0 movsd %xmm0, -0x8(%rbp) jmp 0xfb76 movq -0x30(%rbp), %rax movl -0x14(%rbp), %ecx movl 0xe44(%rax), %edx addl %edx, %ecx movl 0x3c(%rax,%rcx,4), %eax movl %eax, -0x18(%rbp) movw -0x18(%rbp), %ax movw %ax, -0x1a(%rbp) movswl -0x1a(%rbp), %eax sarl $0x5, %eax movl %eax, -0x20(%rbp) fildl -0x20(%rbp) flds 0x18fa9(%rip) # 0x28b10 fdivrp %st, %st(1) fstpl -0x28(%rbp) movsd -0x28(%rbp), %xmm0 movsd %xmm0, -0x8(%rbp) movsd -0x8(%rbp), %xmm0 addq $0x30, %rsp popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::GetAnalogInput(unsigned int) const	uint32_t AmpIO::GetAnalogInput(unsigned int index) const { // Checking against NumMotors is correct because the analog input (e.g., pot) is in the same // quadlet as the motor current feedback. Logically, it would have made more sense to use // NumEncoders, since the number of pots would likely match the number of encoders. if (index >= NumMotors) return 0L; quadlet_t buff; buff = ReadBuffer[index+ANALOG_POS_OFFSET]; buff &= ANALOG_POS_MASK; // mask for applicable bits buff >>= 16; // shift to lsb alignment return static_cast<uint32_t>(buff) & ADC_MASK; }	pushq %rbp movq %rsp, %rbp movq %rdi, -0x10(%rbp) movl %esi, -0x14(%rbp) movq -0x10(%rbp), %rcx movq %rcx, -0x20(%rbp) movl -0x14(%rbp), %eax cmpl 0x30(%rcx), %eax jb 0xfbb4 movl $0x0, -0x4(%rbp) jmp 0xfbe6 movq -0x20(%rbp), %rax movl -0x14(%rbp), %ecx addl $0x4, %ecx movl %ecx, %ecx movl 0x3c(%rax,%rcx,4), %eax movl %eax, -0x18(%rbp) movl -0x18(%rbp), %eax andl $0xffff0000, %eax # imm = 0xFFFF0000 movl %eax, -0x18(%rbp) movl -0x18(%rbp), %eax shrl $0x10, %eax movl %eax, -0x18(%rbp) movl -0x18(%rbp), %eax andl $0xffff, %eax # imm = 0xFFFF movl %eax, -0x4(%rbp) movl -0x4(%rbp), %eax popq %rbp retq nopl (%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::ReadWatchdogPeriod(bool) const	int32_t AmpIO::ReadWatchdogPeriod(bool applyMask) const { uint32_t counts = 0; if (port) { port->ReadQuadlet(BoardId, 3, counts); } if (applyMask) counts &= 0x0000ffff; return counts; }	pushq %rbp movq %rsp, %rbp subq $0x20, %rsp movb %sil, %al movq %rdi, -0x8(%rbp) andb $0x1, %al movb %al, -0x9(%rbp) movq -0x8(%rbp), %rax movq %rax, -0x18(%rbp) movl $0x0, -0x10(%rbp) cmpq $0x0, 0x10(%rax) je 0x10ffc movq -0x18(%rbp), %rax movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movq (%rdi), %rax movl $0x3, %edx leaq -0x10(%rbp), %rcx movzbl %sil, %esi callq *0x118(%rax) testb $0x1, -0x9(%rbp) je 0x1100d movl -0x10(%rbp), %eax andl $0xffff, %eax # imm = 0xFFFF movl %eax, -0x10(%rbp) movl -0x10(%rbp), %eax addq $0x20, %rsp popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::WriteAmpEnableAxis(unsigned int, bool)	bool AmpIO::WriteAmpEnableAxis(unsigned int index, bool state) { if (index >= NumMotors) return false; if (GetFirmwareVersion() < 8) { quadlet_t mask = (1 << index); quadlet_t write_data = (mask << 8); if (state) write_data \|= mask; return (port ? port->WriteQuadlet(BoardId, BoardIO::BOARD_STATUS, write_data) : false); } else { quadlet_t write_data = MOTOR_ENABLE_MASK; if (state) write_data \|= MOTOR_ENABLE_BIT; unsigned int channel = (index+1) << 4; return (port ? port->WriteQuadlet(BoardId, channel \| DAC_CTRL_REG, write_data) : false); } }	pushq %rbp movq %rsp, %rbp subq $0x40, %rsp movb %dl, %al movq %rdi, -0x10(%rbp) movl %esi, -0x14(%rbp) andb $0x1, %al movb %al, -0x15(%rbp) movq -0x10(%rbp), %rcx movq %rcx, -0x30(%rbp) movl -0x14(%rbp), %eax cmpl 0x30(%rcx), %eax jb 0x117df movb $0x0, -0x1(%rbp) jmp 0x118ba movq -0x30(%rbp), %rdi callq 0xdd60 cmpl $0x8, %eax jae 0x11851 movl -0x14(%rbp), %ecx movl $0x1, %eax shll %cl, %eax movl %eax, -0x1c(%rbp) movl -0x1c(%rbp), %eax shll $0x8, %eax movl %eax, -0x20(%rbp) testb $0x1, -0x15(%rbp) je 0x11812 movl -0x1c(%rbp), %eax orl -0x20(%rbp), %eax movl %eax, -0x20(%rbp) movq -0x30(%rbp), %rax cmpq $0x0, 0x10(%rax) je 0x11840 movq -0x30(%rbp), %rax movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movl -0x20(%rbp), %ecx movq (%rdi), %rax xorl %edx, %edx movzbl %sil, %esi callq 0x120(%rax) movb %al, -0x31(%rbp) jmp 0x11847 xorl %eax, %eax movb %al, -0x31(%rbp) jmp 0x11847 movb -0x31(%rbp), %al andb $0x1, %al movb %al, -0x1(%rbp) jmp 0x118ba movl $0x20000000, -0x24(%rbp) # imm = 0x20000000 testb $0x1, -0x15(%rbp) je 0x11869 movl -0x24(%rbp), %eax orl $0x10000000, %eax # imm = 0x10000000 movl %eax, -0x24(%rbp) movq -0x30(%rbp), %rax movl -0x14(%rbp), %ecx addl $0x1, %ecx shll $0x4, %ecx movl %ecx, -0x28(%rbp) cmpq $0x0, 0x10(%rax) je 0x118ab movq -0x30(%rbp), %rax movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movl -0x28(%rbp), %eax orl $0x1, %eax movl %eax, %eax movl %eax, %edx movl -0x24(%rbp), %ecx movq (%rdi), %rax movzbl %sil, %esi callq 0x120(%rax) movb %al, -0x32(%rbp) jmp 0x118b2 xorl %eax, %eax movb %al, -0x32(%rbp) jmp 0x118b2 movb -0x32(%rbp), %al andb $0x1, %al movb %al, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x40, %rsp popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::WriteEncoderPreload(unsigned int, int)	bool AmpIO::WriteEncoderPreload(unsigned int index, int32_t sdata) { unsigned int channel = (index+1) << 4; if ((sdata >= ENC_MIDRANGE) \|\| (sdata < -ENC_MIDRANGE)) { std::cerr << "AmpIO::WriteEncoderPreload, preload out of range " << sdata << std::endl; return false; } bool ret = false; if (port && (index < NumEncoders)) { ret = port->WriteQuadlet(BoardId, channel \| ENC_LOAD_REG, static_cast<uint32_t>(sdata + ENC_MIDRANGE)); } return ret; }	pushq %rbp movq %rsp, %rbp subq $0x30, %rsp movq %rdi, -0x10(%rbp) movl %esi, -0x14(%rbp) movl %edx, -0x18(%rbp) movq -0x10(%rbp), %rax movq %rax, -0x28(%rbp) movl -0x14(%rbp), %eax addl $0x1, %eax shll $0x4, %eax movl %eax, -0x1c(%rbp) cmpl $0x800000, -0x18(%rbp) # imm = 0x800000 jge 0x11978 cmpl $0xff800000, -0x18(%rbp) # imm = 0xFF800000 jge 0x119ab movq 0x24671(%rip), %rdi # 0x35ff0 leaq 0x173b8(%rip), %rsi # 0x28d3e callq 0x6420 movq %rax, %rdi movl -0x18(%rbp), %esi callq 0x67d0 movq %rax, %rdi movq 0x24610(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x119ff movq -0x28(%rbp), %rax movb $0x0, -0x1d(%rbp) cmpq $0x0, 0x10(%rax) je 0x119f7 movq -0x28(%rbp), %rcx movl -0x14(%rbp), %eax cmpl 0x34(%rcx), %eax jae 0x119f7 movq -0x28(%rbp), %rax movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movl -0x1c(%rbp), %eax orl $0x4, %eax movl %eax, %eax movl %eax, %edx movl -0x18(%rbp), %ecx addl $0x800000, %ecx # imm = 0x800000 movq (%rdi), %rax movzbl %sil, %esi callq *0x120(%rax) andb $0x1, %al movb %al, -0x1d(%rbp) movb -0x1d(%rbp), %al andb $0x1, %al movb %al, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x30, %rsp popq %rbp retq nopw (%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::WriteDigitalOutput(unsigned char, unsigned char)	bool AmpIO::WriteDigitalOutput(uint8_t mask, uint8_t bits) { // Firmware versions < 5 have bits in reverse order with respect to schematic // (do not need to handle more than 4 bits in this case) if (GetFirmwareVersion() < 5) { mask = BitReverse4[mask&0x0f]; bits = BitReverse4[bits&0x0f]; } // Starting with Version 1.3.0 of this library, the digital outputs are inverted // before being sent because they are inverted in hardware and/or firmware. // This way, the digital output state matches the hardware state (i.e., 0 means digital output // is at 0V). quadlet_t write_data = (static_cast<quadlet_t>(mask) << 8) \| (static_cast<quadlet_t>(~bits)&mask); return port->WriteQuadlet(BoardId, 6, write_data); }	pushq %rbp movq %rsp, %rbp subq $0x20, %rsp movb %dl, %al movb %sil, %cl movq %rdi, -0x8(%rbp) movb %cl, -0x9(%rbp) movb %al, -0xa(%rbp) movq -0x8(%rbp), %rdi movq %rdi, -0x18(%rbp) callq 0xdd60 cmpl $0x5, %eax jae 0x11ad7 movzbl -0x9(%rbp), %eax andl $0xf, %eax movslq %eax, %rcx leaq 0x249e6(%rip), %rax # 0x364a0 movb (%rax,%rcx), %al movb %al, -0x9(%rbp) movzbl -0xa(%rbp), %eax andl $0xf, %eax movslq %eax, %rcx leaq 0x249cf(%rip), %rax # 0x364a0 movb (%rax,%rcx), %al movb %al, -0xa(%rbp) movq -0x18(%rbp), %rax movzbl -0x9(%rbp), %ecx shll $0x8, %ecx movzbl -0xa(%rbp), %edx xorl $-0x1, %edx movzbl -0x9(%rbp), %esi andl %esi, %edx orl %edx, %ecx movl %ecx, -0x10(%rbp) movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movl -0x10(%rbp), %ecx movq (%rdi), %rax movl $0x6, %edx movzbl %sil, %esi callq *0x120(%rax) andb $0x1, %al addq $0x20, %rsp popq %rbp retq nopl (%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::WriteWatchdogPeriodInSeconds(double, bool)	bool AmpIO::WriteWatchdogPeriodInSeconds(const double seconds, bool ledDisplay) { uint32_t counts; if (seconds == 0.0) { // Disable watchdog counts = 0; } else { // Use at least one tick just to make sure we don't accidentaly disable; // the truth is that the count will be so low that watchdog will // continuously trigger. counts = static_cast<uint32_t>(seconds/WDOG_ClockPeriod); counts = std::max(counts, static_cast<uint32_t>(1)); } if (ledDisplay) counts \|= 0x80000000; return WriteWatchdogPeriod(counts); }	pushq %rbp movq %rsp, %rbp subq $0x30, %rsp movb %sil, %al movq %rdi, -0x8(%rbp) movsd %xmm0, -0x10(%rbp) andb $0x1, %al movb %al, -0x11(%rbp) movq -0x8(%rbp), %rax movq %rax, -0x28(%rbp) movsd -0x10(%rbp), %xmm0 xorps %xmm1, %xmm1 ucomisd %xmm1, %xmm0 jne 0x11c1a jp 0x11c1a movl $0x0, -0x18(%rbp) jmp 0x11c4c movsd -0x10(%rbp), %xmm0 movsd 0x16ec1(%rip), %xmm1 # 0x28ae8 divsd %xmm1, %xmm0 cvttsd2si %xmm0, %rax movl %eax, -0x18(%rbp) movl $0x1, -0x1c(%rbp) leaq -0x18(%rbp), %rdi leaq -0x1c(%rbp), %rsi callq 0x14710 movl (%rax), %eax movl %eax, -0x18(%rbp) testb $0x1, -0x11(%rbp) je 0x11c5d movl -0x18(%rbp), %eax orl $0x80000000, %eax # imm = 0x80000000 movl %eax, -0x18(%rbp) movq -0x28(%rbp), %rdi movl -0x18(%rbp), %esi callq 0x11ba0 andb $0x1, %al addq $0x30, %rsp popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::WriteDoutControl(unsigned int, unsigned short, unsigned short)	bool AmpIO::WriteDoutControl(unsigned int index, uint16_t countsHigh, uint16_t countsLow) { if (GetFirmwareVersion() < 5) { std::cerr << "AmpIO::WriteDoutControl: requires firmware 5 or above" << std::endl; return false; } if (GetHardwareVersion() == dRA1_String) { std::cerr << "AmpIO::WriteDoutControl not implemented for dRAC" << std::endl; return false; } // Counter frequency = 49.152 MHz --> 1 count is about 0.02 uS // Max high/low time = (2^16-1)/49.152 usec = 1333.3 usec = 1.33 msec // The max PWM period with full adjustment of duty cycle (1-65535) is (2^16-1+1)/49.152 usec = 1.33 msec unsigned int channel = (index+1) << 4; if (port && (index < NumDouts)) { // Starting with Version 1.3.0 of this library, we swap the high and low times // because the digital outputs are inverted in hardware. uint32_t counts = (static_cast<uint32_t>(countsLow) << 16) \| countsHigh; return port->WriteQuadlet(BoardId, channel \| DOUT_CTRL_REG, counts); } else { return false; } }	pushq %rbp movq %rsp, %rbp subq $0x30, %rsp movw %cx, %ax movw %dx, %cx movq %rdi, -0x10(%rbp) movl %esi, -0x14(%rbp) movw %cx, -0x16(%rbp) movw %ax, -0x18(%rbp) movq -0x10(%rbp), %rdi movq %rdi, -0x28(%rbp) callq 0xdd60 cmpl $0x5, %eax jae 0x11cda movq 0x2433a(%rip), %rdi # 0x35ff0 leaq 0x170b3(%rip), %rsi # 0x28d70 callq 0x6420 movq %rax, %rdi movq 0x242e4(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x11d79 movq -0x28(%rbp), %rdi callq 0xde60 movl %eax, %eax cmpq $0x64524131, %rax # imm = 0x64524131 jne 0x11d15 movq 0x242fc(%rip), %rdi # 0x35ff0 leaq 0x170ab(%rip), %rsi # 0x28da6 callq 0x6420 movq %rax, %rdi movq 0x242a6(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x11d79 movq -0x28(%rbp), %rax movl -0x14(%rbp), %ecx addl $0x1, %ecx shll $0x4, %ecx movl %ecx, -0x1c(%rbp) cmpq $0x0, 0x10(%rax) je 0x11d75 movq -0x28(%rbp), %rcx movl -0x14(%rbp), %eax cmpl 0x38(%rcx), %eax jae 0x11d75 movq -0x28(%rbp), %rax movzwl -0x18(%rbp), %ecx shll $0x10, %ecx movzwl -0x16(%rbp), %edx orl %edx, %ecx movl %ecx, -0x20(%rbp) movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movl -0x1c(%rbp), %eax orl $0x8, %eax movl %eax, %eax movl %eax, %edx movl -0x20(%rbp), %ecx movq (%rdi), %rax movzbl %sil, %esi callq *0x120(%rax) andb $0x1, %al movb %al, -0x1(%rbp) jmp 0x11d79 movb $0x0, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x30, %rsp popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::WriteMotorConfig(unsigned int, unsigned int)	bool AmpIO::WriteMotorConfig(unsigned int index, uint32_t cfg) { bool ret = false; if (GetFirmwareVersion() < 8) return ret; if (HasQLA() && port && (index < NumMotors)) { unsigned int channel = (index+1) << 4; ret = port->WriteQuadlet(BoardId, channel \| MOTOR_CONFIG_REG, cfg); } return ret; }	pushq %rbp movq %rsp, %rbp subq $0x30, %rsp movq %rdi, -0x10(%rbp) movl %esi, -0x14(%rbp) movl %edx, -0x18(%rbp) movq -0x10(%rbp), %rdi movq %rdi, -0x28(%rbp) movb $0x0, -0x19(%rbp) callq 0xdd60 cmpl $0x8, %eax jae 0x12032 movb -0x19(%rbp), %al andb $0x1, %al movb %al, -0x1(%rbp) jmp 0x12097 movq -0x28(%rbp), %rdi callq 0xf420 testb $0x1, %al jne 0x12041 jmp 0x1208f movq -0x28(%rbp), %rax cmpq $0x0, 0x10(%rax) je 0x1208f movq -0x28(%rbp), %rcx movl -0x14(%rbp), %eax cmpl 0x30(%rcx), %eax jae 0x1208f movq -0x28(%rbp), %rax movl -0x14(%rbp), %ecx addl $0x1, %ecx shll $0x4, %ecx movl %ecx, -0x20(%rbp) movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movl -0x20(%rbp), %eax orl $0xb, %eax movl %eax, %eax movl %eax, %edx movl -0x18(%rbp), %ecx movq (%rdi), %rax movzbl %sil, %esi callq *0x120(%rax) andb $0x1, %al movb %al, -0x19(%rbp) movb -0x19(%rbp), %al andb $0x1, %al movb %al, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x30, %rsp popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::WriteMotorCurrentLimit(unsigned int, unsigned short)	bool AmpIO::WriteMotorCurrentLimit(unsigned int index, uint16_t mcurlim) { bool ret = false; if (GetFirmwareVersion() < 8) return ret; // Return false if motor current limit exceeds maximum range (rather // than allowing firmware to set msb to 0). if (mcurlim > 0x7fff) return ret; if (HasQLA() && port && (index < NumMotors)) { uint32_t cfg = MCFG_SET_CUR_LIMIT \| mcurlim; unsigned int channel = (index+1) << 4; ret = port->WriteQuadlet(BoardId, channel \| MOTOR_CONFIG_REG, cfg); } return ret; }	pushq %rbp movq %rsp, %rbp subq $0x30, %rsp movw %dx, %ax movq %rdi, -0x10(%rbp) movl %esi, -0x14(%rbp) movw %ax, -0x16(%rbp) movq -0x10(%rbp), %rdi movq %rdi, -0x28(%rbp) movb $0x0, -0x17(%rbp) callq 0xdd60 cmpl $0x8, %eax jae 0x120e9 movb -0x17(%rbp), %al andb $0x1, %al movb %al, -0x1(%rbp) jmp 0x12170 movzwl -0x16(%rbp), %eax cmpl $0x7fff, %eax # imm = 0x7FFF jle 0x120fe movb -0x17(%rbp), %al andb $0x1, %al movb %al, -0x1(%rbp) jmp 0x12170 movq -0x28(%rbp), %rdi callq 0xf420 testb $0x1, %al jne 0x1210d jmp 0x12168 movq -0x28(%rbp), %rax cmpq $0x0, 0x10(%rax) je 0x12168 movq -0x28(%rbp), %rcx movl -0x14(%rbp), %eax cmpl 0x30(%rcx), %eax jae 0x12168 movq -0x28(%rbp), %rax movzwl -0x16(%rbp), %ecx orl $0x1000000, %ecx # imm = 0x1000000 movl %ecx, -0x1c(%rbp) movl -0x14(%rbp), %ecx addl $0x1, %ecx shll $0x4, %ecx movl %ecx, -0x20(%rbp) movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movl -0x20(%rbp), %eax orl $0xb, %eax movl %eax, %eax movl %eax, %edx movl -0x1c(%rbp), %ecx movq (%rdi), %rax movzbl %sil, %esi callq *0x120(%rax) andb $0x1, %al movb %al, -0x17(%rbp) movb -0x17(%rbp), %al andb $0x1, %al movb %al, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x30, %rsp popq %rbp retq nopl (%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::WriteAmpEnableDelay(unsigned int, unsigned char)	bool AmpIO::WriteAmpEnableDelay(unsigned int index, uint8_t ampdelay) { bool ret = false; if (GetFirmwareVersion() < 8) return ret; if (HasQLA() && port && (index < NumMotors)) { uint32_t cfg = MCFG_SET_AMP_DELAY \| (ampdelay<<16); unsigned int channel = (index+1) << 4; ret = port->WriteQuadlet(BoardId, channel \| MOTOR_CONFIG_REG, cfg); } return ret; }	pushq %rbp movq %rsp, %rbp subq $0x30, %rsp movb %dl, %al movq %rdi, -0x10(%rbp) movl %esi, -0x14(%rbp) movb %al, -0x15(%rbp) movq -0x10(%rbp), %rdi movq %rdi, -0x28(%rbp) movb $0x0, -0x16(%rbp) callq 0xdd60 cmpl $0x8, %eax jae 0x121b4 movb -0x16(%rbp), %al andb $0x1, %al movb %al, -0x1(%rbp) jmp 0x12229 movq -0x28(%rbp), %rdi callq 0xf420 testb $0x1, %al jne 0x121c3 jmp 0x12221 movq -0x28(%rbp), %rax cmpq $0x0, 0x10(%rax) je 0x12221 movq -0x28(%rbp), %rcx movl -0x14(%rbp), %eax cmpl 0x30(%rcx), %eax jae 0x12221 movq -0x28(%rbp), %rax movzbl -0x15(%rbp), %ecx shll $0x10, %ecx orl $0x2000000, %ecx # imm = 0x2000000 movl %ecx, -0x1c(%rbp) movl -0x14(%rbp), %ecx addl $0x1, %ecx shll $0x4, %ecx movl %ecx, -0x20(%rbp) movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movl -0x20(%rbp), %eax orl $0xb, %eax movl %eax, %eax movl %eax, %edx movl -0x1c(%rbp), %ecx movq (%rdi), %rax movzbl %sil, %esi callq *0x120(%rax) andb $0x1, %al movb %al, -0x16(%rbp) movb -0x16(%rbp), %al andb $0x1, %al movb %al, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x30, %rsp popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::WriteEncoderPreloadAll(BasePort*, int)	bool AmpIO::WriteEncoderPreloadAll(BasePort *port, int32_t sdata) { bool ret = true; for (size_t index = 0; index < 8; ++index) { unsigned int channel = (index+1) << 4; if ((sdata >= ENC_MIDRANGE) \|\| (sdata < -ENC_MIDRANGE)) { std::cerr << "AmpIO::WriteEncoderPreloadAll, preload out of range " << sdata << std::endl; return false; } // Cannot use NumEncoders below because this is a static method if (port && (index < MAX_CHANNELS)) { ret &= port->WriteQuadlet(FW_NODE_BROADCAST, channel \| ENC_LOAD_REG, static_cast<uint32_t>(sdata + ENC_MIDRANGE)); } } return ret; }	pushq %rbp movq %rsp, %rbp subq $0x30, %rsp movq %rdi, -0x10(%rbp) movl %esi, -0x14(%rbp) movb $0x1, -0x15(%rbp) movq $0x0, -0x20(%rbp) cmpq $0x8, -0x20(%rbp) jae 0x123da movq -0x20(%rbp), %rax addq $0x1, %rax shlq $0x4, %rax movl %eax, -0x24(%rbp) cmpl $0x800000, -0x14(%rbp) # imm = 0x800000 jge 0x12347 cmpl $0xff800000, -0x14(%rbp) # imm = 0xFF800000 jge 0x1237a movq 0x23ca2(%rip), %rdi # 0x35ff0 leaq 0x16aab(%rip), %rsi # 0x28e00 callq 0x6420 movq %rax, %rdi movl -0x14(%rbp), %esi callq 0x67d0 movq %rax, %rdi movq 0x23c41(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x123e2 cmpq $0x0, -0x10(%rbp) je 0x123c7 cmpq $0x10, -0x20(%rbp) jae 0x123c7 movq -0x10(%rbp), %rdi movl -0x24(%rbp), %eax orl $0x4, %eax movl %eax, %eax movl %eax, %edx movl -0x14(%rbp), %ecx addl $0x800000, %ecx # imm = 0x800000 movq (%rdi), %rax movl $0x3f, %esi callq *0x120(%rax) andb $0x1, %al movzbl %al, %ecx movb -0x15(%rbp), %al andb $0x1, %al movzbl %al, %eax andl %ecx, %eax cmpl $0x0, %eax setne %al andb $0x1, %al movb %al, -0x15(%rbp) jmp 0x123c9 movq -0x20(%rbp), %rax addq $0x1, %rax movq %rax, -0x20(%rbp) jmp 0x1231b movb -0x15(%rbp), %al andb $0x1, %al movb %al, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x30, %rsp popq %rbp retq nopl (%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::DallasReadBlock(unsigned char*, unsigned int) const	bool AmpIO::DallasReadBlock(unsigned char data, unsigned int nbytes) const { if (GetHardwareVersion() == dRA1_String) return false; nodeaddr_t address = 0x6000; if (nbytes > 256) return false; if (port) return port->ReadBlock(BoardId, address, reinterpret_cast<quadlet_t >(data), nbytes); return false; }	pushq %rbp movq %rsp, %rbp subq $0x30, %rsp movq %rdi, -0x10(%rbp) movq %rsi, -0x18(%rbp) movl %edx, -0x1c(%rbp) movq -0x10(%rbp), %rdi movq %rdi, -0x30(%rbp) callq 0xde60 movl %eax, %eax cmpq $0x64524131, %rax # imm = 0x64524131 jne 0x128b0 movb $0x0, -0x1(%rbp) jmp 0x12902 movq $0x6000, -0x28(%rbp) # imm = 0x6000 cmpl $0x100, -0x1c(%rbp) # imm = 0x100 jbe 0x128c7 movb $0x0, -0x1(%rbp) jmp 0x12902 movq -0x30(%rbp), %rax cmpq $0x0, 0x10(%rax) je 0x128fe movq -0x30(%rbp), %rax movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movq -0x28(%rbp), %rdx movq -0x18(%rbp), %rcx movl -0x1c(%rbp), %r8d movq (%rdi), %rax movzbl %sil, %esi callq *0x130(%rax) andb $0x1, %al movb %al, -0x1(%rbp) jmp 0x12902 movb $0x0, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x30, %rsp popq %rbp retq nopl (%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::DallasWaitIdle()	bool AmpIO::DallasWaitIdle() { int i; uint32_t status; // For each block (256 bytes), wait up to 2000 msec. The actual processing time varies according to system setting. // Based on measurements, direct 1-wire interface costs about 250-300 msec to read entire 2048 bytes. // For DS2480B serial method, the approximate read time is 5 sec. for (i = 0; i < 2000; i++) { // Wait 1 msec Amp1394_Sleep(0.001); if (!DallasReadStatus(status)) return false; // Done when in idle state. The following test works for both Firmware Rev 7 // (state is bits 7:4) and Firmware Rev 8 (state is bits 8:4 and busy flag is bit 13) if ((status&0x000020F0) == 0) break; } //std::cerr << "Wait time = " << i << " milliseconds" << std::endl; return (i < 2000); }	pushq %rbp movq %rsp, %rbp subq $0x20, %rsp movq %rdi, -0x10(%rbp) movq -0x10(%rbp), %rax movq %rax, -0x20(%rbp) movl $0x0, -0x14(%rbp) cmpl $0x7d0, -0x14(%rbp) # imm = 0x7D0 jge 0x12974 movsd 0x161c4(%rip), %xmm0 # 0x28b00 callq 0x14790 movq -0x20(%rbp), %rdi leaq -0x18(%rbp), %rsi callq 0x12800 testb $0x1, %al jne 0x12958 movb $0x0, -0x1(%rbp) jmp 0x12983 movl -0x18(%rbp), %eax andl $0x20f0, %eax # imm = 0x20F0 cmpl $0x0, %eax jne 0x12967 jmp 0x12974 jmp 0x12969 movl -0x14(%rbp), %eax addl $0x1, %eax movl %eax, -0x14(%rbp) jmp 0x1292b cmpl $0x7d0, -0x14(%rbp) # imm = 0x7D0 setl %al andb $0x1, %al movb %al, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x20, %rsp popq %rbp retq nop	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::ReadRobotSerialNumber[abi:cxx11]() const	std::string AmpIO::ReadRobotSerialNumber() const { // Experimental: implementation will likely change const size_t read_length = 16; // 16 words, 32 bytes. char buf[read_length * 2 + 1] = {'\0'}; if (GetHardwareVersion() == dRA1_String) { uint16_t* buf16 = reinterpret_cast<uint16_t*>(buf); uint32_t base_flash_addr = 0; for (size_t i = 0; i < read_length; i++) { for (uint32_t flash_en = 0; flash_en < 2; flash_en++) { uint32_t flash_command = (flash_en << 28) \| (1 << 24) \| (base_flash_addr + i) ; port->WriteQuadlet(BoardId, 0xa002, flash_command); Amp1394_Sleep(0.01); } uint32_t q; port->ReadQuadlet(BoardId, 0xa031, q); buf16[i] = q & 0xFFFF; } port->WriteQuadlet(BoardId, 0xa002, 0); } std::string serial_number(buf); return serial_number; }	pushq %rbp movq %rsp, %rbp subq $0xa0, %rsp movq %rdi, -0x90(%rbp) movq %rdi, %rax movq %rax, -0x88(%rbp) movq %rdi, -0x8(%rbp) movq %rsi, -0x10(%rbp) movq -0x10(%rbp), %rax movq %rax, -0x80(%rbp) movq $0x10, -0x18(%rbp) leaq -0x40(%rbp), %rdi xorl %esi, %esi movl $0x21, %edx callq 0x62b0 movq -0x80(%rbp), %rdi callq 0xde60 movl %eax, %eax cmpq $0x64524131, %rax # imm = 0x64524131 jne 0x12e08 leaq -0x40(%rbp), %rax movq %rax, -0x48(%rbp) movl $0x0, -0x4c(%rbp) movq $0x0, -0x58(%rbp) cmpq $0x10, -0x58(%rbp) jae 0x12de8 movl $0x0, -0x5c(%rbp) cmpl $0x2, -0x5c(%rbp) jae 0x12d9e movq -0x80(%rbp), %rax movl -0x5c(%rbp), %ecx shll $0x1c, %ecx orl $0x1000000, %ecx # imm = 0x1000000 movl %ecx, %ecx movl -0x4c(%rbp), %edx addq -0x58(%rbp), %rdx orq %rdx, %rcx movl %ecx, -0x60(%rbp) movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movl -0x60(%rbp), %ecx movq (%rdi), %rax movl $0xa002, %edx # imm = 0xA002 movzbl %sil, %esi callq 0x120(%rax) movsd 0x15d7a(%rip), %xmm0 # 0x28b08 callq 0x14790 movl -0x5c(%rbp), %eax addl $0x1, %eax movl %eax, -0x5c(%rbp) jmp 0x12d44 movq -0x80(%rbp), %rax movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movq (%rdi), %rax movl $0xa031, %edx # imm = 0xA031 leaq -0x64(%rbp), %rcx movzbl %sil, %esi callq 0x118(%rax) movl -0x64(%rbp), %eax andl $0xffff, %eax # imm = 0xFFFF movw %ax, %dx movq -0x48(%rbp), %rax movq -0x58(%rbp), %rcx movw %dx, (%rax,%rcx,2) movq -0x58(%rbp), %rax addq $0x1, %rax movq %rax, -0x58(%rbp) jmp 0x12d32 movq -0x80(%rbp), %rax movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movq (%rdi), %rax movl $0xa002, %edx # imm = 0xA002 xorl %ecx, %ecx movzbl %sil, %esi callq *0x120(%rax) movb $0x0, -0x65(%rbp) leaq -0x66(%rbp), %rdi movq %rdi, -0x98(%rbp) callq 0x67f0 movq -0x90(%rbp), %rdi movq -0x98(%rbp), %rdx leaq -0x40(%rbp), %rsi callq 0xbb90 jmp 0x12e35 leaq -0x66(%rbp), %rdi callq 0x64c0 movb $0x1, -0x65(%rbp) testb $0x1, -0x65(%rbp) jne 0x12e6d jmp 0x12e61 movq %rax, %rcx movl %edx, %eax movq %rcx, -0x70(%rbp) movl %eax, -0x74(%rbp) leaq -0x66(%rbp), %rdi callq 0x64c0 jmp 0x12e7d movq -0x90(%rbp), %rdi callq 0x62d0 movq -0x88(%rbp), %rax addq $0xa0, %rsp popq %rbp retq movq -0x70(%rbp), %rdi callq 0x67e0 nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::WriteWaveformTable(unsigned int const*, unsigned short, unsigned short)	bool AmpIO::WriteWaveformTable(const quadlet_t buffer, unsigned short offset, unsigned short nquads) { if (GetFirmwareVersion() < 7) return false; if (GetHardwareVersion() == dRA1_String) return false; if (nquads == 0) return true; if (nquads > (port->GetMaxWriteDataSize()/sizeof(quadlet_t))) return false; if (offset > 1023) return false; static quadlet_t localBuffer[MAX_POSSIBLE_DATA_SIZE/sizeof(quadlet_t)]; nodeaddr_t address = 0x8000 + offset; // ADDR_WAVEFORM = 0x8000 // Byteswap and invert digital output bits (see WriteDigitalOutput and GetDigitalOutput) for (unsigned short i = 0; i < nquads; i++) localBuffer[i] = bswap_32(buffer[i]^0x0000000f); return port->WriteBlock(BoardId, address, localBuffer, nquadssizeof(quadlet_t)); }	pushq %rbp movq %rsp, %rbp subq $0x40, %rsp movw %cx, %ax movw %dx, %cx movq %rdi, -0x10(%rbp) movq %rsi, -0x18(%rbp) movw %cx, -0x1a(%rbp) movw %ax, -0x1c(%rbp) movq -0x10(%rbp), %rdi movq %rdi, -0x38(%rbp) callq 0xdd60 cmpl $0x7, %eax jae 0x13019 movb $0x0, -0x1(%rbp) jmp 0x13116 movq -0x38(%rbp), %rdi callq 0xde60 movl %eax, %eax cmpq $0x64524131, %rax # imm = 0x64524131 jne 0x13035 movb $0x0, -0x1(%rbp) jmp 0x13116 movzwl -0x1c(%rbp), %eax cmpl $0x0, %eax jne 0x13047 movb $0x1, -0x1(%rbp) jmp 0x13116 movq -0x38(%rbp), %rax movzwl -0x1c(%rbp), %ecx movq %rcx, -0x40(%rbp) movq 0x10(%rax), %rdi movq (%rdi), %rax callq 0xd0(%rax) movl %eax, %ecx movq -0x40(%rbp), %rax movl %ecx, %ecx shrq $0x2, %rcx cmpq %rcx, %rax jbe 0x1307a movb $0x0, -0x1(%rbp) jmp 0x13116 movzwl -0x1a(%rbp), %eax cmpl $0x3ff, %eax # imm = 0x3FF jle 0x1308e movb $0x0, -0x1(%rbp) jmp 0x13116 movzwl -0x1a(%rbp), %eax addl $0x8000, %eax # imm = 0x8000 cltq movq %rax, -0x28(%rbp) movw $0x0, -0x2a(%rbp) movzwl -0x2a(%rbp), %eax movzwl -0x1c(%rbp), %ecx cmpl %ecx, %eax jge 0x130e2 movq -0x18(%rbp), %rax movzwl -0x2a(%rbp), %ecx movl (%rax,%rcx,4), %edi xorl $0xf, %edi callq 0xe690 movl %eax, %edx movzwl -0x2a(%rbp), %eax movl %eax, %ecx leaq 0x23aaf(%rip), %rax # 0x36b80 movl %edx, (%rax,%rcx,4) movw -0x2a(%rbp), %ax addw $0x1, %ax movw %ax, -0x2a(%rbp) jmp 0x130a3 movq -0x38(%rbp), %rax movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movq -0x28(%rbp), %rdx movzwl -0x1c(%rbp), %eax shlq $0x2, %rax movl %eax, %r8d movq (%rdi), %rax leaq 0x23a79(%rip), %rcx # 0x36b80 movzbl %sil, %esi callq 0x138(%rax) andb $0x1, %al movb %al, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x40, %rsp popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::ReadCollectedData(unsigned int*, unsigned short, unsigned short)	bool AmpIO::ReadCollectedData(quadlet_t buffer, unsigned short offset, unsigned short nquads) { if (GetFirmwareVersion() < 7) return false; if (GetHardwareVersion() == DQLA_String) return false; if (nquads > (port->GetMaxReadDataSize()/sizeof(quadlet_t))) return false; if (offset > 1023) return false; nodeaddr_t address = 0x7000 + offset; // ADDR_DATA_BUF = 0x7000 bool ret = port->ReadBlock(BoardId, address, buffer, nquadssizeof(quadlet_t)); if (ret) { for (unsigned short i = 0; i < nquads; i++) buffer[i] = bswap_32(buffer[i]); } return ret; }	pushq %rbp movq %rsp, %rbp subq $0x40, %rsp movw %cx, %ax movw %dx, %cx movq %rdi, -0x10(%rbp) movq %rsi, -0x18(%rbp) movw %cx, -0x1a(%rbp) movw %ax, -0x1c(%rbp) movq -0x10(%rbp), %rdi movq %rdi, -0x38(%rbp) callq 0xdd60 cmpl $0x7, %eax jae 0x13429 movb $0x0, -0x1(%rbp) jmp 0x1351b movq -0x38(%rbp), %rdi callq 0xde60 movl %eax, %eax cmpq $0x44514c41, %rax # imm = 0x44514C41 jne 0x13445 movb $0x0, -0x1(%rbp) jmp 0x1351b movq -0x38(%rbp), %rax movzwl -0x1c(%rbp), %ecx movq %rcx, -0x40(%rbp) movq 0x10(%rax), %rdi movq (%rdi), %rax callq 0xc8(%rax) movl %eax, %ecx movq -0x40(%rbp), %rax movl %ecx, %ecx shrq $0x2, %rcx cmpq %rcx, %rax jbe 0x13478 movb $0x0, -0x1(%rbp) jmp 0x1351b movzwl -0x1a(%rbp), %eax cmpl $0x3ff, %eax # imm = 0x3FF jle 0x1348c movb $0x0, -0x1(%rbp) jmp 0x1351b movq -0x38(%rbp), %rax movzwl -0x1a(%rbp), %ecx addl $0x7000, %ecx # imm = 0x7000 movslq %ecx, %rcx movq %rcx, -0x28(%rbp) movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movq -0x28(%rbp), %rdx movq -0x18(%rbp), %rcx movzwl -0x1c(%rbp), %eax shlq $0x2, %rax movl %eax, %r8d movq (%rdi), %rax movzbl %sil, %esi callq 0x130(%rax) andb $0x1, %al movb %al, -0x29(%rbp) testb $0x1, -0x29(%rbp) je 0x13513 movw $0x0, -0x2c(%rbp) movzwl -0x2c(%rbp), %eax movzwl -0x1c(%rbp), %ecx cmpl %ecx, %eax jge 0x13511 movq -0x18(%rbp), %rax movzwl -0x2c(%rbp), %ecx movl (%rax,%rcx,4), %edi callq 0xe690 movl %eax, %edx movq -0x18(%rbp), %rax movzwl -0x2c(%rbp), %ecx movl %edx, (%rax,%rcx,4) movw -0x2c(%rbp), %ax addw $0x1, %ax movw %ax, -0x2c(%rbp) jmp 0x134da jmp 0x13513 movb -0x29(%rbp), %al andb $0x1, %al movb %al, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x40, %rsp popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::CheckCollectCallback()	void AmpIO::CheckCollectCallback() { if (collect_cb == 0) return; bool fpgaCollecting; unsigned char fpgaChan; unsigned short collect_windex; if (!GetCollectionStatus(fpgaCollecting, fpgaChan, collect_windex)) { std::cerr << "CheckCollectCallback: failed to get collection status" << std::endl; return; } // Wait to make sure FPGA is collecting data if (collect_state && !fpgaCollecting) return; if (fpgaChan != collect_chan) { std::cerr << "CheckCollectCallback: channel mismatch: " << static_cast<unsigned int>(fpgaChan) << ", " << static_cast<unsigned int>(collect_chan) << std::endl; // Continue processing } // Figure out how much data is available // (this implementation works correctly for unsigned integers) unsigned short numAvail = (collect_windex >= collect_rindex) ? (collect_windex-collect_rindex) : (COLLECT_BUFSIZE +collect_windex-collect_rindex); if (numAvail > 0) { if (numAvail > (port->GetMaxReadDataSize()/sizeof(quadlet_t))) numAvail = static_cast<unsigned short>(port->GetMaxReadDataSize()/sizeof(quadlet_t)); if (ReadCollectedData(collect_data, collect_rindex, numAvail)) { collect_rindex += numAvail; if (collect_rindex >= COLLECT_BUFSIZE) collect_rindex -= COLLECT_BUFSIZE; } else numAvail = 0; } if (!(*collect_cb)(collect_data, numAvail)) DataCollectionStop(); }	pushq %rbp movq %rsp, %rbp subq $0x30, %rsp movq %rdi, -0x8(%rbp) movq -0x8(%rbp), %rax movq %rax, -0x18(%rbp) cmpq $0x0, 0xe20(%rax) jne 0x13553 jmp 0x1373d movq -0x18(%rbp), %rdi leaq -0x9(%rbp), %rsi leaq -0xa(%rbp), %rdx leaq -0xc(%rbp), %rcx callq 0x13280 testb $0x1, %al jne 0x13593 movq 0x22a7d(%rip), %rdi # 0x35ff0 leaq 0x158f3(%rip), %rsi # 0x28e6d callq 0x6420 movq %rax, %rdi movq 0x22a27(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x1373d movq -0x18(%rbp), %rax testb $0x1, 0xe1c(%rax) je 0x135ab testb $0x1, -0x9(%rbp) jne 0x135ab jmp 0x1373d movq -0x18(%rbp), %rcx movzbl -0xa(%rbp), %eax movzbl 0xe1d(%rcx), %ecx cmpl %ecx, %eax je 0x1360e movq 0x22a2b(%rip), %rdi # 0x35ff0 leaq 0x158d7(%rip), %rsi # 0x28ea3 callq 0x6420 movq %rax, %rdi movzbl -0xa(%rbp), %esi callq 0x65d0 movq %rax, %rdi leaq 0x15d7a(%rip), %rsi # 0x29361 callq 0x6420 movq %rax, %rdi movq -0x18(%rbp), %rax movzbl 0xe1d(%rax), %esi callq 0x65d0 movq %rax, %rdi movq 0x229a7(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x18(%rbp), %rcx movzwl -0xc(%rbp), %eax movzwl 0xe28(%rcx), %ecx cmpl %ecx, %eax jl 0x13637 movq -0x18(%rbp), %rcx movzwl -0xc(%rbp), %eax movzwl 0xe28(%rcx), %ecx subl %ecx, %eax movl %eax, -0x1c(%rbp) jmp 0x13650 movq -0x18(%rbp), %rcx movzwl -0xc(%rbp), %eax addl $0x400, %eax # imm = 0x400 movzwl 0xe28(%rcx), %ecx subl %ecx, %eax movl %eax, -0x1c(%rbp) movl -0x1c(%rbp), %eax movw %ax, -0xe(%rbp) movzwl -0xe(%rbp), %eax cmpl $0x0, %eax jle 0x13718 movq -0x18(%rbp), %rax movzwl -0xe(%rbp), %ecx movq %rcx, -0x28(%rbp) movq 0x10(%rax), %rdi movq (%rdi), %rax callq 0xc8(%rax) movl %eax, %ecx movq -0x28(%rbp), %rax movl %ecx, %ecx shrq $0x2, %rcx cmpq %rcx, %rax jbe 0x136a9 movq -0x18(%rbp), %rax movq 0x10(%rax), %rdi movq (%rdi), %rax callq 0xc8(%rax) movl %eax, %eax shrq $0x2, %rax movw %ax, -0xe(%rbp) movq -0x18(%rbp), %rdi movq %rdi, %rsi addq $0x61c, %rsi # imm = 0x61C movw 0xe28(%rdi), %ax movzwl %ax, %edx movzwl -0xe(%rbp), %ecx callq 0x133f0 testb $0x1, %al jne 0x136d0 jmp 0x13710 movq -0x18(%rbp), %rax movzwl -0xe(%rbp), %edx movzwl 0xe28(%rax), %ecx addl %edx, %ecx movw %cx, 0xe28(%rax) movzwl 0xe28(%rax), %eax cmpl $0x400, %eax # imm = 0x400 jl 0x1370e movq -0x18(%rbp), %rax movzwl 0xe28(%rax), %ecx subl $0x400, %ecx # imm = 0x400 movw %cx, 0xe28(%rax) jmp 0x13716 movw $0x0, -0xe(%rbp) jmp 0x13718 movq -0x18(%rbp), %rdi movq 0xe20(%rdi), %rax addq $0x61c, %rdi # imm = 0x61C movswl -0xe(%rbp), %esi callq *%rax testb $0x1, %al jne 0x1373d movq -0x18(%rbp), %rdi callq 0x131f0 addq $0x30, %rsp popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
AmpIO::ExplainSiFault[abi:cxx11]() const	std::string AmpIO::ExplainSiFault() const { if (GetHardwareVersion() != dRA1_String) { return "Not a Si controller"; } std::stringstream ss; const char* amp_fault_text[16] = {"-", "ADC saturated", "Current deviation", "HW overcurrent", "HW overtemp", "Undefined", "Undefined", "Undefined", "Undefined", "Undefined", "Undefined", "Undefined", "Undefined", "Undefined", "Undefined", "Undefined"}; uint32_t status = GetStatus(); ss << "Explaining faults in the Si controller:" << std::endl; ss << std::endl; ss << "1. Interlocks that are preventing the axis from turning on:" << std::endl; if (!(status & (1 << 0))) ss << "ESPM->dVRK communication failed. Robot not programmed? Cables?" << std::endl; if ((status & (1 << 0)) && !(status & (1 << 1))) ss << "ESII/CC->ESPM communication failed. The problem is inside the robot." << std::endl; if (!(status & (1 << 3))) ss << "Encoder preload is out of sync. You must preload encoder at least once." << std::endl; if (!GetPowerStatus()) ss << "48V bad. E-stop pressed?" << std::endl; if (GetWatchdogTimeoutStatus()) ss << "Watchdog timeout." << std::endl; ss << "(end)" << std::endl; ss << std::endl; ss << "2. Amps that are in fault state:" << std::endl; for (unsigned int i = 0; i < NumMotors; i++) { // std::cout << NumMotors << std::endl; uint32_t amp_fault = GetAmpFaultCode(i); // std::cout << amp_fault << std::endl; if (amp_fault) { ss << "Amp " << i << ": " << amp_fault_text[amp_fault] << std::endl; } } ss << "(end)" << std::endl; ss << std::endl; ss << std::endl; return ss.str(); }	pushq %rbp movq %rsp, %rbp subq $0x2e0, %rsp # imm = 0x2E0 movq %rdi, -0x258(%rbp) movq %rdi, %rax movq %rax, -0x250(%rbp) movq %rdi, -0x8(%rbp) movq %rsi, -0x10(%rbp) movq -0x10(%rbp), %rdi movq %rdi, -0x248(%rbp) callq 0xde60 movl %eax, %eax cmpq $0x64524131, %rax # imm = 0x64524131 je 0x137e2 leaq -0x11(%rbp), %rdi movq %rdi, -0x260(%rbp) callq 0x67f0 movq -0x258(%rbp), %rdi movq -0x260(%rbp), %rdx leaq 0x15719(%rip), %rsi # 0x28ecc callq 0xbb90 jmp 0x137ba leaq -0x11(%rbp), %rdi callq 0x64c0 jmp 0x13c58 movq %rax, %rcx movl %edx, %eax movq %rcx, -0x20(%rbp) movl %eax, -0x24(%rbp) leaq -0x11(%rbp), %rdi callq 0x64c0 jmp 0x13c68 leaq -0x1b0(%rbp), %rdi callq 0x6300 movq -0x248(%rbp), %rdi movaps 0x21d94(%rip), %xmm0 # 0x35590 movaps %xmm0, -0x1c0(%rbp) movaps 0x21d76(%rip), %xmm0 # 0x35580 movaps %xmm0, -0x1d0(%rbp) movaps 0x21d58(%rip), %xmm0 # 0x35570 movaps %xmm0, -0x1e0(%rbp) movaps 0x21d3a(%rip), %xmm0 # 0x35560 movaps %xmm0, -0x1f0(%rbp) movaps 0x21d1c(%rip), %xmm0 # 0x35550 movaps %xmm0, -0x200(%rbp) movaps 0x21cfe(%rip), %xmm0 # 0x35540 movaps %xmm0, -0x210(%rbp) movaps 0x21ce0(%rip), %xmm0 # 0x35530 movaps %xmm0, -0x220(%rbp) movaps 0x21cc2(%rip), %xmm0 # 0x35520 movaps %xmm0, -0x230(%rbp) callq 0xf470 movl %eax, -0x234(%rbp) leaq -0x1a0(%rbp), %rdi leaq 0x156a7(%rip), %rsi # 0x28f25 callq 0x6420 movq %rax, -0x268(%rbp) jmp 0x1388c movq -0x268(%rbp), %rdi movq 0x22716(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x138a1 leaq -0x1a0(%rbp), %rdi movq 0x22701(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x138b6 leaq -0x1a0(%rbp), %rdi leaq 0x15689(%rip), %rsi # 0x28f4d callq 0x6420 movq %rax, -0x270(%rbp) jmp 0x138d2 movq -0x270(%rbp), %rdi movq 0x226d0(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x138e7 movl -0x234(%rbp), %eax andl $0x1, %eax cmpl $0x0, %eax jne 0x13945 leaq -0x1a0(%rbp), %rdi leaq 0x15686(%rip), %rsi # 0x28f89 callq 0x6420 movq %rax, -0x278(%rbp) jmp 0x13911 movq -0x278(%rbp), %rdi movq 0x22691(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x13926 jmp 0x13945 movq %rax, %rcx movl %edx, %eax movq %rcx, -0x20(%rbp) movl %eax, -0x24(%rbp) leaq -0x1b0(%rbp), %rdi callq 0x6320 jmp 0x13c68 movl -0x234(%rbp), %eax andl $0x1, %eax cmpl $0x0, %eax je 0x13994 movl -0x234(%rbp), %eax andl $0x2, %eax cmpl $0x0, %eax jne 0x13994 leaq -0x1a0(%rbp), %rdi leaq 0x15659(%rip), %rsi # 0x28fc8 callq 0x6420 movq %rax, -0x280(%rbp) jmp 0x1397d movq -0x280(%rbp), %rdi movq 0x22625(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x13992 jmp 0x13994 movl -0x234(%rbp), %eax andl $0x8, %eax cmpl $0x0, %eax jne 0x139d5 leaq -0x1a0(%rbp), %rdi leaq 0x1565d(%rip), %rsi # 0x2900d callq 0x6420 movq %rax, -0x288(%rbp) jmp 0x139be movq -0x288(%rbp), %rdi movq 0x225e4(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x139d3 jmp 0x139d5 movq -0x248(%rbp), %rdi xorl %esi, %esi callq 0x10120 movb %al, -0x289(%rbp) jmp 0x139eb movb -0x289(%rbp), %al testb $0x1, %al jne 0x13a2a jmp 0x139f7 leaq -0x1a0(%rbp), %rdi leaq 0x15650(%rip), %rsi # 0x29055 callq 0x6420 movq %rax, -0x298(%rbp) jmp 0x13a13 movq -0x298(%rbp), %rdi movq 0x2258f(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x13a28 jmp 0x13a2a movq -0x248(%rbp), %rdi callq 0x102a0 testb $0x1, %al jne 0x13a3c jmp 0x13a6f leaq -0x1a0(%rbp), %rdi leaq 0x15624(%rip), %rsi # 0x2906e callq 0x6420 movq %rax, -0x2a0(%rbp) jmp 0x13a58 movq -0x2a0(%rbp), %rdi movq 0x2254a(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x13a6d jmp 0x13a6f leaq -0x1a0(%rbp), %rdi leaq 0x15603(%rip), %rsi # 0x29080 callq 0x6420 movq %rax, -0x2a8(%rbp) jmp 0x13a8b movq -0x2a8(%rbp), %rdi movq 0x22517(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x13aa0 leaq -0x1a0(%rbp), %rdi movq 0x22502(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x13ab5 leaq -0x1a0(%rbp), %rdi leaq 0x155c3(%rip), %rsi # 0x29086 callq 0x6420 movq %rax, -0x2b0(%rbp) jmp 0x13ad1 movq -0x2b0(%rbp), %rdi movq 0x224d1(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x13ae6 movl $0x0, -0x238(%rbp) movq -0x248(%rbp), %rcx movl -0x238(%rbp), %eax cmpl 0x30(%rcx), %eax jae 0x13bdc movq -0x248(%rbp), %rdi movl -0x238(%rbp), %esi callq 0x105f0 movl %eax, -0x2b4(%rbp) jmp 0x13b20 movl -0x2b4(%rbp), %eax movl %eax, -0x23c(%rbp) cmpl $0x0, -0x23c(%rbp) je 0x13bc6 leaq -0x1a0(%rbp), %rdi leaq 0x15560(%rip), %rsi # 0x290a7 callq 0x6420 movq %rax, -0x2c0(%rbp) jmp 0x13b55 movq -0x2c0(%rbp), %rdi movl -0x238(%rbp), %esi callq 0x65d0 movq %rax, -0x2c8(%rbp) jmp 0x13b70 movq -0x2c8(%rbp), %rdi leaq 0x16bb7(%rip), %rsi # 0x2a735 callq 0x6420 movq %rax, -0x2d0(%rbp) jmp 0x13b8c movq -0x2d0(%rbp), %rdi movl -0x23c(%rbp), %eax movq -0x230(%rbp,%rax,8), %rsi callq 0x6420 movq %rax, -0x2d8(%rbp) jmp 0x13baf movq -0x2d8(%rbp), %rdi movq 0x223f3(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x13bc4 jmp 0x13bc6 jmp 0x13bc8 movl -0x238(%rbp), %eax addl $0x1, %eax movl %eax, -0x238(%rbp) jmp 0x13af0 leaq -0x1a0(%rbp), %rdi leaq 0x15496(%rip), %rsi # 0x29080 callq 0x6420 movq %rax, -0x2e0(%rbp) jmp 0x13bf8 movq -0x2e0(%rbp), %rdi movq 0x223aa(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x13c0d leaq -0x1a0(%rbp), %rdi movq 0x22395(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x13c22 leaq -0x1a0(%rbp), %rdi movq 0x22380(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x13c37 movq -0x258(%rbp), %rdi leaq -0x1b0(%rbp), %rsi callq 0x6410 jmp 0x13c4c leaq -0x1b0(%rbp), %rdi callq 0x6320 movq -0x250(%rbp), %rax addq $0x2e0, %rsp # imm = 0x2E0 popq %rbp retq movq -0x20(%rbp), %rdi callq 0x67e0 nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/AmpIO.cpp
Amp1394_Sleep(double)	void Amp1394_Sleep(double sec) { #ifdef _MSC_VER // A waitable timer seems to be better than the Windows Sleep(). HANDLE WaitTimer; LARGE_INTEGER dueTime; sec = -10.0 1000.0 * 1000.0; dueTime.QuadPart = static_cast<LONGLONG>(sec); //dueTime is in 100ns // We don't name the timer (third parameter) because CreateWaitableTimer will fail if the name // matches an existing name (e.g., if two threads call osaSleep). WaitTimer = CreateWaitableTimer(NULL, true, NULL); SetWaitableTimer(WaitTimer, &dueTime, 0, NULL, NULL, 0); WaitForSingleObject(WaitTimer, INFINITE); CloseHandle(WaitTimer); #else const long nSecInSec = 1000L * 1000L * 1000L; struct timespec ts; ts.tv_sec = static_cast<long> (sec); ts.tv_nsec = static_cast<long> ( (sec-ts.tv_sec) * nSecInSec ); nanosleep(&ts, NULL); #endif }	pushq %rbp movq %rsp, %rbp subq $0x20, %rsp movsd %xmm0, -0x8(%rbp) movq $0x3b9aca00, -0x10(%rbp) # imm = 0x3B9ACA00 cvttsd2si -0x8(%rbp), %rax movq %rax, -0x20(%rbp) movsd -0x8(%rbp), %xmm0 cvtsi2sdq -0x20(%rbp), %xmm1 subsd %xmm1, %xmm0 movsd 0x1492a(%rip), %xmm1 # 0x290f0 mulsd %xmm1, %xmm0 cvttsd2si %xmm0, %rax movq %rax, -0x18(%rbp) leaq -0x20(%rbp), %rdi xorl %eax, %eax movl %eax, %esi callq 0x6190 addq $0x20, %rsp popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/Amp1394Time.cpp
BasePort::BroadcastReadInfo::PrepareForRead()	void BasePort::BroadcastReadInfo::PrepareForRead() { // Initialize update Start/Finish times (i.e., start/end of data update on FPGA Hub) // Units are seconds. updateStartTime = 1.0; updateFinishTime = 0.0; updateOverflow = false; readOverflow = false; for (unsigned int bnum = 0; bnum < BoardIO::MAX_BOARDS; bnum++) boardInfo[bnum].updated = false; }	pushq %rbp movq %rsp, %rbp movq %rdi, -0x8(%rbp) movq -0x8(%rbp), %rax movq %rax, -0x18(%rbp) movsd 0x13028(%rip), %xmm0 # 0x28030 movsd %xmm0, 0x8(%rax) xorps %xmm0, %xmm0 movsd %xmm0, 0x10(%rax) movb $0x0, 0x18(%rax) movb $0x0, 0x30(%rax) movl $0x0, -0xc(%rbp) cmpl $0x10, -0xc(%rbp) jae 0x1504b movq -0x18(%rbp), %rax addq $0x50, %rax movl -0xc(%rbp), %ecx shlq $0x5, %rcx addq %rcx, %rax movb $0x0, 0x1(%rax) movl -0xc(%rbp), %eax addl $0x1, %eax movl %eax, -0xc(%rbp) jmp 0x15024 popq %rbp retq nopl (%rax)	/jhu-cisst[P]mechatronics-software/lib/code/BasePort.cpp
BasePort::BroadcastReadInfo::PrintTiming(std::ostream&) const	void BasePort::BroadcastReadInfo::PrintTiming(std::ostream &outStr) const { unsigned int num_bds = 0; outStr << "Updates (usec): "; for (unsigned int bnum = 0; bnum < BoardIO::MAX_BOARDS; bnum++) { if (boardInfo[bnum].inUse) { double bdTime_us = boardInfo[bnum].updateTime1e6; outStr << bnum << ": " << std::fixed << std::setprecision(2) << bdTime_us << " "; num_bds++; } } double bdTimeDiff_us = (updateFinishTime-updateStartTime)1e6; outStr << "Range: " << std::fixed << std::setprecision(2) << bdTimeDiff_us; if (num_bds > 1) outStr << " (" << (bdTimeDiff_us/(num_bds-1)) << ") "; outStr << (updateOverflow ? "OVF" : " "); outStr << std::endl; outStr << "Read start: " << std::fixed << std::setprecision(2) << std::setw(6) << (readStartTime1e6) << " finish: " << std::setw(6) << (readFinishTime1e6) << " delta: " << ((readFinishTime-readStartTime)1e6) << " gap: " << std::setw(6) << (gapTime1e6); if ((gapTimeMin != 1.0) && (gapTimeMax != 0.0)) { outStr << " (min " << std::setw(6) << (gapTimeMin1e6) << ", max " << (gapTimeMax1e6) << ") "; } outStr << (readOverflow ? "OVF" : " "); outStr << std::endl; }	pushq %rbp movq %rsp, %rbp subq $0xb0, %rsp movq %rdi, -0x8(%rbp) movq %rsi, -0x10(%rbp) movq -0x8(%rbp), %rax movq %rax, -0x50(%rbp) movl $0x0, -0x14(%rbp) movq -0x10(%rbp), %rdi leaq 0x140ab(%rip), %rsi # 0x29128 callq 0x6420 movl $0x0, -0x18(%rbp) cmpl $0x10, -0x18(%rbp) jae 0x1514e movq -0x50(%rbp), %rax addq $0x50, %rax movl -0x18(%rbp), %ecx shlq $0x5, %rcx addq %rcx, %rax testb $0x1, (%rax) je 0x1513e movq -0x50(%rbp), %rax addq $0x50, %rax movl -0x18(%rbp), %ecx shlq $0x5, %rcx addq %rcx, %rax movsd 0x14050(%rip), %xmm0 # 0x29118 mulsd 0x18(%rax), %xmm0 movsd %xmm0, -0x20(%rbp) movq -0x10(%rbp), %rdi movl -0x18(%rbp), %esi callq 0x65d0 movq %rax, %rdi leaq 0x1564d(%rip), %rsi # 0x2a735 callq 0x6420 movq %rax, %rdi leaq 0x4e59(%rip), %rsi # 0x19f50 callq 0x61f0 movq %rax, -0x58(%rbp) movl $0x2, %edi callq 0x19f80 movq -0x58(%rbp), %rdi movl %eax, -0x24(%rbp) movl -0x24(%rbp), %esi callq 0x6710 movq %rax, %rdi movsd -0x20(%rbp), %xmm0 callq 0x6890 movq %rax, %rdi leaq 0x13704(%rip), %rsi # 0x28834 callq 0x6420 movl -0x14(%rbp), %eax addl $0x1, %eax movl %eax, -0x14(%rbp) jmp 0x15140 movl -0x18(%rbp), %eax addl $0x1, %eax movl %eax, -0x18(%rbp) jmp 0x15089 movq -0x50(%rbp), %rax movsd 0x10(%rax), %xmm0 subsd 0x8(%rax), %xmm0 movsd 0x13fb4(%rip), %xmm1 # 0x29118 mulsd %xmm1, %xmm0 movsd %xmm0, -0x30(%rbp) movq -0x10(%rbp), %rdi leaq 0x13fc1(%rip), %rsi # 0x29139 callq 0x6420 movq %rax, %rdi leaq 0x4dc9(%rip), %rsi # 0x19f50 callq 0x61f0 movq %rax, -0x60(%rbp) movl $0x2, %edi callq 0x19f80 movq -0x60(%rbp), %rdi movl %eax, -0x34(%rbp) movl -0x34(%rbp), %esi callq 0x6710 movq %rax, %rdi movsd -0x30(%rbp), %xmm0 callq 0x6890 cmpl $0x1, -0x14(%rbp) jbe 0x151f6 movq -0x10(%rbp), %rdi leaq 0x1493d(%rip), %rsi # 0x29b04 callq 0x6420 movq %rax, %rdi movsd -0x30(%rbp), %xmm0 movl -0x14(%rbp), %eax decl %eax cvtsi2sd %rax, %xmm1 divsd %xmm1, %xmm0 callq 0x6890 movq %rax, %rdi leaq 0x14b99(%rip), %rsi # 0x29d8a callq 0x6420 movq -0x50(%rbp), %rax movq -0x10(%rbp), %rcx movq %rcx, -0x68(%rbp) testb $0x1, 0x18(%rax) je 0x15215 leaq 0x13f32(%rip), %rax # 0x29141 movq %rax, -0x70(%rbp) jmp 0x15222 leaq 0x13618(%rip), %rax # 0x28834 movq %rax, -0x70(%rbp) jmp 0x15222 movq -0x68(%rbp), %rdi movq -0x70(%rbp), %rsi callq 0x6420 movq -0x10(%rbp), %rdi movq 0x20d76(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x10(%rbp), %rdi leaq 0x13efb(%rip), %rsi # 0x29145 callq 0x6420 movq %rax, %rdi leaq 0x4cf7(%rip), %rsi # 0x19f50 callq 0x61f0 movq %rax, -0x90(%rbp) movl $0x2, %edi callq 0x19f80 movq -0x90(%rbp), %rdi movl %eax, -0x38(%rbp) movl -0x38(%rbp), %esi callq 0x6710 movq %rax, -0x88(%rbp) movl $0x6, %edi callq 0x19fa0 movq -0x88(%rbp), %rdi movl %eax, -0x3c(%rbp) movl -0x3c(%rbp), %esi callq 0x6540 movq %rax, %rdi movq -0x50(%rbp), %rax movsd 0x13e65(%rip), %xmm0 # 0x29118 mulsd 0x20(%rax), %xmm0 callq 0x6890 movq %rax, %rdi leaq 0x13e8b(%rip), %rsi # 0x29152 callq 0x6420 movq %rax, -0x80(%rbp) movl $0x6, %edi callq 0x19fa0 movq -0x80(%rbp), %rdi movl %eax, -0x40(%rbp) movl -0x40(%rbp), %esi callq 0x6540 movq %rax, %rdi movq -0x50(%rbp), %rax movsd 0x13e20(%rip), %xmm0 # 0x29118 mulsd 0x28(%rax), %xmm0 callq 0x6890 movq %rax, %rdi leaq 0x13e51(%rip), %rsi # 0x2915d callq 0x6420 movq %rax, %rdi movq -0x50(%rbp), %rax movsd 0x28(%rax), %xmm0 subsd 0x20(%rax), %xmm0 movsd 0x13dee(%rip), %xmm1 # 0x29118 mulsd %xmm1, %xmm0 callq 0x6890 movq %rax, %rdi leaq 0x13e2a(%rip), %rsi # 0x29167 callq 0x6420 movq %rax, -0x78(%rbp) movl $0x6, %edi callq 0x19fa0 movq -0x78(%rbp), %rdi movl %eax, -0x44(%rbp) movl -0x44(%rbp), %esi callq 0x6540 movq %rax, %rdi movq -0x50(%rbp), %rax movsd 0x13daa(%rip), %xmm0 # 0x29118 mulsd 0x38(%rax), %xmm0 callq 0x6890 movq -0x50(%rbp), %rax movsd 0x40(%rax), %xmm0 movsd 0x12ca7(%rip), %xmm1 # 0x28030 ucomisd %xmm1, %xmm0 jne 0x15396 jp 0x15396 jmp 0x15432 movq -0x50(%rbp), %rax movsd 0x48(%rax), %xmm0 xorps %xmm1, %xmm1 ucomisd %xmm1, %xmm0 jne 0x153af jp 0x153af jmp 0x15432 movq -0x10(%rbp), %rdi leaq 0x13db5(%rip), %rsi # 0x2916f callq 0x6420 movq %rax, -0x98(%rbp) movl $0x6, %edi callq 0x19fa0 movq -0x98(%rbp), %rdi movl %eax, -0x48(%rbp) movl -0x48(%rbp), %esi callq 0x6540 movq %rax, %rdi movq -0x50(%rbp), %rax movsd 0x13d27(%rip), %xmm0 # 0x29118 mulsd 0x40(%rax), %xmm0 callq 0x6890 movq %rax, %rdi leaq 0x13d71(%rip), %rsi # 0x29176 callq 0x6420 movq %rax, %rdi movq -0x50(%rbp), %rax movsd 0x13cff(%rip), %xmm0 # 0x29118 mulsd 0x48(%rax), %xmm0 callq 0x6890 movq %rax, %rdi leaq 0x1495d(%rip), %rsi # 0x29d8a callq 0x6420 movq -0x50(%rbp), %rax movq -0x10(%rbp), %rcx movq %rcx, -0xa0(%rbp) testb $0x1, 0x30(%rax) je 0x15457 leaq 0x13cf3(%rip), %rax # 0x29141 movq %rax, -0xa8(%rbp) jmp 0x15467 leaq 0x133d6(%rip), %rax # 0x28834 movq %rax, -0xa8(%rbp) jmp 0x15467 movq -0xa0(%rbp), %rdi movq -0xa8(%rbp), %rsi callq 0x6420 movq -0x10(%rbp), %rdi movq 0x20b2b(%rip), %rsi # 0x35fb0 callq 0x6490 addq $0xb0, %rsp popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/BasePort.cpp
BasePort::BasePort(int, std::ostream&)	BasePort::BasePort(int portNum, std::ostream &ostr): outStr(ostr), Protocol_(BasePort::PROTOCOL_SEQ_RW), IsAllBoardsBroadcastCapable_(false), IsAllBoardsRev4_5_(false), IsAllBoardsRev4_6_(false), IsAllBoardsRev6_(false), IsAllBoardsRev7_(false), IsAllBoardsRev8_9_(false), ReadErrorCounter_(0), PortNum(portNum), FwBusGeneration(0), newFwBusGeneration(0), autoReScan(true), NumOfNodes_(0), NumOfBoards_(0), BoardInUseMask_(0), max_board(0), HubBoard(BoardIO::MAX_BOARDS) { size_t i; for (i = 0; i < BoardIO::MAX_BOARDS; i++) { BoardList[i] = 0; FirmwareVersion[i] = 0; FpgaVersion[i] = 0; HardwareVersion[i] = 0; Board2Node[i] = MAX_NODES; } ReadBufferBroadcast = 0; WriteBufferBroadcast = 0; GenericBuffer = 0; for (i = 0; i < MAX_NODES; i++) Node2Board[i] = BoardIO::MAX_BOARDS; // Note that AddHardwareVersion will not add duplicates BasePort::AddHardwareVersion(QLA1_String); BasePort::AddHardwareVersion(dRA1_String); BasePort::AddHardwareVersion(DQLA_String); BasePort::AddHardwareVersion(BCFG_String); BasePort::AddHardwareVersion(0x54455354); // "TEST" }	pushq %rbp movq %rsp, %rbp subq $0x40, %rsp movq %rdi, -0x8(%rbp) movl %esi, -0xc(%rbp) movq %rdx, -0x18(%rbp) movq -0x8(%rbp), %rdi movq %rdi, -0x40(%rbp) leaq 0x200f6(%rip), %rax # 0x355b8 addq $0x10, %rax movq %rax, (%rdi) movq -0x18(%rbp), %rax movq %rax, 0x8(%rdi) movl $0x0, 0x10(%rdi) movb $0x0, 0x14(%rdi) movb $0x0, 0x15(%rdi) movb $0x0, 0x16(%rdi) movb $0x0, 0x17(%rdi) movb $0x0, 0x18(%rdi) movb $0x0, 0x19(%rdi) movq $0x0, 0x20(%rdi) movl -0xc(%rbp), %eax movl %eax, 0x28(%rdi) movl $0x0, 0x2c(%rdi) movl $0x0, 0x30(%rdi) movb $0x1, 0x34(%rdi) movl $0x0, 0x38(%rdi) movl $0x0, 0xc0(%rdi) movl $0x0, 0xc4(%rdi) movl $0x0, 0xc8(%rdi) movb $0x10, 0xcc(%rdi) addq $0xf0, %rdi movq %rdi, -0x38(%rbp) callq 0xc1f0 movq $0x0, -0x20(%rbp) cmpq $0x10, -0x20(%rbp) jae 0x155b7 movq -0x40(%rbp), %rax movq -0x20(%rbp), %rcx movq $0x0, 0x40(%rax,%rcx,8) movq -0x20(%rbp), %rcx movq $0x0, 0x340(%rax,%rcx,8) movq -0x20(%rbp), %rcx movl $0x0, 0x3c0(%rax,%rcx,4) movq -0x20(%rbp), %rcx movq $0x0, 0x400(%rax,%rcx,8) movq -0x20(%rbp), %rcx movw $0x40, 0x4c0(%rax,%rcx,2) movq -0x20(%rbp), %rax addq $0x1, %rax movq %rax, -0x20(%rbp) jmp 0x15554 movq -0x40(%rbp), %rax movq $0x0, 0xd8(%rax) movq $0x0, 0xd0(%rax) movq $0x0, 0xe0(%rax) movq $0x0, -0x20(%rbp) cmpq $0x40, -0x20(%rbp) jae 0x15609 movq -0x40(%rbp), %rax movq -0x20(%rbp), %rcx movb $0x10, 0x480(%rax,%rcx) movq -0x20(%rbp), %rax addq $0x1, %rax movq %rax, -0x20(%rbp) jmp 0x155e4 movl $0x514c4131, %edi # imm = 0x514C4131 callq 0x15670 jmp 0x15615 movl $0x64524131, %edi # imm = 0x64524131 callq 0x15670 jmp 0x15621 movl $0x44514c41, %edi # imm = 0x44514C41 callq 0x15670 jmp 0x1562d movl $0x42434647, %edi # imm = 0x42434647 callq 0x15670 jmp 0x15639 movl $0x54455354, %edi # imm = 0x54455354 callq 0x15670 jmp 0x15645 addq $0x40, %rsp popq %rbp retq movq -0x38(%rbp), %rdi movq %rax, %rcx movl %edx, %eax movq %rcx, -0x28(%rbp) movl %eax, -0x2c(%rbp) callq 0xc320 movq -0x28(%rbp), %rdi callq 0x67e0 nopl (%rax)	/jhu-cisst[P]mechatronics-software/lib/code/BasePort.cpp
BasePort::~BasePort()	BasePort::~BasePort() { delete [] ReadBufferBroadcast; delete [] WriteBufferBroadcast; delete [] GenericBuffer; }	pushq %rbp movq %rsp, %rbp subq $0x30, %rsp movq %rdi, -0x8(%rbp) movq -0x8(%rbp), %rax movq %rax, -0x18(%rbp) leaq 0x1feed(%rip), %rcx # 0x355b8 addq $0x10, %rcx movq %rcx, (%rax) movq 0xd8(%rax), %rax movq %rax, -0x10(%rbp) cmpq $0x0, %rax je 0x156ec movq -0x10(%rbp), %rdi callq 0x6590 movq -0x18(%rbp), %rax movq 0xd0(%rax), %rax movq %rax, -0x20(%rbp) cmpq $0x0, %rax je 0x1570a movq -0x20(%rbp), %rdi callq 0x6590 movq -0x18(%rbp), %rax movq 0xe0(%rax), %rax movq %rax, -0x28(%rbp) cmpq $0x0, %rax je 0x15728 movq -0x28(%rbp), %rdi callq 0x6590 movq -0x18(%rbp), %rdi addq $0xf0, %rdi callq 0xc320 addq $0x30, %rsp popq %rbp retq nop	/jhu-cisst[P]mechatronics-software/lib/code/BasePort.cpp
BasePort::ParseProtocol(char const*, BasePort::ProtocolType&, std::ostream&)	bool BasePort::ParseProtocol(const char * arg, ProtocolType & protocol, std::ostream & ostr) { // no option, using default if ((arg == 0) \|\| (strlen(arg) == 0)) { ostr << "ParseProtocol: no protocol provided" << std::endl; return false; } // convert arg to string std::string name(arg); // this could likely be implemented using a static map if ((name == "sequential-read-write") \|\| (name == "srw")) { protocol = PROTOCOL_SEQ_RW; return true; } else if ((name == "sequential-read-broadcast-write") \|\| (name == "srbw")) { protocol = PROTOCOL_SEQ_R_BC_W; return true; } else if ((name == "broadcast-read-write") \|\| (name == "brw") \|\| (name == "broadcast-query-read-write") \|\| (name == "bqrw")) { protocol = PROTOCOL_BC_QRW; return true; } ostr << "ParseProtocol: no protocol \"" << name << "\" is not supported, use sequential-read-write, srw, sequential-read-broadcast-write, srbw, broadcast-query-read-write or bqrw" << std::endl; return false; }	pushq %rbp movq %rsp, %rbp subq $0x90, %rsp movq %rdi, -0x10(%rbp) movq %rsi, -0x18(%rbp) movq %rdx, -0x20(%rbp) cmpq $0x0, -0x10(%rbp) je 0x158ed movq -0x10(%rbp), %rdi callq 0x6270 cmpq $0x0, %rax jne 0x15915 movq -0x20(%rbp), %rdi leaq 0x138de(%rip), %rsi # 0x291d6 callq 0x6420 movq %rax, %rdi movq 0x206a9(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x15b24 movq -0x10(%rbp), %rax movq %rax, -0x68(%rbp) leaq -0x41(%rbp), %rdi movq %rdi, -0x60(%rbp) callq 0x67f0 movq -0x68(%rbp), %rsi movq -0x60(%rbp), %rdx leaq -0x40(%rbp), %rdi callq 0xbb90 jmp 0x1593d leaq -0x41(%rbp), %rdi callq 0x64c0 leaq 0x13830(%rip), %rsi # 0x2917d leaq -0x40(%rbp), %rdi callq 0x19fc0 movb %al, -0x69(%rbp) jmp 0x1595b movb -0x69(%rbp), %al testb $0x1, %al jne 0x15982 jmp 0x15964 leaq 0x1388f(%rip), %rsi # 0x291fa leaq -0x40(%rbp), %rdi callq 0x19fc0 movb %al, -0x6a(%rbp) jmp 0x15979 movb -0x6a(%rbp), %al testb $0x1, %al jne 0x15982 jmp 0x159d0 movq -0x18(%rbp), %rax movl $0x0, (%rax) movb $0x1, -0x1(%rbp) movl $0x1, -0x58(%rbp) jmp 0x15b1b movq %rax, %rcx movl %edx, %eax movq %rcx, -0x50(%rbp) movl %eax, -0x54(%rbp) leaq -0x41(%rbp), %rdi callq 0x64c0 jmp 0x15b32 movq %rax, %rcx movl %edx, %eax movq %rcx, -0x50(%rbp) movl %eax, -0x54(%rbp) leaq -0x40(%rbp), %rdi callq 0x62d0 jmp 0x15b32 leaq 0x137bc(%rip), %rsi # 0x29193 leaq -0x40(%rbp), %rdi callq 0x19fc0 movb %al, -0x6b(%rbp) jmp 0x159e5 movb -0x6b(%rbp), %al testb $0x1, %al jne 0x15a0c jmp 0x159ee leaq 0x13809(%rip), %rsi # 0x291fe leaq -0x40(%rbp), %rdi callq 0x19fc0 movb %al, -0x6c(%rbp) jmp 0x15a03 movb -0x6c(%rbp), %al testb $0x1, %al jne 0x15a0c jmp 0x15a26 movq -0x18(%rbp), %rax movl $0x1, (%rax) movb $0x1, -0x1(%rbp) movl $0x1, -0x58(%rbp) jmp 0x15b1b leaq 0x137d6(%rip), %rsi # 0x29203 leaq -0x40(%rbp), %rdi callq 0x19fc0 movb %al, -0x6d(%rbp) jmp 0x15a3b movb -0x6d(%rbp), %al testb $0x1, %al jne 0x15a9e jmp 0x15a44 leaq 0x137cd(%rip), %rsi # 0x29218 leaq -0x40(%rbp), %rdi callq 0x19fc0 movb %al, -0x6e(%rbp) jmp 0x15a59 movb -0x6e(%rbp), %al testb $0x1, %al jne 0x15a9e jmp 0x15a62 leaq 0x1374a(%rip), %rsi # 0x291b3 leaq -0x40(%rbp), %rdi callq 0x19fc0 movb %al, -0x6f(%rbp) jmp 0x15a77 movb -0x6f(%rbp), %al testb $0x1, %al jne 0x15a9e jmp 0x15a80 leaq 0x1382b(%rip), %rsi # 0x292b2 leaq -0x40(%rbp), %rdi callq 0x19fc0 movb %al, -0x70(%rbp) jmp 0x15a95 movb -0x70(%rbp), %al testb $0x1, %al jne 0x15a9e jmp 0x15ab5 movq -0x18(%rbp), %rax movl $0x2, (%rax) movb $0x1, -0x1(%rbp) movl $0x1, -0x58(%rbp) jmp 0x15b1b jmp 0x15ab7 jmp 0x15ab9 movq -0x20(%rbp), %rdi leaq 0x13758(%rip), %rsi # 0x2921c callq 0x6420 movq %rax, -0x78(%rbp) jmp 0x15acf movq -0x78(%rbp), %rdi leaq -0x40(%rbp), %rsi callq 0x63b0 movq %rax, -0x80(%rbp) jmp 0x15ae2 movq -0x80(%rbp), %rdi leaq 0x1374c(%rip), %rsi # 0x29239 callq 0x6420 movq %rax, -0x88(%rbp) jmp 0x15afb movq -0x88(%rbp), %rdi movq 0x204a7(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x15b10 movb $0x0, -0x1(%rbp) movl $0x1, -0x58(%rbp) leaq -0x40(%rbp), %rdi callq 0x62d0 movb -0x1(%rbp), %al andb $0x1, %al addq $0x90, %rsp popq %rbp retq movq -0x50(%rbp), %rdi callq 0x67e0 nopl (%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/BasePort.cpp
BasePort::ScanNodes()	bool BasePort::ScanNodes(void) { unsigned int board; nodeid_t node; // Clear any existing Node2Board memset(Node2Board, BoardIO::MAX_BOARDS, sizeof(Node2Board)); IsAllBoardsBroadcastCapable_ = true; IsAllBoardsRev4_5_ = true; IsAllBoardsRev4_6_ = true; IsAllBoardsRev6_ = true; IsAllBoardsRev7_ = true; IsAllBoardsRev8_9_ = true; NumOfNodes_ = 0; nodeid_t max_nodes = InitNodes(); outStr << "BasePort::ScanNodes: building node map for " << max_nodes << " nodes:" << std::endl; // Iterate through all possible nodes for (node = 0; node < max_nodes; node++) { quadlet_t data; unsigned long hver = 0; // check hardware version if (!ReadQuadletNode(node, BoardIO::HARDWARE_VERSION, data)) { if (GetPortType() == PORT_FIREWIRE) outStr << "BasePort::ScanNodes: unable to read from node " << node << std::endl; continue; } hver = data; if (!HardwareVersionValid(hver)) { outStr << "BasePort::ScanNodes: node " << node << " is not a supported board (data = " << std::hex << data << std::dec << ")" << std::endl; continue; } // read firmware version unsigned long fver = 0; if (!ReadQuadletNode(node, BoardIO::FIRMWARE_VERSION, data)) { outStr << "BasePort::ScanNodes: unable to read firmware version from node " << node << std::endl; continue; } fver = data; // read FPGA version (for Firmware Rev 5+) unsigned long fpga_ver = 1; if (fver >= 5) { if (!ReadQuadletNode(node, BoardIO::ETH_STATUS, data)) { outStr << "BasePort::ScanNodes: unable to read FPGA version (ETH_STATUS) from node " << node << std::endl; continue; } fpga_ver = BoardIO::GetFpgaVersionMajorFromStatus(data); } // read board id if (!ReadQuadletNode(node, BoardIO::BOARD_STATUS, data)) { outStr << "BasePort::ScanNodes: unable to read status from node " << node << std::endl; continue; } // board_id is bits 27-24, BOARD_ID_MASK = 0x0F000000 board = (data & BOARD_ID_MASK) >> 24; FpgaVersion[board] = fpga_ver; HardwareVersion[board] = hver; FirmwareVersion[board] = fver; // read git description (introduced after Rev 8 release) uint32_t git_desc = 0; if (!ReadQuadletNode(node, BoardIO::GIT_DESC, git_desc)) { outStr << "BasePort::ScanNodes: unable to read git desc from node " << node << std::endl; } outStr << " Node " << node << ", BoardId = " << board << ", " << GetFpgaVersionMajorString(board) << ", Hardware = " << GetHardwareVersionString(board) << ", Firmware Version = " << GetFirmwareVersion(board); if (git_desc != 0) { // git_dirty bit indicates that firmware was built with uncommitted changes; // shown by appending * to the git SHA. bool git_dirty = git_desc&0x00000008; // git_commits bit indicates whether there were any commits since the last tag bool git_commits = git_desc&0x00000004; // git_flag is set by the firmware, based on comparing the firmware version (F) to // the most recent git tag ("RevG", where G is the git tag version) // 0: F == G actual release ("F") or update to last release ("F+"), // depending on git_dirty and git_commits // 1: F == G+1 new firmware preview, shown as "F-" // 2: F > G+1 should not happen (missing git tag?), shown as "F?" // 3: F < G should not happen, shown as "F?" uint8_t git_flag = git_desc&0x00000003; bool showSHA = true; if (git_flag == 0) { if (git_dirty\|git_commits) outStr << "+"; else showSHA = false; } else if (git_flag == 1) outStr << "-"; else outStr << "?"; if (showSHA) { outStr << " (git-" << std::hex << std::setw(7) << std::setfill('0') << (git_desc>>4) << std::dec; if (git_dirty) outStr << "*"; outStr << ")"; } } outStr << std::endl; if (Node2Board[node] < BoardIO::MAX_BOARDS) { outStr << " Duplicate entry, previous value = " << static_cast<int>(Node2Board[node]) << std::endl; } Node2Board[node] = static_cast<unsigned char>(board); // check firmware version // Firmware Version >= 4, broadcast capable if (fver < 4) { IsAllBoardsBroadcastCapable_ = false; IsAllBoardsRev4_5_ = false; IsAllBoardsRev4_6_ = false; } if (fver > 5) IsAllBoardsRev4_5_ = false; if (fver > 6) IsAllBoardsRev4_6_ = false; // Firmware Version 6, broadcast with possibly shorter wait (i.e., skipping nodes // on the bus that are not part of the current configuration). if (fver != 6) IsAllBoardsRev6_ = false; // Firmware Version 7, added power control to block write; added velocity estimation // fields to block read if (fver != 7) IsAllBoardsRev7_ = false; // Firmware Version 8, added header quadlet to block write; support larger entries in // block read (both changes to support dRAC). if ((fver != 8) && (fver != 9)) IsAllBoardsRev8_9_ = false; NumOfNodes_++; } outStr << "BasePort::ScanNodes: found " << NumOfNodes_ << " boards" << std::endl; // update Board2Node for (board = 0; board < BoardIO::MAX_BOARDS; board++) { Board2Node[board] = MAX_NODES; // search up to max_nodes (not NumOfNodes_) in case nodes are not sequential (i.e., if some nodes // are not associated with valid boards). for (node = 0; node < max_nodes; node++) { if (Node2Board[node] == board) { if (Board2Node[board] < MAX_NODES) outStr << "BasePort::ScanNodes: warning: duplicate node id for board " << board << "(" << Board2Node[board] << ", " << node << ")" << std::endl; Board2Node[board] = node; } } } return (NumOfNodes_ > 0); }	pushq %rbp movq %rsp, %rbp subq $0xf0, %rsp movq %rdi, -0x8(%rbp) movq -0x8(%rbp), %rdi movq %rdi, -0xa0(%rbp) addq $0x480, %rdi # imm = 0x480 movl $0x10, %esi movl $0x40, %edx callq 0x62b0 movq -0xa0(%rbp), %rdi movb $0x1, 0x14(%rdi) movb $0x1, 0x15(%rdi) movb $0x1, 0x16(%rdi) movb $0x1, 0x17(%rdi) movb $0x1, 0x18(%rdi) movb $0x1, 0x19(%rdi) movl $0x0, 0x38(%rdi) movq (%rdi), %rax callq 0x10(%rax) movw %ax, %cx movq -0xa0(%rbp), %rax movw %cx, -0x10(%rbp) movq 0x8(%rax), %rdi leaq 0x1327f(%rip), %rsi # 0x29464 callq 0x6420 movq %rax, %rdi movzwl -0x10(%rbp), %esi callq 0x6770 movq %rax, %rdi leaq 0x13290(%rip), %rsi # 0x29490 callq 0x6420 movq %rax, %rdi movq 0x1fda1(%rip), %rsi # 0x35fb0 callq 0x6490 movw $0x0, -0xe(%rbp) movzwl -0xe(%rbp), %eax movzwl -0x10(%rbp), %ecx cmpl %ecx, %eax jge 0x16944 movq -0xa0(%rbp), %rdi movq $0x0, -0x20(%rbp) movw -0xe(%rbp), %si movq (%rdi), %rax movl $0x4, %edx leaq -0x14(%rbp), %rcx xorl %r8d, %r8d movzwl %si, %esi callq 0x20(%rax) testb $0x1, %al jne 0x1629f movq -0xa0(%rbp), %rdi movq (%rdi), %rax callq 0x78(%rax) cmpl $0x0, %eax jne 0x1629a movq -0xa0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0x1321e(%rip), %rsi # 0x29498 callq 0x6420 movq %rax, %rdi movzwl -0xe(%rbp), %esi callq 0x6770 movq %rax, %rdi movq 0x1fd1b(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x16933 movl -0x14(%rbp), %eax movq %rax, -0x20(%rbp) movq -0x20(%rbp), %rdi callq 0x16ae0 testb $0x1, %al jne 0x16331 movq -0xa0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0x13202(%rip), %rsi # 0x294c7 callq 0x6420 movq %rax, %rdi movzwl -0xe(%rbp), %esi callq 0x6770 movq %rax, %rdi leaq 0x13202(%rip), %rsi # 0x294e2 callq 0x6420 movq %rax, %rdi leaq -0x1c2f(%rip), %rsi # 0x146c0 callq 0x61f0 movq %rax, %rdi movl -0x14(%rbp), %esi callq 0x65d0 movq %rax, %rdi leaq -0xa6c9(%rip), %rsi # 0xbc40 callq 0x61f0 movq %rax, %rdi leaq 0x121db(%rip), %rsi # 0x284f3 callq 0x6420 movq %rax, %rdi movq 0x1fc89(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x16933 movq -0xa0(%rbp), %rdi movq $0x0, -0x28(%rbp) movw -0xe(%rbp), %si movq (%rdi), %rax movl $0x7, %edx leaq -0x14(%rbp), %rcx xorl %r8d, %r8d movzwl %si, %esi callq 0x20(%rax) testb $0x1, %al jne 0x16394 movq -0xa0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0x13196(%rip), %rsi # 0x29505 callq 0x6420 movq %rax, %rdi movzwl -0xe(%rbp), %esi callq 0x6770 movq %rax, %rdi movq 0x1fc26(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x16933 movl -0x14(%rbp), %eax movq %rax, -0x28(%rbp) movq $0x1, -0x30(%rbp) cmpq $0x5, -0x28(%rbp) jb 0x16413 movq -0xa0(%rbp), %rdi movw -0xe(%rbp), %si movq (%rdi), %rax movl $0xc, %edx leaq -0x14(%rbp), %rcx xorl %r8d, %r8d movzwl %si, %esi callq 0x20(%rax) testb $0x1, %al jne 0x16405 movq -0xa0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0x13165(%rip), %rsi # 0x29545 callq 0x6420 movq %rax, %rdi movzwl -0xe(%rbp), %esi callq 0x6770 movq %rax, %rdi movq 0x1fbb5(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x16933 movl -0x14(%rbp), %edi callq 0xde00 movl %eax, %eax movq %rax, -0x30(%rbp) movq -0xa0(%rbp), %rdi movw -0xe(%rbp), %si movq (%rdi), %rax xorl %ecx, %ecx movl %ecx, %edx leaq -0x14(%rbp), %rcx xorl %r8d, %r8d movzwl %si, %esi callq 0x20(%rax) testb $0x1, %al jne 0x1646d movq -0xa0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0x13146(%rip), %rsi # 0x2958e callq 0x6420 movq %rax, %rdi movzwl -0xe(%rbp), %esi callq 0x6770 movq %rax, %rdi movq 0x1fb4d(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x16933 movq -0xa0(%rbp), %rdi movl -0x14(%rbp), %eax andq $0xf000000, %rax # imm = 0xF000000 shrq $0x18, %rax movl %eax, -0xc(%rbp) movq -0x30(%rbp), %rax movl %eax, %ecx movl -0xc(%rbp), %eax movl %ecx, 0x3c0(%rdi,%rax,4) movq -0x20(%rbp), %rcx movl -0xc(%rbp), %eax movq %rcx, 0x400(%rdi,%rax,8) movq -0x28(%rbp), %rcx movl -0xc(%rbp), %eax movq %rcx, 0x340(%rdi,%rax,8) movl $0x0, -0x34(%rbp) movw -0xe(%rbp), %si movq (%rdi), %rax movl $0xf, %edx leaq -0x34(%rbp), %rcx xorl %r8d, %r8d movzwl %si, %esi callq *0x20(%rax) testb $0x1, %al jne 0x16508 movq -0xa0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0x130dc(%rip), %rsi # 0x295c4 callq 0x6420 movq %rax, %rdi movzwl -0xe(%rbp), %esi callq 0x6770 movq %rax, %rdi movq 0x1faad(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0xa0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0x130e2(%rip), %rsi # 0x295fc callq 0x6420 movq %rax, %rdi movzwl -0xe(%rbp), %esi callq 0x6770 movq %rax, %rdi leaq 0x130cf(%rip), %rsi # 0x29604 callq 0x6420 movq %rax, %rdi movl -0xc(%rbp), %esi callq 0x65d0 movq %rax, %rdi leaq 0x12e12(%rip), %rsi # 0x29361 callq 0x6420 movq -0xa0(%rbp), %rsi movq %rax, -0xb8(%rbp) movzbl -0xc(%rbp), %edx leaq -0x58(%rbp), %rdi movq %rdi, -0xb0(%rbp) callq 0x16b60 movq -0xb8(%rbp), %rdi movq -0xb0(%rbp), %rsi callq 0x63b0 movq %rax, -0xa8(%rbp) jmp 0x16592 movq -0xa8(%rbp), %rdi leaq 0x13071(%rip), %rsi # 0x29611 callq 0x6420 movq %rax, -0xc0(%rbp) jmp 0x165ae movq -0xa0(%rbp), %rsi movzbl -0xc(%rbp), %edx leaq -0x88(%rbp), %rdi callq 0x16c50 jmp 0x165c7 movq -0xc0(%rbp), %rdi leaq -0x88(%rbp), %rsi callq 0x63b0 movq %rax, -0xc8(%rbp) jmp 0x165e3 movq -0xc8(%rbp), %rdi leaq 0x1302e(%rip), %rsi # 0x2961f callq 0x6420 movq %rax, -0xd0(%rbp) jmp 0x165ff movq -0xa0(%rbp), %rdi movzbl -0xc(%rbp), %esi callq 0xe0f0 movq %rax, -0xd8(%rbp) jmp 0x16618 movq -0xd8(%rbp), %rsi movq -0xd0(%rbp), %rdi callq 0x6110 jmp 0x1662d leaq -0x88(%rbp), %rdi callq 0x62d0 leaq -0x58(%rbp), %rdi callq 0x62d0 cmpl $0x0, -0x34(%rbp) je 0x16821 movl -0x34(%rbp), %eax andl $0x8, %eax cmpl $0x0, %eax setne %al andb $0x1, %al movb %al, -0x89(%rbp) movl -0x34(%rbp), %eax andl $0x4, %eax cmpl $0x0, %eax setne %al andb $0x1, %al movb %al, -0x8a(%rbp) movl -0x34(%rbp), %eax andl $0x3, %eax movb %al, -0x8b(%rbp) movb $0x1, -0x8c(%rbp) movzbl -0x8b(%rbp), %eax cmpl $0x0, %eax jne 0x16707 movb -0x89(%rbp), %al andb $0x1, %al movzbl %al, %eax movb -0x8a(%rbp), %cl andb $0x1, %cl movzbl %cl, %ecx orl %ecx, %eax cmpl $0x0, %eax je 0x166fe movq -0xa0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0x12f72(%rip), %rsi # 0x29635 callq 0x6420 jmp 0x16705 movq %rax, %rcx movl %edx, %eax movq %rcx, -0x60(%rbp) movl %eax, -0x64(%rbp) jmp 0x166f0 movq %rax, %rcx movl %edx, %eax movq %rcx, -0x60(%rbp) movl %eax, -0x64(%rbp) leaq -0x88(%rbp), %rdi callq 0x62d0 leaq -0x58(%rbp), %rdi callq 0x62d0 jmp 0x16ad3 movb $0x0, -0x8c(%rbp) jmp 0x16745 movzbl -0x8b(%rbp), %eax cmpl $0x1, %eax jne 0x1672c movq -0xa0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0x12f17(%rip), %rsi # 0x2963c callq 0x6420 jmp 0x16743 movq -0xa0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0x1213d(%rip), %rsi # 0x2887b callq 0x6420 jmp 0x16745 testb $0x1, -0x8c(%rbp) je 0x1681f movq -0xa0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0x12ed3(%rip), %rsi # 0x29637 callq 0x6420 movq %rax, %rdi leaq -0x20b3(%rip), %rsi # 0x146c0 callq 0x61f0 movq %rax, -0xe8(%rbp) movl $0x7, %edi callq 0x19fa0 movq -0xe8(%rbp), %rdi movl %eax, -0x90(%rbp) movl -0x90(%rbp), %esi callq 0x6540 movq %rax, -0xe0(%rbp) movl $0x30, %edi callq 0x1a070 movq -0xe0(%rbp), %rdi movb %al, -0x91(%rbp) movzbl -0x91(%rbp), %esi callq 0x66f0 movq %rax, %rdi movl -0x34(%rbp), %esi shrl $0x4, %esi callq 0x65d0 movq %rax, %rdi leaq -0xaba3(%rip), %rsi # 0xbc40 callq 0x61f0 testb $0x1, -0x89(%rbp) je 0x16808 movq -0xa0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0x12e3b(%rip), %rsi # 0x2963e callq 0x6420 movq -0xa0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0x11cd9(%rip), %rsi # 0x284f3 callq 0x6420 jmp 0x16821 movq -0xa0(%rbp), %rax movq 0x8(%rax), %rdi movq 0x1f77d(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0xa0(%rbp), %rax movzwl -0xe(%rbp), %ecx movzbl 0x480(%rax,%rcx), %eax cmpl $0x10, %eax jge 0x16891 movq -0xa0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0x12dde(%rip), %rsi # 0x29640 callq 0x6420 movq %rax, %rdi movq -0xa0(%rbp), %rax movzwl -0xe(%rbp), %ecx movzbl 0x480(%rax,%rcx), %esi callq 0x67d0 movq %rax, %rdi movq 0x1f724(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0xa0(%rbp), %rax movl -0xc(%rbp), %ecx movb %cl, %dl movzwl -0xe(%rbp), %ecx movb %dl, 0x480(%rax,%rcx) cmpq $0x4, -0x28(%rbp) jae 0x168c2 movq -0xa0(%rbp), %rax movb $0x0, 0x14(%rax) movb $0x0, 0x15(%rax) movb $0x0, 0x16(%rax) cmpq $0x5, -0x28(%rbp) jbe 0x168d4 movq -0xa0(%rbp), %rax movb $0x0, 0x15(%rax) cmpq $0x6, -0x28(%rbp) jbe 0x168e6 movq -0xa0(%rbp), %rax movb $0x0, 0x16(%rax) cmpq $0x6, -0x28(%rbp) je 0x168f8 movq -0xa0(%rbp), %rax movb $0x0, 0x17(%rax) cmpq $0x7, -0x28(%rbp) je 0x1690a movq -0xa0(%rbp), %rax movb $0x0, 0x18(%rax) cmpq $0x8, -0x28(%rbp) je 0x16923 cmpq $0x9, -0x28(%rbp) je 0x16923 movq -0xa0(%rbp), %rax movb $0x0, 0x19(%rax) movq -0xa0(%rbp), %rax movl 0x38(%rax), %ecx addl $0x1, %ecx movl %ecx, 0x38(%rax) movw -0xe(%rbp), %ax addw $0x1, %ax movw %ax, -0xe(%rbp) jmp 0x1621a movq -0xa0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0x12d11(%rip), %rsi # 0x29667 callq 0x6420 movq %rax, %rdi movq -0xa0(%rbp), %rax movl 0x38(%rax), %esi callq 0x65d0 movq %rax, %rdi leaq 0x11c7f(%rip), %rsi # 0x285f6 callq 0x6420 movq %rax, %rdi movq 0x1f62a(%rip), %rsi # 0x35fb0 callq 0x6490 movl $0x0, -0xc(%rbp) cmpl $0x10, -0xc(%rbp) jae 0x16aba movq -0xa0(%rbp), %rax movl -0xc(%rbp), %ecx movw $0x40, 0x4c0(%rax,%rcx,2) movw $0x0, -0xe(%rbp) movzwl -0xe(%rbp), %eax movzwl -0x10(%rbp), %ecx cmpl %ecx, %eax jge 0x16aaa movq -0xa0(%rbp), %rax movzwl -0xe(%rbp), %ecx movzbl 0x480(%rax,%rcx), %eax cmpl -0xc(%rbp), %eax jne 0x16a97 movq -0xa0(%rbp), %rax movl -0xc(%rbp), %ecx movzwl 0x4c0(%rax,%rcx,2), %eax cmpl $0x40, %eax jge 0x16a81 movq -0xa0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0x12c74(%rip), %rsi # 0x29683 callq 0x6420 movq %rax, %rdi movl -0xc(%rbp), %esi callq 0x65d0 movq %rax, %rdi leaq 0x130dc(%rip), %rsi # 0x29b05 callq 0x6420 movq %rax, %rdi movq -0xa0(%rbp), %rax movl -0xc(%rbp), %ecx movzwl 0x4c0(%rax,%rcx,2), %esi callq 0x6770 movq %rax, %rdi leaq 0x1290f(%rip), %rsi # 0x29361 callq 0x6420 movq %rax, %rdi movzwl -0xe(%rbp), %esi callq 0x6770 movq %rax, %rdi leaq 0x11a86(%rip), %rsi # 0x284f3 callq 0x6420 movq %rax, %rdi movq 0x1f534(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0xa0(%rbp), %rax movw -0xe(%rbp), %dx movl -0xc(%rbp), %ecx movw %dx, 0x4c0(%rax,%rcx,2) jmp 0x16a99 movw -0xe(%rbp), %ax addw $0x1, %ax movw %ax, -0xe(%rbp) jmp 0x169b6 jmp 0x16aac movl -0xc(%rbp), %eax addl $0x1, %eax movl %eax, -0xc(%rbp) jmp 0x16992 movq -0xa0(%rbp), %rax cmpl $0x0, 0x38(%rax) seta %al andb $0x1, %al addq $0xf0, %rsp popq %rbp retq movq -0x60(%rbp), %rdi callq 0x67e0 nopl (%rax)	/jhu-cisst[P]mechatronics-software/lib/code/BasePort.cpp
BasePort::GetHardwareVersionString[abi:cxx11](unsigned char) const	std::string BasePort::GetHardwareVersionString(unsigned char boardId) const { std::string hStr; if ((boardId < BoardIO::MAX_BOARDS) && HardwareVersion[boardId]) { unsigned long hver = bswap_32(HardwareVersion[boardId]); hStr.assign(reinterpret_cast<const char *>(&hver), sizeof(unsigned long)); hStr.resize(4); } else { hStr = "Invalid"; } return hStr; }	pushq %rbp movq %rsp, %rbp subq $0x50, %rsp movq %rdi, -0x48(%rbp) movb %dl, %al movq %rdi, %rcx movq %rcx, -0x40(%rbp) movq %rdi, -0x8(%rbp) movq %rsi, -0x10(%rbp) movb %al, -0x11(%rbp) movq -0x10(%rbp), %rax movq %rax, -0x38(%rbp) movb $0x0, -0x12(%rbp) callq 0x6630 movzbl -0x11(%rbp), %eax cmpl $0x10, %eax jge 0x16cfc movq -0x38(%rbp), %rax movzbl -0x11(%rbp), %ecx cmpq $0x0, 0x400(%rax,%rcx,8) je 0x16cfc movq -0x38(%rbp), %rax movzbl -0x11(%rbp), %ecx movl 0x400(%rax,%rcx,8), %edi callq 0x178f0 movl %eax, -0x4c(%rbp) jmp 0x16cb6 movq -0x48(%rbp), %rdi movl -0x4c(%rbp), %eax movl %eax, %eax movq %rax, -0x20(%rbp) leaq -0x20(%rbp), %rsi movl $0x8, %edx callq 0x65e0 jmp 0x16cd3 movq -0x48(%rbp), %rdi movl $0x4, %esi callq 0x6620 jmp 0x16ce3 jmp 0x16d10 movq -0x48(%rbp), %rdi movq %rax, %rcx movl %edx, %eax movq %rcx, -0x28(%rbp) movl %eax, -0x2c(%rbp) callq 0x62d0 jmp 0x16d2d movq -0x48(%rbp), %rdi leaq 0x12d79(%rip), %rsi # 0x29a80 callq 0x6600 jmp 0x16d0e jmp 0x16d10 movb $0x1, -0x12(%rbp) testb $0x1, -0x12(%rbp) jne 0x16d23 movq -0x48(%rbp), %rdi callq 0x62d0 movq -0x40(%rbp), %rax addq $0x50, %rsp popq %rbp retq movq -0x28(%rbp), %rdi callq 0x67e0 nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/BasePort.cpp
BasePort::AddBoard(BoardIO*)	bool BasePort::AddBoard(BoardIO *board) { unsigned int id = board->BoardId; if (id >= BoardIO::MAX_BOARDS) { outStr << "BasePort::AddBoard: board number out of range: " << id << std::endl; return false; } BoardList[id] = board; board->port = this; board->InitBoard(); // Make sure read/write buffers are allocated SetReadBufferBroadcast(); SetWriteBufferBroadcast(); if (id >= max_board) max_board = id+1; // update BoardInUseMask_ BoardInUseMask_ = (BoardInUseMask_ \| (1 << id)); bcReadInfo.boardInfo[id].inUse = true; NumOfBoards_++; // increment board counts bcReadInfo.readSizeQuads = GetBroadcastReadSizeQuads(); return true; }	pushq %rbp movq %rsp, %rbp subq $0x30, %rsp movq %rdi, -0x10(%rbp) movq %rsi, -0x18(%rbp) movq -0x10(%rbp), %rax movq %rax, -0x28(%rbp) movq -0x18(%rbp), %rax movzbl 0x8(%rax), %eax movl %eax, -0x1c(%rbp) cmpl $0x10, -0x1c(%rbp) jb 0x16eb0 movq -0x28(%rbp), %rax movq 0x8(%rax), %rdi leaq 0x1299a(%rip), %rsi # 0x29822 callq 0x6420 movq %rax, %rdi movl -0x1c(%rbp), %esi callq 0x65d0 movq %rax, %rdi movq 0x1f10e(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x16f5e movq -0x28(%rbp), %rcx movq -0x18(%rbp), %rdx movl -0x1c(%rbp), %eax movq %rdx, 0x40(%rcx,%rax,8) movq -0x18(%rbp), %rax movq %rcx, 0x10(%rax) movq -0x18(%rbp), %rdi movq (%rdi), %rax callq *(%rax) movq -0x28(%rbp), %rdi callq 0x15e80 movq -0x28(%rbp), %rdi callq 0x15f50 movq -0x28(%rbp), %rcx movl -0x1c(%rbp), %eax cmpl 0xc8(%rcx), %eax jb 0x16f02 movq -0x28(%rbp), %rax movl -0x1c(%rbp), %ecx addl $0x1, %ecx movl %ecx, 0xc8(%rax) movq -0x28(%rbp), %rdi movl 0xc4(%rdi), %eax movl -0x1c(%rbp), %ecx movl $0x1, %edx shll %cl, %edx movl %edx, %ecx orl %ecx, %eax movl %eax, 0xc4(%rdi) movq %rdi, %rax addq $0xf0, %rax addq $0x50, %rax movl -0x1c(%rbp), %ecx shlq $0x5, %rcx addq %rcx, %rax movb $0x1, (%rax) movl 0xc0(%rdi), %eax addl $0x1, %eax movl %eax, 0xc0(%rdi) callq 0x16020 movl %eax, %ecx movq -0x28(%rbp), %rax movl %ecx, 0xf0(%rax) movb $0x1, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x30, %rsp popq %rbp retq nopl (%rax)	/jhu-cisst[P]mechatronics-software/lib/code/BasePort.cpp
BasePort::AddHardwareVersionStringList(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)	void BasePort::AddHardwareVersionStringList(const std::string &hStr) { if (hStr.empty()) return; std::string::size_type n = 0; while (n != std::string::npos) { std::string::size_type p = hStr.find(',', n); if (p == std::string::npos) { AddHardwareVersionString(hStr.substr(n, p)); n = std::string::npos; } else { AddHardwareVersionString(hStr.substr(n, (p-n))); n = p+1; } } }	pushq %rbp movq %rsp, %rbp subq $0x80, %rsp movq %rdi, -0x8(%rbp) movq -0x8(%rbp), %rdi callq 0x6760 testb $0x1, %al jne 0x17a9e jmp 0x17aa3 jmp 0x17b7b movq $0x0, -0x10(%rbp) cmpq $-0x1, -0x10(%rbp) je 0x17b7b movq -0x8(%rbp), %rdi movq -0x10(%rbp), %rdx movl $0x2c, %esi callq 0x65a0 movq %rax, -0x18(%rbp) cmpq $-0x1, -0x18(%rbp) jne 0x17b21 movq -0x8(%rbp), %rsi movq -0x10(%rbp), %rdx movq -0x18(%rbp), %rcx leaq -0x38(%rbp), %rdi movq %rdi, -0x70(%rbp) callq 0x6470 movq -0x70(%rbp), %rdi callq 0x17930 jmp 0x17af7 leaq -0x38(%rbp), %rdi callq 0x62d0 movq $-0x1, -0x10(%rbp) jmp 0x17b76 movq %rax, %rcx movl %edx, %eax movq %rcx, -0x40(%rbp) movl %eax, -0x44(%rbp) leaq -0x38(%rbp), %rdi callq 0x62d0 jmp 0x17b84 movq -0x8(%rbp), %rsi movq -0x10(%rbp), %rdx movq -0x18(%rbp), %rcx subq %rdx, %rcx leaq -0x68(%rbp), %rdi movq %rdi, -0x78(%rbp) callq 0x6470 movq -0x78(%rbp), %rdi callq 0x17930 jmp 0x17b48 leaq -0x68(%rbp), %rdi callq 0x62d0 movq -0x18(%rbp), %rax addq $0x1, %rax movq %rax, -0x10(%rbp) jmp 0x17b76 movq %rax, %rcx movl %edx, %eax movq %rcx, -0x40(%rbp) movl %eax, -0x44(%rbp) leaq -0x68(%rbp), %rdi callq 0x62d0 jmp 0x17b84 jmp 0x17aab addq $0x80, %rsp popq %rbp retq movq -0x40(%rbp), %rdi callq 0x67e0 nopl (%rax)	/jhu-cisst[P]mechatronics-software/lib/code/BasePort.cpp
BasePort::ReScanNodes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)	bool BasePort::ReScanNodes(const std::string &caller) { unsigned int oldFwBusGeneration = FwBusGeneration; UpdateBusGeneration(newFwBusGeneration); bool ret = ScanNodes(); if (!ret) { outStr << caller << ": failed to rescan nodes" << std::endl; UpdateBusGeneration(oldFwBusGeneration); } return ret; }	pushq %rbp movq %rsp, %rbp subq $0x20, %rsp movq %rdi, -0x8(%rbp) movq %rsi, -0x10(%rbp) movq -0x8(%rbp), %rdi movq %rdi, -0x20(%rbp) movl 0x2c(%rdi), %eax movl %eax, -0x14(%rbp) movl 0x30(%rdi), %esi movq (%rdi), %rax callq 0x98(%rax) movq -0x20(%rbp), %rdi movq (%rdi), %rax callq 0x18(%rax) andb $0x1, %al movb %al, -0x15(%rbp) testb $0x1, -0x15(%rbp) jne 0x17cce movq -0x20(%rbp), %rax movq 0x8(%rax), %rdi movq -0x10(%rbp), %rsi callq 0x63b0 movq %rax, %rdi leaq 0x11e20(%rip), %rsi # 0x29aca callq 0x6420 movq %rax, %rdi movq 0x1e2f7(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x20(%rbp), %rdi movl -0x14(%rbp), %esi movq (%rdi), %rax callq *0x98(%rax) movb -0x15(%rbp), %al andb $0x1, %al addq $0x20, %rsp popq %rbp retq nopl (%rax)	/jhu-cisst[P]mechatronics-software/lib/code/BasePort.cpp
EthBasePort::EthBasePort(int, bool, std::ostream&, bool (*)(EthBasePort&, unsigned char, std::ostream&))	EthBasePort::EthBasePort(int portNum, bool forceFwBridge, std::ostream &debugStream, EthCallbackType cb): BasePort(portNum, debugStream), useFwBridge(forceFwBridge), fw_tl(0), eth_read_callback(cb), ReceiveTimeout(0.02) { }	pushq %rbp movq %rsp, %rbp subq $0x40, %rsp movb %dl, %al movq %rdi, -0x8(%rbp) movl %esi, -0xc(%rbp) andb $0x1, %al movb %al, -0xd(%rbp) movq %rcx, -0x18(%rbp) movq %r8, -0x20(%rbp) movq -0x8(%rbp), %rdi movq %rdi, -0x38(%rbp) movl -0xc(%rbp), %esi movq -0x18(%rbp), %rdx callq 0x154a0 movq -0x38(%rbp), %rdi leaq 0x1a5e3(%rip), %rax # 0x35740 addq $0x10, %rax movq %rax, (%rdi) movb -0xd(%rbp), %al andb $0x1, %al movb %al, 0x4e0(%rdi) movb $0x0, 0x4e1(%rdi) movq -0x20(%rbp), %rax movq %rax, 0x4e8(%rdi) movabsq $0x3f947ae147ae147b, %rax # imm = 0x3F947AE147AE147B movq %rax, 0x4f0(%rdi) addq $0x4f8, %rdi # imm = 0x4F8 callq 0xc370 jmp 0x1b1a0 addq $0x40, %rsp popq %rbp retq movq -0x38(%rbp), %rdi movq %rax, %rcx movl %edx, %eax movq %rcx, -0x28(%rbp) movl %eax, -0x2c(%rbp) callq 0x156b0 movq -0x28(%rbp), %rdi callq 0x67e0 nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/EthBasePort.cpp
EthBasePort::CheckFirewirePacket(unsigned char const*, unsigned long, unsigned short, unsigned int, unsigned int)	bool EthBasePort::CheckFirewirePacket(const unsigned char packet, size_t length, nodeid_t node, unsigned int tcode, unsigned int tl) { if (!checkCRC(packet)) { outStr << "CheckFirewirePacket: CRC error" << std::endl; return false; } nodeid_t src_node; unsigned int tcode_recv; unsigned int tl_recv; GetFirewireHeaderInfo(packet, &src_node, &tcode_recv, &tl_recv); if (tcode_recv != tcode) { outStr << "Unexpected tcode: received = " << tcode_recv << ", expected = " << tcode << std::endl; return false; } if ((node != FW_NODE_BROADCAST) && (src_node != node)) { outStr << "Inconsistent source node: received = " << src_node << ", expected = " << node << std::endl; return false; } if (tl_recv != tl) { outStr << "Inconsistent Firewire TL: received = " << tl_recv << ", expected = " << tl << std::endl; return false; } // TODO: could also check QRESPONSE length if (tcode == BRESPONSE) { const quadlet_t qpacket = reinterpret_cast<const quadlet_t *>(packet); size_t length_recv = (qpacket[3]&0xffff0000) >> 16; if (length_recv != length) { outStr << "Inconsistent length: received = " << length_recv << ", expected = " << length << std::endl; return false; } } return true; }	pushq %rbp movq %rsp, %rbp subq $0x50, %rsp movw %cx, %ax movq %rdi, -0x10(%rbp) movq %rsi, -0x18(%rbp) movq %rdx, -0x20(%rbp) movw %ax, -0x22(%rbp) movl %r8d, -0x28(%rbp) movl %r9d, -0x2c(%rbp) movq -0x10(%rbp), %rax movq %rax, -0x50(%rbp) movq -0x18(%rbp), %rdi callq 0x1bb00 testb $0x1, %al jne 0x1b934 movq -0x50(%rbp), %rax movq 0x8(%rax), %rdi leaq 0xe6d9(%rip), %rsi # 0x29ff0 callq 0x6420 movq %rax, %rdi movq 0x1a68a(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x1bae6 movq -0x18(%rbp), %rdi leaq -0x2e(%rbp), %rsi leaq -0x34(%rbp), %rdx leaq -0x38(%rbp), %rcx callq 0x1b850 movl -0x34(%rbp), %eax cmpl -0x28(%rbp), %eax je 0x1b9a2 movq -0x50(%rbp), %rax movq 0x8(%rax), %rdi leaq 0xe6af(%rip), %rsi # 0x2a00f callq 0x6420 movq %rax, %rdi movl -0x34(%rbp), %esi callq 0x65d0 movq %rax, %rdi leaq 0xe4d9(%rip), %rsi # 0x29e53 callq 0x6420 movq %rax, %rdi movl -0x28(%rbp), %esi callq 0x65d0 movq %rax, %rdi movq 0x1a61c(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x1bae6 movzwl -0x22(%rbp), %eax cmpl $0x3f, %eax je 0x1ba0a movzwl -0x2e(%rbp), %eax movzwl -0x22(%rbp), %ecx cmpl %ecx, %eax je 0x1ba0a movq -0x50(%rbp), %rax movq 0x8(%rax), %rdi leaq 0xe667(%rip), %rsi # 0x2a02d callq 0x6420 movq %rax, %rdi movzwl -0x2e(%rbp), %esi callq 0x6770 movq %rax, %rdi leaq 0xe472(%rip), %rsi # 0x29e53 callq 0x6420 movq %rax, %rdi movzwl -0x22(%rbp), %esi callq 0x6770 movq %rax, %rdi movq 0x1a5b4(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x1bae6 movl -0x38(%rbp), %eax cmpl -0x2c(%rbp), %eax je 0x1ba63 movq -0x50(%rbp), %rax movq 0x8(%rax), %rdi leaq 0xe632(%rip), %rsi # 0x2a053 callq 0x6420 movq %rax, %rdi movl -0x38(%rbp), %esi callq 0x65d0 movq %rax, %rdi leaq 0xe418(%rip), %rsi # 0x29e53 callq 0x6420 movq %rax, %rdi movl -0x2c(%rbp), %esi callq 0x65d0 movq %rax, %rdi movq 0x1a55b(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x1bae6 cmpl $0x7, -0x28(%rbp) jne 0x1bae2 movq -0x18(%rbp), %rax movq %rax, -0x40(%rbp) movq -0x40(%rbp), %rax movl 0xc(%rax), %eax andl $0xffff0000, %eax # imm = 0xFFFF0000 shrl $0x10, %eax movl %eax, %eax movq %rax, -0x48(%rbp) movq -0x48(%rbp), %rax cmpq -0x20(%rbp), %rax je 0x1bae0 movq -0x50(%rbp), %rax movq 0x8(%rax), %rdi leaq 0xe5da(%rip), %rsi # 0x2a079 callq 0x6420 movq %rax, %rdi movq -0x48(%rbp), %rsi callq 0x6110 movq %rax, %rdi leaq 0xe399(%rip), %rsi # 0x29e53 callq 0x6420 movq %rax, %rdi movq -0x20(%rbp), %rsi callq 0x6110 movq %rax, %rdi movq 0x1a4db(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x1bae6 jmp 0x1bae2 movb $0x1, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x50, %rsp popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/EthBasePort.cpp
EthBasePort::checkCRC(unsigned char const*)	bool EthBasePort::checkCRC(const unsigned char packet) { // Eliminate CRC checking of FireWire packets received via Ethernet // because Ethernet already includes CRC. #if 0 // Note that FW_QREPONSE_SIZE == FW_BRESPONSE_HEADER_SIZE uint32_t crc_check = BitReverse32(crc32(0U, packet, FW_QRESPONSE_SIZE-FW_CRC_SIZE)); uint32_t crc_original = bswap_32(reinterpret_cast<const uint32_t *>(packet+FW_QRESPONSE_SIZE-FW_CRC_SIZE)); return (crc_check == crc_original); #else return true; #endif }	pushq %rbp movq %rsp, %rbp movq %rdi, -0x8(%rbp) movb $0x1, %al andb $0x1, %al popq %rbp retq nop	/jhu-cisst[P]mechatronics-software/lib/code/EthBasePort.cpp
EthBasePort::PrintStatus(std::ostream&, unsigned int)	void EthBasePort::PrintStatus(std::ostream &debugStream, uint32_t status) { unsigned int ver = BoardIO::GetFpgaVersionMajorFromStatus(status); debugStream << "Status: "; if (ver == 0) { debugStream << "Unknown FPGA, status = " << std::hex << status << std::dec << std::endl; } else if (ver == 1) { // FPGA V1 debugStream << "No Ethernet present" << std::endl; } else { // FPGA V2 or V3 if (ver == 2) { if (status&FpgaIO::ETH_STAT_REQ_ERR_V2) debugStream << "error "; if (status&FpgaIO::ETH_STAT_INIT_OK_V2) debugStream << "initOK "; } if (status & FpgaIO::ETH_STAT_FRAME_ERR) debugStream << "FrameErr "; if (status & FpgaIO::ETH_STAT_IPV4_ERR) debugStream << "IPv4Err "; if (status & FpgaIO::ETH_STAT_UDP_ERR) debugStream << "UDPErr "; if (status & FpgaIO::ETH_STAT_DEST_ERR) debugStream << "DestErr "; if (status & FpgaIO::ETH_STAT_ACCESS_ERR) debugStream << "AccessErr "; if ((ver == 2) && (status & FpgaIO::ETH_STAT_STATE_ERR_V2)) debugStream << "StateErr "; if ((ver == 3) && (status & FpgaIO::ETH_STAT_CLK125_OK_V3)) debugStream << "Clk125 "; if (status & FpgaIO::ETH_STAT_ETHST_ERR ) debugStream << "EthStateErr "; if ((ver == 3) && (status & FpgaIO::ETH_STAT_CLK200_OK_V3)) debugStream << "Clk200 "; if (status & FpgaIO::ETH_STAT_UDP) debugStream << "UDP "; if (ver == 2) { if (status & FpgaIO::ETH_STAT_LINK_STAT_V2) debugStream << "Link-On "; else debugStream << "Link-Off "; if (status & FpgaIO::ETH_STAT_IDLE_V2) debugStream << "ETH-idle "; int waitInfo = (status & FpgaIO::ETH_STAT_WAIT_MASK_V2)>>16; if (waitInfo == 0) debugStream << "wait-none"; else if (waitInfo == 1) debugStream << "wait-recv"; else if (waitInfo == 2) debugStream << "wait-send"; else debugStream << "wait-flush"; debugStream << std::endl; } else { // ver == 3 // Following bit introduced in Firmware Rev 9, but was previously 0 if (status & FpgaIO::ETH_STAT_PSETH_EN_V3) debugStream << "PS-Eth "; debugStream << std::endl; for (unsigned int port = 1; port <= 2; port++) { debugStream << "Port " << port << ": "; uint8_t portStatus = FpgaIO::GetEthernetPortStatusV3(status, port); if (portStatus & FpgaIO::ETH_PORT_STAT_INIT_OK) debugStream << "initOK "; if (portStatus & FpgaIO::ETH_PORT_STAT_HAS_IRQ) debugStream << "hasIRQ "; if (portStatus & FpgaIO::ETH_PORT_STAT_LINK_STAT) debugStream << "Link-On "; else debugStream << "Link-Off "; uint8_t linkSpeed = (portStatus & FpgaIO::ETH_PORT_STAT_SPEED_MASK)>>3; if (linkSpeed == 0) debugStream << "10 Mbps "; else if (linkSpeed == 1) debugStream << "100 Mbps "; else if (linkSpeed == 2) debugStream << "1000 Mbps "; // Following are only for Firmware Rev 8 if (portStatus & FpgaIO::ETH_PORT_STAT_RECV_ERR) debugStream << "RecvErr "; if (portStatus & FpgaIO::ETH_PORT_STAT_SEND_OVF) debugStream << "SendOvf "; if (portStatus & FpgaIO::ETH_PORT_STAT_PS_ETH) debugStream << "PS-Eth "; debugStream << std::endl; } } } }	pushq %rbp movq %rsp, %rbp subq $0x20, %rsp movq %rdi, -0x8(%rbp) movl %esi, -0xc(%rbp) movl -0xc(%rbp), %edi callq 0xde00 movl %eax, -0x10(%rbp) movq -0x8(%rbp), %rdi leaq 0xdf26(%rip), %rsi # 0x2a21b callq 0x6420 cmpl $0x0, -0x10(%rbp) jne 0x1c34d movq -0x8(%rbp), %rdi leaq 0xdf19(%rip), %rsi # 0x2a224 callq 0x6420 movq %rax, %rdi leaq -0x7c5a(%rip), %rsi # 0x146c0 callq 0x61f0 movq %rax, %rdi movl -0xc(%rbp), %esi callq 0x65d0 movq %rax, %rdi leaq -0x106f4(%rip), %rsi # 0xbc40 callq 0x61f0 movq %rax, %rdi movq 0x19c6d(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x1c778 cmpl $0x1, -0x10(%rbp) jne 0x1c377 movq -0x8(%rbp), %rdi leaq 0xdede(%rip), %rsi # 0x2a23c callq 0x6420 movq %rax, %rdi movq 0x19c43(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x1c776 cmpl $0x2, -0x10(%rbp) jne 0x1c3b9 movl -0xc(%rbp), %eax andl $0x40000000, %eax # imm = 0x40000000 cmpl $0x0, %eax je 0x1c39a movq -0x8(%rbp), %rdi leaq 0xdebb(%rip), %rsi # 0x2a250 callq 0x6420 movl -0xc(%rbp), %eax andl $0x20000000, %eax # imm = 0x20000000 cmpl $0x0, %eax je 0x1c3b7 movq -0x8(%rbp), %rdi leaq 0xdea5(%rip), %rsi # 0x2a257 callq 0x6420 jmp 0x1c3b9 movl -0xc(%rbp), %eax andl $0x10000000, %eax # imm = 0x10000000 cmpl $0x0, %eax je 0x1c3d6 movq -0x8(%rbp), %rdi leaq 0xde8e(%rip), %rsi # 0x2a25f callq 0x6420 movl -0xc(%rbp), %eax andl $0x8000000, %eax # imm = 0x8000000 cmpl $0x0, %eax je 0x1c3f3 movq -0x8(%rbp), %rdi leaq 0xde7b(%rip), %rsi # 0x2a269 callq 0x6420 movl -0xc(%rbp), %eax andl $0x4000000, %eax # imm = 0x4000000 cmpl $0x0, %eax je 0x1c410 movq -0x8(%rbp), %rdi leaq 0xde67(%rip), %rsi # 0x2a272 callq 0x6420 movl -0xc(%rbp), %eax andl $0x2000000, %eax # imm = 0x2000000 cmpl $0x0, %eax je 0x1c42d movq -0x8(%rbp), %rdi leaq 0xde52(%rip), %rsi # 0x2a27a callq 0x6420 movl -0xc(%rbp), %eax andl $0x1000000, %eax # imm = 0x1000000 cmpl $0x0, %eax je 0x1c44a movq -0x8(%rbp), %rdi leaq 0xde3e(%rip), %rsi # 0x2a283 callq 0x6420 cmpl $0x2, -0x10(%rbp) jne 0x1c46d movl -0xc(%rbp), %eax andl $0x800000, %eax # imm = 0x800000 cmpl $0x0, %eax je 0x1c46d movq -0x8(%rbp), %rdi leaq 0xde31(%rip), %rsi # 0x2a299 callq 0x6420 cmpl $0x3, -0x10(%rbp) jne 0x1c490 movl -0xc(%rbp), %eax andl $0x800000, %eax # imm = 0x800000 cmpl $0x0, %eax je 0x1c490 movq -0x8(%rbp), %rdi leaq 0xde03(%rip), %rsi # 0x2a28e callq 0x6420 movl -0xc(%rbp), %eax andl $0x400000, %eax # imm = 0x400000 cmpl $0x0, %eax je 0x1c4ad movq -0x8(%rbp), %rdi leaq 0xddee(%rip), %rsi # 0x2a296 callq 0x6420 cmpl $0x3, -0x10(%rbp) jne 0x1c4d0 movl -0xc(%rbp), %eax andl $0x200000, %eax # imm = 0x200000 cmpl $0x0, %eax je 0x1c4d0 movq -0x8(%rbp), %rdi leaq 0xddd8(%rip), %rsi # 0x2a2a3 callq 0x6420 movl -0xc(%rbp), %eax andl $0x100000, %eax # imm = 0x100000 cmpl $0x0, %eax je 0x1c4ed movq -0x8(%rbp), %rdi leaq 0xdfa4(%rip), %rsi # 0x2a48c callq 0x6420 cmpl $0x2, -0x10(%rbp) jne 0x1c5c2 movl -0xc(%rbp), %eax andl $0x80000, %eax # imm = 0x80000 cmpl $0x0, %eax je 0x1c516 movq -0x8(%rbp), %rdi leaq 0xdd9c(%rip), %rsi # 0x2a2ab callq 0x6420 jmp 0x1c526 movq -0x8(%rbp), %rdi leaq 0xdd93(%rip), %rsi # 0x2a2b4 callq 0x6420 movl -0xc(%rbp), %eax andl $0x40000, %eax # imm = 0x40000 cmpl $0x0, %eax je 0x1c543 movq -0x8(%rbp), %rdi leaq 0xdd80(%rip), %rsi # 0x2a2be callq 0x6420 movl -0xc(%rbp), %eax andl $0x30000, %eax # imm = 0x30000 shrl $0x10, %eax movl %eax, -0x14(%rbp) cmpl $0x0, -0x14(%rbp) jne 0x1c569 movq -0x8(%rbp), %rdi leaq 0xdd66(%rip), %rsi # 0x2a2c8 callq 0x6420 jmp 0x1c5ad cmpl $0x1, -0x14(%rbp) jne 0x1c581 movq -0x8(%rbp), %rdi leaq 0xdd58(%rip), %rsi # 0x2a2d2 callq 0x6420 jmp 0x1c5ab cmpl $0x2, -0x14(%rbp) jne 0x1c599 movq -0x8(%rbp), %rdi leaq 0xdd4a(%rip), %rsi # 0x2a2dc callq 0x6420 jmp 0x1c5a9 movq -0x8(%rbp), %rdi leaq 0xdd42(%rip), %rsi # 0x2a2e6 callq 0x6420 jmp 0x1c5ab jmp 0x1c5ad movq -0x8(%rbp), %rdi movq 0x199f8(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x1c774 movl -0xc(%rbp), %eax andl $0x10000, %eax # imm = 0x10000 cmpl $0x0, %eax je 0x1c5df movq -0x8(%rbp), %rdi leaq 0xdd17(%rip), %rsi # 0x2a2f1 callq 0x6420 movq -0x8(%rbp), %rdi movq 0x199c6(%rip), %rsi # 0x35fb0 callq 0x6490 movl $0x1, -0x18(%rbp) cmpl $0x2, -0x18(%rbp) ja 0x1c772 movq -0x8(%rbp), %rdi leaq 0xe93a(%rip), %rsi # 0x2af45 callq 0x6420 movq %rax, %rdi movl -0x18(%rbp), %esi callq 0x65d0 movq %rax, %rdi leaq 0xe110(%rip), %rsi # 0x2a735 callq 0x6420 movl -0xc(%rbp), %edi movl -0x18(%rbp), %esi callq 0x25610 movb %al, -0x19(%rbp) movzbl -0x19(%rbp), %eax andl $0x80, %eax cmpl $0x0, %eax je 0x1c656 movq -0x8(%rbp), %rdi leaq 0xdc06(%rip), %rsi # 0x2a257 callq 0x6420 movzbl -0x19(%rbp), %eax andl $0x40, %eax cmpl $0x0, %eax je 0x1c672 movq -0x8(%rbp), %rdi leaq 0xdc8c(%rip), %rsi # 0x2a2f9 callq 0x6420 movzbl -0x19(%rbp), %eax andl $0x20, %eax cmpl $0x0, %eax je 0x1c690 movq -0x8(%rbp), %rdi leaq 0xdc22(%rip), %rsi # 0x2a2ab callq 0x6420 jmp 0x1c6a0 movq -0x8(%rbp), %rdi leaq 0xdc19(%rip), %rsi # 0x2a2b4 callq 0x6420 movzbl -0x19(%rbp), %eax andl $0x18, %eax sarl $0x3, %eax movb %al, -0x1a(%rbp) movzbl -0x1a(%rbp), %eax cmpl $0x0, %eax jne 0x1c6c8 movq -0x8(%rbp), %rdi leaq 0xdc40(%rip), %rsi # 0x2a301 callq 0x6420 jmp 0x1c700 movzbl -0x1a(%rbp), %eax cmpl $0x1, %eax jne 0x1c6e3 movq -0x8(%rbp), %rdi leaq 0xdc2e(%rip), %rsi # 0x2a30a callq 0x6420 jmp 0x1c6fe movzbl -0x1a(%rbp), %eax cmpl $0x2, %eax jne 0x1c6fc movq -0x8(%rbp), %rdi leaq 0xdc1d(%rip), %rsi # 0x2a314 callq 0x6420 jmp 0x1c6fe jmp 0x1c700 movzbl -0x19(%rbp), %eax andl $0x4, %eax cmpl $0x0, %eax je 0x1c71c movq -0x8(%rbp), %rdi leaq 0xdc08(%rip), %rsi # 0x2a31f callq 0x6420 movzbl -0x19(%rbp), %eax andl $0x2, %eax cmpl $0x0, %eax je 0x1c738 movq -0x8(%rbp), %rdi leaq 0xdbf5(%rip), %rsi # 0x2a328 callq 0x6420 movzbl -0x19(%rbp), %eax andl $0x1, %eax cmpl $0x0, %eax je 0x1c754 movq -0x8(%rbp), %rdi leaq 0xdba2(%rip), %rsi # 0x2a2f1 callq 0x6420 movq -0x8(%rbp), %rdi movq 0x19851(%rip), %rsi # 0x35fb0 callq 0x6490 movl -0x18(%rbp), %eax addl $0x1, %eax movl %eax, -0x18(%rbp) jmp 0x1c5f6 jmp 0x1c774 jmp 0x1c776 jmp 0x1c778 addq $0x20, %rsp popq %rbp retq nop	/jhu-cisst[P]mechatronics-software/lib/code/EthBasePort.cpp
EthBasePort::CheckDebugHeader(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, unsigned int)	bool EthBasePort::CheckDebugHeader(std::ostream &debugStream, const std::string &caller, const char *header, unsigned int version) { if (strncmp(header, "DBG", 3) != 0) { debugStream << caller << ": Unexpected header string: " << header[0] << header[1] << header[2] << " (should be DBG)" << std::endl; return false; } unsigned int debugLevel = header[3] - '0'; if (debugLevel == 0) { debugStream << caller << ": No debug data available" << std::endl; return false; } // Introduced debugLevel 2 with Firmware V8. Use an older version of this software for // earlier versions of firmware. else if (debugLevel != version) { debugStream << caller << ": Unsupported debug level: " << debugLevel << " (must be " << version << ")" << std::endl; return false; } return true; }	pushq %rbp movq %rsp, %rbp subq $0x30, %rsp movq %rdi, -0x10(%rbp) movq %rsi, -0x18(%rbp) movq %rdx, -0x20(%rbp) movl %ecx, -0x24(%rbp) movq -0x20(%rbp), %rdi leaq 0xdb8f(%rip), %rsi # 0x2a331 movl $0x3, %edx callq 0x6280 cmpl $0x0, %eax je 0x1c823 movq -0x10(%rbp), %rdi movq -0x18(%rbp), %rsi callq 0x63b0 movq %rax, %rdi leaq 0xdb6d(%rip), %rsi # 0x2a335 callq 0x6420 movq %rax, %rdi movq -0x20(%rbp), %rax movsbl (%rax), %esi callq 0x6550 movq %rax, %rdi movq -0x20(%rbp), %rax movsbl 0x1(%rax), %esi callq 0x6550 movq %rax, %rdi movq -0x20(%rbp), %rax movsbl 0x2(%rax), %esi callq 0x6550 movq %rax, %rdi leaq 0xdb4c(%rip), %rsi # 0x2a352 callq 0x6420 movq %rax, %rdi movq 0x1979b(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x1c8db movq -0x20(%rbp), %rax movsbl 0x3(%rax), %eax subl $0x30, %eax movl %eax, -0x28(%rbp) cmpl $0x0, -0x28(%rbp) jne 0x1c868 movq -0x10(%rbp), %rdi movq -0x18(%rbp), %rsi callq 0x63b0 movq %rax, %rdi leaq 0xdb15(%rip), %rsi # 0x2a363 callq 0x6420 movq %rax, %rdi movq 0x19753(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x1c8db movl -0x28(%rbp), %eax cmpl -0x24(%rbp), %eax je 0x1c8d5 movq -0x10(%rbp), %rdi movq -0x18(%rbp), %rsi callq 0x63b0 movq %rax, %rdi leaq 0xdaf6(%rip), %rsi # 0x2a37d callq 0x6420 movq %rax, %rdi movl -0x28(%rbp), %esi callq 0x65d0 movq %rax, %rdi leaq 0xdaf8(%rip), %rsi # 0x2a399 callq 0x6420 movq %rax, %rdi movl -0x24(%rbp), %esi callq 0x65d0 movq %rax, %rdi leaq 0xbc38(%rip), %rsi # 0x284f3 callq 0x6420 movq %rax, %rdi movq 0x196e6(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x1c8db jmp 0x1c8d7 movb $0x1, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x30, %rsp popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/EthBasePort.cpp
EthBasePort::PrintDebugDataRTI(std::ostream&, unsigned int const*, double)	void EthBasePort::PrintDebugDataRTI(std::ostream &debugStream, const quadlet_t data, double clockPeriod) { // Following structure must match DebugData in EthRtInterface.v struct DebugData { char header[4]; // Quad 0 uint16_t recv_nbytes; // Quad 1 uint8_t numRecv; uint8_t statusbits; uint8_t numSent; // Quad 2 uint8_t txStateBits; uint16_t respBytes; uint16_t timeReceive; // Quad 3 uint16_t timeSend; uint16_t quad4_low; // Quad 4 uint16_t bw_wait; uint32_t unused[3]; // Quad 5-7 }; if (sizeof(DebugData) != 8sizeof(quadlet_t)) { debugStream << "PrintDebugDataRTI: structure packing problem" << std::endl; return; } const DebugData p = reinterpret_cast<const DebugData >(data); if (!CheckDebugHeader(debugStream, "PrintDebugDataRTI", p->header, 3)) return; debugStream << "*** RTI: "; if (p->statusbits & 0x80) debugStream << "sendBusy "; if (p->statusbits & 0x40) debugStream << "sendRequest "; if (p->statusbits & 0x08) debugStream << "responseRequired "; if (p->statusbits & 0x04) debugStream << "recvNotReady "; if (p->statusbits & 0x02) debugStream << "recvReady "; if (p->statusbits & 0x01) debugStream << "PortReady "; debugStream << std::endl << "rxState: " << static_cast<uint16_t>((p->statusbits&0x30)>>4) << std::endl; debugStream << "numPacketRecv: " << static_cast<uint16_t>(p->numRecv) << ", numBytesRecv: " << p->recv_nbytes << std::endl; debugStream << "numPacketSent: " << static_cast<uint16_t>(p->numSent) << std::endl; debugStream << "txState: " << static_cast<uint16_t>(p->txStateBits&0x07); if (p->txStateBits&0x10) debugStream << ", txStateError "; debugStream << std::endl << "respBytes: " << p->respBytes << std::endl; const double bits2uS = clockPeriod1e6; debugStream << "timeReceive: " << (p->timeReceiveclockPeriod) << " timeSend: " << (p->timeSendclockPeriod) << std::endl; debugStream << "bw_wait: " << std::dec << p->bw_wait << " (" << p->bw_waitbits2uS << " us)" << std::endl; }	pushq %rbp movq %rsp, %rbp subq $0x80, %rsp movq %rdi, -0x8(%rbp) movq %rsi, -0x10(%rbp) movsd %xmm0, -0x18(%rbp) movq -0x10(%rbp), %rax movq %rax, -0x20(%rbp) movq -0x8(%rbp), %rax movq %rax, -0x70(%rbp) leaq -0x41(%rbp), %rdi movq %rdi, -0x68(%rbp) callq 0x67f0 movq -0x68(%rbp), %rdx leaq 0xce33(%rip), %rsi # 0x2a743 leaq -0x40(%rbp), %rdi callq 0xbb90 jmp 0x1d91b movq -0x70(%rbp), %rdi movq -0x20(%rbp), %rdx leaq -0x40(%rbp), %rsi movl $0x3, %ecx callq 0x1c780 movb %al, -0x71(%rbp) jmp 0x1d936 movb -0x71(%rbp), %al xorb $-0x1, %al movb %al, -0x72(%rbp) leaq -0x40(%rbp), %rdi callq 0x62d0 leaq -0x41(%rbp), %rdi callq 0x64c0 movb -0x72(%rbp), %al testb $0x1, %al jne 0x1d959 jmp 0x1d98f jmp 0x1dc96 movq %rax, %rcx movl %edx, %eax movq %rcx, -0x50(%rbp) movl %eax, -0x54(%rbp) jmp 0x1d981 movq %rax, %rcx movl %edx, %eax movq %rcx, -0x50(%rbp) movl %eax, -0x54(%rbp) leaq -0x40(%rbp), %rdi callq 0x62d0 leaq -0x41(%rbp), %rdi callq 0x64c0 jmp 0x1dc9f movq -0x8(%rbp), %rdi leaq 0xcdbb(%rip), %rsi # 0x2a755 callq 0x6420 movq -0x20(%rbp), %rax movzbl 0x7(%rax), %eax andl $0x80, %eax cmpl $0x0, %eax je 0x1d9c1 movq -0x8(%rbp), %rdi leaq 0xca48(%rip), %rsi # 0x2a404 callq 0x6420 movq -0x20(%rbp), %rax movzbl 0x7(%rax), %eax andl $0x40, %eax cmpl $0x0, %eax je 0x1d9e1 movq -0x8(%rbp), %rdi leaq 0xca32(%rip), %rsi # 0x2a40e callq 0x6420 movq -0x20(%rbp), %rax movzbl 0x7(%rax), %eax andl $0x8, %eax cmpl $0x0, %eax je 0x1da01 movq -0x8(%rbp), %rdi leaq 0xcd63(%rip), %rsi # 0x2a75f callq 0x6420 movq -0x20(%rbp), %rax movzbl 0x7(%rax), %eax andl $0x4, %eax cmpl $0x0, %eax je 0x1da21 movq -0x8(%rbp), %rdi leaq 0xcd55(%rip), %rsi # 0x2a771 callq 0x6420 movq -0x20(%rbp), %rax movzbl 0x7(%rax), %eax andl $0x2, %eax cmpl $0x0, %eax je 0x1da41 movq -0x8(%rbp), %rdi leaq 0xcd43(%rip), %rsi # 0x2a77f callq 0x6420 movq -0x20(%rbp), %rax movzbl 0x7(%rax), %eax andl $0x1, %eax cmpl $0x0, %eax je 0x1da61 movq -0x8(%rbp), %rdi leaq 0xcd2e(%rip), %rsi # 0x2a78a callq 0x6420 movq -0x8(%rbp), %rdi movq 0x18544(%rip), %rsi # 0x35fb0 callq 0x6490 movq %rax, %rdi leaq 0xcd1a(%rip), %rsi # 0x2a795 callq 0x6420 movq %rax, %rdi movq -0x20(%rbp), %rax movzbl 0x7(%rax), %eax andl $0x30, %eax sarl $0x4, %eax movzwl %ax, %esi callq 0x6770 movq %rax, %rdi movq 0x1850d(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x8(%rbp), %rdi leaq 0xccec(%rip), %rsi # 0x2a79f callq 0x6420 movq %rax, %rdi movq -0x20(%rbp), %rax movzbl 0x6(%rax), %eax movzwl %ax, %esi callq 0x6770 movq %rax, %rdi leaq 0xccda(%rip), %rsi # 0x2a7af callq 0x6420 movq %rax, %rdi movq -0x20(%rbp), %rax movzwl 0x4(%rax), %esi callq 0x6770 movq %rax, %rdi movq 0x184bc(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x8(%rbp), %rdi leaq 0xcbb9(%rip), %rsi # 0x2a6bd callq 0x6420 movq %rax, %rdi movq -0x20(%rbp), %rax movzbl 0x8(%rax), %eax movzwl %ax, %esi callq 0x6770 movq %rax, %rdi movq 0x1848a(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x8(%rbp), %rdi leaq 0xcc8a(%rip), %rsi # 0x2a7c0 callq 0x6420 movq %rax, %rdi movq -0x20(%rbp), %rax movzbl 0x9(%rax), %eax andl $0x7, %eax movzwl %ax, %esi callq 0x6770 movq -0x20(%rbp), %rax movzbl 0x9(%rax), %eax andl $0x10, %eax cmpl $0x0, %eax je 0x1db71 movq -0x8(%rbp), %rdi leaq 0xcc5e(%rip), %rsi # 0x2a7ca callq 0x6420 movq -0x8(%rbp), %rdi movq 0x18434(%rip), %rsi # 0x35fb0 callq 0x6490 movq %rax, %rdi leaq 0xcb5c(%rip), %rsi # 0x2a6e7 callq 0x6420 movq %rax, %rdi movq -0x20(%rbp), %rax movzwl 0xa(%rax), %esi callq 0x6770 movq %rax, %rdi movq 0x18406(%rip), %rsi # 0x35fb0 callq 0x6490 movsd 0xb561(%rip), %xmm0 # 0x29118 mulsd -0x18(%rbp), %xmm0 movsd %xmm0, -0x60(%rbp) movq -0x8(%rbp), %rdi leaq 0xcc0e(%rip), %rsi # 0x2a7da callq 0x6420 movq %rax, %rdi movq -0x20(%rbp), %rax movzwl 0xc(%rax), %eax cvtsi2sd %eax, %xmm0 mulsd -0x18(%rbp), %xmm0 callq 0x6890 movq %rax, %rdi leaq 0xcbf4(%rip), %rsi # 0x2a7e8 callq 0x6420 movq %rax, %rdi movq -0x20(%rbp), %rax movzwl 0xe(%rax), %eax cvtsi2sd %eax, %xmm0 mulsd -0x18(%rbp), %xmm0 callq 0x6890 movq %rax, %rdi movq 0x18394(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x8(%rbp), %rdi leaq 0xcaea(%rip), %rsi # 0x2a716 callq 0x6420 movq %rax, %rdi leaq -0x11ffb(%rip), %rsi # 0xbc40 callq 0x61f0 movq %rax, %rdi movq -0x20(%rbp), %rax movzwl 0x12(%rax), %esi callq 0x6770 movq %rax, %rdi leaq 0xbeaa(%rip), %rsi # 0x29b04 callq 0x6420 movq %rax, %rdi movq -0x20(%rbp), %rax movzwl 0x12(%rax), %eax cvtsi2sd %eax, %xmm0 mulsd -0x60(%rbp), %xmm0 callq 0x6890 movq %rax, %rdi leaq 0xca9e(%rip), %rsi # 0x2a720 callq 0x6420 movq %rax, %rdi movq 0x1831f(%rip), %rsi # 0x35fb0 callq 0x6490 addq $0x80, %rsp popq %rbp retq movq -0x50(%rbp), %rdi callq 0x67e0 nopl (%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/EthBasePort.cpp
EthBasePort::ReadQuadletNode(unsigned short, unsigned long, unsigned int&, unsigned char)	bool EthBasePort::ReadQuadletNode(nodeid_t node, nodeaddr_t addr, quadlet_t &data, unsigned char flags) { if ((node != FW_NODE_BROADCAST) && !CheckFwBusGeneration("ReadQuadlet")) return false; // Flush before reading int numFlushed = PacketFlushAll(); if (numFlushed > 0) outStr << "ReadQuadlet: flushed " << numFlushed << " packets" << std::endl; // Increment transaction label fw_tl = (fw_tl+1)&FW_TL_MASK; SetGenericBuffer(); // Make sure buffer is allocated unsigned char sendPacket = GenericBuffer+GetWriteQuadAlign(); unsigned int sendPacketSize = GetPrefixOffset(WR_FW_HEADER)+FW_QREAD_SIZE; // Make Ethernet header (only needed for raw Ethernet) make_ethernet_header(sendPacket, sendPacketSize, node, flags); // Make control word make_write_header(sendPacket, sendPacketSize, flags); // Build FireWire packet make_qread_packet(reinterpret_cast<quadlet_t >(sendPacket+GetPrefixOffset(WR_FW_HEADER)), node, addr, fw_tl); if (!PacketSend(node, sendPacket, sendPacketSize, flags&FW_NODE_ETH_BROADCAST_MASK)) return false; // Invoke callback (if defined) between sending read request // and checking for read response. If callback returns false, we // skip checking for a received packet. if (eth_read_callback && !(eth_read_callback)(this, node, outStr)) { outStr << "ReadQuadlet: callback aborting (not reading packet)" << std::endl; return false; } unsigned char recvPacket = GenericBuffer+GetReadQuadAlign(); unsigned int recvPacketSize = GetPrefixOffset(RD_FW_HEADER)+FW_QRESPONSE_SIZE+FW_EXTRA_SIZE; int nRecv = PacketReceive(recvPacket, recvPacketSize); if (nRecv != static_cast<int>(recvPacketSize)) { // Only print message if Node2Board contains valid board number, to avoid unnecessary error messages during ScanNodes. unsigned int boardId = Node2Board[node]; if (boardId < BoardIO::MAX_BOARDS) { outStr << "ReadQuadlet: failed to receive read response from board " << boardId << " via UDP: return value = " << nRecv << ", expected = " << recvPacketSize << std::endl; } return false; } ProcessExtraData(recvPacket+GetPrefixOffset(RD_FW_HEADER)+FW_QRESPONSE_SIZE); if (!CheckEthernetHeader(recvPacket, flags&FW_NODE_ETH_BROADCAST_MASK)) return false; // Byteswap Firewire header (also swaps quadlet data) ByteswapQuadlets(recvPacket + GetPrefixOffset(RD_FW_HEADER), FW_QRESPONSE_SIZE); if (!CheckFirewirePacket(recvPacket+GetPrefixOffset(RD_FW_HEADER), 0, node, EthBasePort::QRESPONSE, fw_tl)) return false; const quadlet_t packet_FW = reinterpret_cast<const quadlet_t *>(recvPacket+GetPrefixOffset(RD_FW_HEADER)); data = packet_FW[3]; return true; }	pushq %rbp movq %rsp, %rbp subq $0x100, %rsp # imm = 0x100 movb %r8b, %al movq %rdi, -0x10(%rbp) movw %si, -0x12(%rbp) movq %rdx, -0x20(%rbp) movq %rcx, -0x28(%rbp) movb %al, -0x29(%rbp) movq -0x10(%rbp), %rax movq %rax, -0xb0(%rbp) movzwl -0x12(%rbp), %ecx movb $0x0, -0x52(%rbp) movb $0x0, -0x65(%rbp) xorl %eax, %eax cmpl $0x3f, %ecx movb %al, -0xa1(%rbp) je 0x1e415 leaq -0x51(%rbp), %rdi movq %rdi, -0xb8(%rbp) callq 0x67f0 movq -0xb8(%rbp), %rdx movb $0x1, -0x52(%rbp) leaq 0xce90(%rip), %rsi # 0x2b267 leaq -0x50(%rbp), %rdi callq 0xbb90 jmp 0x1e3e2 movq -0xb0(%rbp), %rdi movb $0x1, -0x65(%rbp) movq (%rdi), %rax movq 0xd8(%rax), %rax leaq -0x50(%rbp), %rsi xorl %edx, %edx callq %rax movb %al, -0xb9(%rbp) jmp 0x1e407 movb -0xb9(%rbp), %al xorb $-0x1, %al movb %al, -0xa1(%rbp) movb -0xa1(%rbp), %al movb %al, -0xba(%rbp) testb $0x1, -0x65(%rbp) jne 0x1e429 jmp 0x1e432 leaq -0x50(%rbp), %rdi callq 0x62d0 testb $0x1, -0x52(%rbp) jne 0x1e43a jmp 0x1e443 leaq -0x51(%rbp), %rdi callq 0x64c0 movb -0xba(%rbp), %al testb $0x1, %al jne 0x1e44f jmp 0x1e49b movb $0x0, -0x1(%rbp) jmp 0x1e916 movq %rax, %rcx movl %edx, %eax movq %rcx, -0x60(%rbp) movl %eax, -0x64(%rbp) jmp 0x1e485 movq %rax, %rcx movl %edx, %eax movq %rcx, -0x60(%rbp) movl %eax, -0x64(%rbp) testb $0x1, -0x65(%rbp) jne 0x1e47a jmp 0x1e483 leaq -0x50(%rbp), %rdi callq 0x62d0 jmp 0x1e485 testb $0x1, -0x52(%rbp) jne 0x1e48d jmp 0x1e496 leaq -0x51(%rbp), %rdi callq 0x64c0 jmp 0x1e924 movq -0xb0(%rbp), %rdi movq (%rdi), %rax callq 0x178(%rax) movl %eax, -0x6c(%rbp) cmpl $0x0, -0x6c(%rbp) jle 0x1e4f4 movq -0xb0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0xc4a6(%rip), %rsi # 0x2a96c callq 0x6420 movq %rax, %rdi movl -0x6c(%rbp), %esi callq 0x67d0 movq %rax, %rdi leaq 0xc4a2(%rip), %rsi # 0x2a982 callq 0x6420 movq %rax, %rdi movq 0x17ac1(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0xb0(%rbp), %rdi movzbl 0x4e1(%rdi), %eax addl $0x1, %eax andl $0x3f, %eax movb %al, 0x4e1(%rdi) callq 0x15d50 movq -0xb0(%rbp), %rdi movq 0xe0(%rdi), %rax movq %rax, -0xd0(%rbp) movq (%rdi), %rax callq 0xb8(%rax) movq -0xb0(%rbp), %rdi movl %eax, %ecx movq -0xd0(%rbp), %rax movl %ecx, %ecx addq %rcx, %rax movq %rax, -0x78(%rbp) movq (%rdi), %rax movl $0x1, %esi callq 0xa0(%rax) movq -0xb0(%rbp), %rdi addl $0x10, %eax movl %eax, -0x7c(%rbp) movq -0x78(%rbp), %rsi movl -0x7c(%rbp), %edx movw -0x12(%rbp), %cx movb -0x29(%rbp), %r8b movq (%rdi), %rax movzwl %cx, %ecx movzbl %r8b, %r8d callq 0x188(%rax) movq -0xb0(%rbp), %rdi movq -0x78(%rbp), %rsi movl -0x7c(%rbp), %edx movzbl -0x29(%rbp), %ecx callq 0x1e930 movq -0xb0(%rbp), %rdi movq -0x78(%rbp), %rax movq %rax, -0xc8(%rbp) movq (%rdi), %rax movl $0x1, %esi callq 0xa0(%rax) movq -0xc8(%rbp), %rsi movq -0xb0(%rbp), %rdi movl %eax, %eax addq %rax, %rsi movw -0x12(%rbp), %ax movq -0x20(%rbp), %rcx movzbl 0x4e1(%rdi), %r8d movzwl %ax, %edx callq 0x1e9c0 movq -0xb0(%rbp), %rdi movw -0x12(%rbp), %si movq -0x78(%rbp), %rdx movl -0x7c(%rbp), %eax movl %eax, %ecx movzbl -0x29(%rbp), %eax andl $0x80, %eax cmpl $0x0, %eax setne %r8b movq (%rdi), %rax movq 0x168(%rax), %rax movzwl %si, %esi movzbl %r8b, %r8d andl $0x1, %r8d callq %rax testb $0x1, %al jne 0x1e62e movb $0x0, -0x1(%rbp) jmp 0x1e916 movq -0xb0(%rbp), %rax cmpq $0x0, 0x4e8(%rax) je 0x1e68d movq -0xb0(%rbp), %rdi movq 0x4e8(%rdi), %rax movw -0x12(%rbp), %cx movq 0x8(%rdi), %rdx movzbl %cl, %esi callq %rax testb $0x1, %al jne 0x1e68d movq -0xb0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0xc31b(%rip), %rsi # 0x2a98b callq 0x6420 movq %rax, %rdi movq 0x17931(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x1e916 movq -0xb0(%rbp), %rdi movq 0xe0(%rdi), %rax movq %rax, -0xd8(%rbp) movq (%rdi), %rax callq 0xc0(%rax) movq -0xb0(%rbp), %rdi movl %eax, %ecx movq -0xd8(%rbp), %rax movl %ecx, %ecx addq %rcx, %rax movq %rax, -0x88(%rbp) movq (%rdi), %rax movl $0x3, %esi callq 0xa0(%rax) movq -0xb0(%rbp), %rdi addl $0x14, %eax addl $0x8, %eax movl %eax, -0x8c(%rbp) movq -0x88(%rbp), %rsi movl -0x8c(%rbp), %eax movl %eax, %edx movq (%rdi), %rax callq 0x170(%rax) movl %eax, -0x90(%rbp) movl -0x90(%rbp), %eax cmpl -0x8c(%rbp), %eax je 0x1e7b1 movq -0xb0(%rbp), %rax movzwl -0x12(%rbp), %ecx movzbl 0x480(%rax,%rcx), %eax movl %eax, -0x94(%rbp) cmpl $0x10, -0x94(%rbp) jae 0x1e7a8 movq -0xb0(%rbp), %rax movq 0x8(%rax), %rdi leaq 0xc273(%rip), %rsi # 0x2a9bf callq 0x6420 movq %rax, %rdi movl -0x94(%rbp), %esi callq 0x65d0 movq %rax, %rdi leaq 0xd3c5(%rip), %rsi # 0x2bb2e callq 0x6420 movq %rax, %rdi movl -0x90(%rbp), %esi callq 0x67d0 movq %rax, %rdi leaq 0xb6cd(%rip), %rsi # 0x29e53 callq 0x6420 movq %rax, %rdi movl -0x8c(%rbp), %esi callq 0x65d0 movq %rax, %rdi movq 0x1780d(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x1e916 movq -0xb0(%rbp), %rdi movq -0x88(%rbp), %rax movq %rax, -0xe0(%rbp) movq (%rdi), %rax movl $0x3, %esi callq 0xa0(%rax) movq -0xe0(%rbp), %rsi movq -0xb0(%rbp), %rdi movl %eax, %eax addq %rax, %rsi addq $0x14, %rsi callq 0x1b690 movq -0xb0(%rbp), %rdi movq -0x88(%rbp), %rsi movzbl -0x29(%rbp), %eax andl $0x80, %eax cmpl $0x0, %eax setne %cl movq (%rdi), %rax movq 0x190(%rax), %rax movzbl %cl, %edx andl $0x1, %edx callq %rax testb $0x1, %al jne 0x1e82c movb $0x0, -0x1(%rbp) jmp 0x1e916 movq -0xb0(%rbp), %rdi movq -0x88(%rbp), %rax movq %rax, -0xf0(%rbp) movq (%rdi), %rax movl $0x3, %esi callq 0xa0(%rax) movq -0xf0(%rbp), %rsi movq -0xb0(%rbp), %rdi movl %eax, %eax addq %rax, %rsi movl $0x14, %edx callq 0x1ea30 movq -0xb0(%rbp), %rdi movq -0x88(%rbp), %rax movq %rax, -0xe8(%rbp) movq (%rdi), %rax movl $0x3, %esi callq 0xa0(%rax) movq -0xe8(%rbp), %rsi movq -0xb0(%rbp), %rdi movl %eax, %eax addq %rax, %rsi movw -0x12(%rbp), %ax movzbl 0x4e1(%rdi), %r9d xorl %ecx, %ecx movl %ecx, %edx movl $0x6, %r8d movzwl %ax, %ecx callq 0x1b8d0 testb $0x1, %al jne 0x1e8ca movb $0x0, -0x1(%rbp) jmp 0x1e916 movq -0xb0(%rbp), %rdi movq -0x88(%rbp), %rax movq %rax, -0xf8(%rbp) movq (%rdi), %rax movl $0x3, %esi callq 0xa0(%rax) movl %eax, %ecx movq -0xf8(%rbp), %rax movl %ecx, %ecx addq %rcx, %rax movq %rax, -0xa0(%rbp) movq -0xa0(%rbp), %rax movl 0xc(%rax), %ecx movq -0x28(%rbp), %rax movl %ecx, (%rax) movb $0x1, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x100, %rsp # imm = 0x100 popq %rbp retq movq -0x60(%rbp), %rdi callq 0x67e0 nopl (%rax)	/jhu-cisst[P]mechatronics-software/lib/code/EthBasePort.cpp
EthBasePort::WriteQuadletNode(unsigned short, unsigned long, unsigned int, unsigned char)	bool EthBasePort::WriteQuadletNode(nodeid_t node, nodeaddr_t addr, quadlet_t data, unsigned char flags) { if ((node != FW_NODE_BROADCAST) && !CheckFwBusGeneration("WriteQuadlet")) return false; // Use GenericBuffer, which is much larger than needed SetGenericBuffer(); // Make sure buffer is allocated unsigned char packet = GenericBuffer+GetWriteQuadAlign(); unsigned int packetSize = GetPrefixOffset(WR_FW_HEADER)+FW_QWRITE_SIZE; // Increment transaction label fw_tl = (fw_tl+1)&FW_TL_MASK; // Make Ethernet header (only needed for raw Ethernet) make_ethernet_header(packet, packetSize, node, flags); // Make control word make_write_header(packet, packetSize, flags); // Build FireWire packet (also byteswaps data) make_qwrite_packet(reinterpret_cast<quadlet_t >(packet+GetPrefixOffset(WR_FW_HEADER)), node, addr, data, fw_tl); return PacketSend(node, packet, packetSize, flags&FW_NODE_ETH_BROADCAST_MASK); }	pushq %rbp movq %rsp, %rbp subq $0xa0, %rsp movb %r8b, %al movq %rdi, -0x10(%rbp) movw %si, -0x12(%rbp) movq %rdx, -0x20(%rbp) movl %ecx, -0x24(%rbp) movb %al, -0x25(%rbp) movq -0x10(%rbp), %rax movq %rax, -0x78(%rbp) movzwl -0x12(%rbp), %ecx movb $0x0, -0x4a(%rbp) movb $0x0, -0x5d(%rbp) xorl %eax, %eax cmpl $0x3f, %ecx movb %al, -0x6d(%rbp) je 0x1eb22 leaq -0x49(%rbp), %rdi movq %rdi, -0x80(%rbp) callq 0x67f0 movq -0x80(%rbp), %rdx movb $0x1, -0x4a(%rbp) leaq 0xc797(%rip), %rsi # 0x2b281 leaq -0x48(%rbp), %rdi callq 0xbb90 jmp 0x1eaf5 movq -0x78(%rbp), %rdi movb $0x1, -0x5d(%rbp) movq (%rdi), %rax movq 0xd8(%rax), %rax leaq -0x48(%rbp), %rsi xorl %edx, %edx callq %rax movb %al, -0x81(%rbp) jmp 0x1eb17 movb -0x81(%rbp), %al xorb $-0x1, %al movb %al, -0x6d(%rbp) movb -0x6d(%rbp), %al movb %al, -0x82(%rbp) testb $0x1, -0x5d(%rbp) jne 0x1eb33 jmp 0x1eb3c leaq -0x48(%rbp), %rdi callq 0x62d0 testb $0x1, -0x4a(%rbp) jne 0x1eb44 jmp 0x1eb4d leaq -0x49(%rbp), %rdi callq 0x64c0 movb -0x82(%rbp), %al testb $0x1, %al jne 0x1eb59 jmp 0x1eba5 movb $0x0, -0x1(%rbp) jmp 0x1ecc3 movq %rax, %rcx movl %edx, %eax movq %rcx, -0x58(%rbp) movl %eax, -0x5c(%rbp) jmp 0x1eb8f movq %rax, %rcx movl %edx, %eax movq %rcx, -0x58(%rbp) movl %eax, -0x5c(%rbp) testb $0x1, -0x5d(%rbp) jne 0x1eb84 jmp 0x1eb8d leaq -0x48(%rbp), %rdi callq 0x62d0 jmp 0x1eb8f testb $0x1, -0x4a(%rbp) jne 0x1eb97 jmp 0x1eba0 leaq -0x49(%rbp), %rdi callq 0x64c0 jmp 0x1ecd1 movq -0x78(%rbp), %rdi callq 0x15d50 movq -0x78(%rbp), %rdi movq 0xe0(%rdi), %rax movq %rax, -0x98(%rbp) movq (%rdi), %rax callq 0xb8(%rax) movq -0x78(%rbp), %rdi movl %eax, %ecx movq -0x98(%rbp), %rax movl %ecx, %ecx addq %rcx, %rax movq %rax, -0x68(%rbp) movq (%rdi), %rax movl $0x1, %esi callq 0xa0(%rax) movq -0x78(%rbp), %rdi addl $0x14, %eax movl %eax, -0x6c(%rbp) movzbl 0x4e1(%rdi), %eax addl $0x1, %eax andl $0x3f, %eax movb %al, 0x4e1(%rdi) movq -0x68(%rbp), %rsi movl -0x6c(%rbp), %edx movw -0x12(%rbp), %cx movb -0x25(%rbp), %r8b movq (%rdi), %rax movzwl %cx, %ecx movzbl %r8b, %r8d callq 0x188(%rax) movq -0x78(%rbp), %rdi movq -0x68(%rbp), %rsi movl -0x6c(%rbp), %edx movzbl -0x25(%rbp), %ecx callq 0x1e930 movq -0x78(%rbp), %rdi movq -0x68(%rbp), %rax movq %rax, -0x90(%rbp) movq (%rdi), %rax movl $0x1, %esi callq 0xa0(%rax) movq -0x90(%rbp), %rsi movq -0x78(%rbp), %rdi movl %eax, %eax addq %rax, %rsi movw -0x12(%rbp), %ax movq -0x20(%rbp), %rcx movl -0x24(%rbp), %r8d movzbl 0x4e1(%rdi), %r9d movzwl %ax, %edx callq 0x1ece0 movq -0x78(%rbp), %rdi movw -0x12(%rbp), %si movq -0x68(%rbp), %rdx movl -0x6c(%rbp), %eax movl %eax, %ecx movzbl -0x25(%rbp), %eax andl $0x80, %eax cmpl $0x0, %eax setne %r8b movq (%rdi), %rax movq 0x168(%rax), %rax movzwl %si, %esi movzbl %r8b, %r8d andl $0x1, %r8d callq %rax andb $0x1, %al movb %al, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0xa0, %rsp popq %rbp retq movq -0x58(%rbp), %rdi callq 0x67e0 nopw (%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/EthBasePort.cpp
EthBasePort::make_1394_header(unsigned int*, unsigned short, unsigned long, unsigned int, unsigned int)	void EthBasePort::make_1394_header(quadlet_t *packet, nodeid_t node, nodeaddr_t addr, unsigned int tcode, unsigned int tl) { // FFC0 replicates the base node ID when using FireWire on PC. This is followed by a transaction // label (arbitrary value that is returned by any resulting FireWire packets) and the transaction code. unsigned char fw_pri = 0; packet[0] = bswap_32((0xFFC0 \| (node&FW_NODE_MASK)) << 16 \| (tl & 0x003F) << 10 \| (tcode & 0x000F) << 4 \| (fw_pri & 0x000F)); // FFD0 is used as source ID (most significant 16 bits); this sets source node to 0x10 (16). // Previously, FFFF was used, which set the source node to 0x3f (63), which is the broadcast address. // This is followed by the destination address, which is 48-bits long packet[1] = bswap_32((0xFFD0 << 16) \| ((addr & 0x0000FFFF00000000) >> 32)); packet[2] = bswap_32(addr&0xFFFFFFFF); }	pushq %rbp movq %rsp, %rbp subq $0x30, %rsp movw %dx, %ax movq %rdi, -0x8(%rbp) movq %rsi, -0x10(%rbp) movw %ax, -0x12(%rbp) movq %rcx, -0x20(%rbp) movl %r8d, -0x24(%rbp) movl %r9d, -0x28(%rbp) movb $0x0, -0x29(%rbp) movzwl -0x12(%rbp), %edi andl $0x3f, %edi orl $0xffc0, %edi # imm = 0xFFC0 shll $0x10, %edi movl -0x28(%rbp), %eax andl $0x3f, %eax shll $0xa, %eax orl %eax, %edi movl -0x24(%rbp), %eax andl $0xf, %eax shll $0x4, %eax orl %eax, %edi movzbl -0x29(%rbp), %eax andl $0xf, %eax orl %eax, %edi callq 0x1f440 movl %eax, %ecx movq -0x10(%rbp), %rax movl %ecx, (%rax) movabsq $0xffff00000000, %rax # imm = 0xFFFF00000000 andq -0x20(%rbp), %rax shrq $0x20, %rax orq $-0x300000, %rax # imm = 0xFFD00000 movl %eax, %edi callq 0x1f440 movl %eax, %ecx movq -0x10(%rbp), %rax movl %ecx, 0x4(%rax) movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF andq -0x20(%rbp), %rax movl %eax, %edi callq 0x1f440 movl %eax, %ecx movq -0x10(%rbp), %rax movl %ecx, 0x8(%rax) addq $0x30, %rsp popq %rbp retq nop	/jhu-cisst[P]mechatronics-software/lib/code/EthBasePort.cpp
PortFactory(char const*, std::ostream&)	BasePort * PortFactory(const char * args, std::ostream & debugStream) { BasePort * port = 0; int portNumber = 0; std::string IPaddr = ETH_UDP_DEFAULT_IP; bool fwBridge = false; BasePort::PortType portType = BasePort::DefaultPortType(); if (!BasePort::ParseOptions(args, portType, portNumber, IPaddr, fwBridge)) { debugStream << "PortFactory: Failed to parse option: " << args << std::endl; return port; } switch (portType) { case BasePort::PORT_FIREWIRE: #if Amp1394_HAS_RAW1394 port = new FirewirePort(portNumber, debugStream); #else debugStream << "PortFactory: FireWire not available (set Amp1394_HAS_RAW1394 in CMake)" << std::endl; #endif break; case BasePort::PORT_ETH_UDP: port = new EthUdpPort(portNumber, IPaddr, fwBridge, debugStream); break; case BasePort::PORT_ETH_RAW: #if Amp1394_HAS_PCAP port = new EthRawPort(portNumber, fwBridge, debugStream); #else debugStream << "PortFactory: Raw Ethernet not available (set Amp1394_HAS_PCAP in CMake)" << std::endl; #endif break; case BasePort::PORT_ZYNQ_EMIO: #if Amp1394_HAS_EMIO port = new ZynqEmioPort(portNumber, debugStream); #else debugStream << "PortFactory: Zynq EMIO not available" << std::endl; #endif break; default: debugStream << "PortFactory: Unsupported port type" << std::endl; break; } return port; }	pushq %rbp movq %rsp, %rbp subq $0xc0, %rsp movq %rdi, -0x10(%rbp) movq %rsi, -0x18(%rbp) movq $0x0, -0x20(%rbp) movl $0x0, -0x24(%rbp) leaq -0x49(%rbp), %rdi movq %rdi, -0x70(%rbp) callq 0x67f0 movq -0x70(%rbp), %rdx leaq 0x966d(%rip), %rsi # 0x29977 leaq -0x48(%rbp), %rdi callq 0xbb90 jmp 0x20315 leaq -0x49(%rbp), %rdi callq 0x64c0 movb $0x0, -0x5d(%rbp) callq 0x17870 movl %eax, -0x74(%rbp) jmp 0x2032c movl -0x74(%rbp), %eax movl %eax, -0x64(%rbp) movq -0x10(%rbp), %rdi movq 0x15cb3(%rip), %r9 # 0x35ff0 leaq -0x64(%rbp), %rsi leaq -0x24(%rbp), %rdx leaq -0x48(%rbp), %rcx leaq -0x5d(%rbp), %r8 callq 0x172c0 movb %al, -0x75(%rbp) jmp 0x20357 movb -0x75(%rbp), %al testb $0x1, %al jne 0x203e4 jmp 0x20364 movq -0x18(%rbp), %rdi leaq 0xaa21(%rip), %rsi # 0x2ad90 callq 0x6420 movq %rax, -0x80(%rbp) jmp 0x2037a movq -0x80(%rbp), %rdi movq -0x10(%rbp), %rsi callq 0x6420 movq %rax, -0x88(%rbp) jmp 0x20390 movq -0x88(%rbp), %rdi movq 0x15c12(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x203a5 movq -0x20(%rbp), %rax movq %rax, -0x8(%rbp) movl $0x1, -0x68(%rbp) jmp 0x20572 movq %rax, %rcx movl %edx, %eax movq %rcx, -0x58(%rbp) movl %eax, -0x5c(%rbp) leaq -0x49(%rbp), %rdi callq 0x64c0 jmp 0x20591 movq %rax, %rcx movl %edx, %eax movq %rcx, -0x58(%rbp) movl %eax, -0x5c(%rbp) jmp 0x20588 movl -0x64(%rbp), %eax movq %rax, -0x90(%rbp) subq $0x3, %rax ja 0x20533 movq -0x90(%rbp), %rax leaq 0xa97a(%rip), %rcx # 0x2ad80 movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq *%rax movl $0x4f8, %edi # imm = 0x4F8 callq 0x6430 movq %rax, -0x98(%rbp) jmp 0x20422 movq -0x98(%rbp), %rdi movl -0x24(%rbp), %esi movq -0x18(%rbp), %rdx callq 0x205a0 jmp 0x20437 movq -0x98(%rbp), %rax movq %rax, -0x20(%rbp) jmp 0x20563 movq -0x98(%rbp), %rdi movq %rax, %rcx movl %edx, %eax movq %rcx, -0x58(%rbp) movl %eax, -0x5c(%rbp) movl $0x4f8, %esi # imm = 0x4F8 callq 0x6440 jmp 0x20588 movl $0x570, %edi # imm = 0x570 callq 0x6430 movq %rax, -0xa0(%rbp) jmp 0x2047c movq -0xa0(%rbp), %rdi movl -0x24(%rbp), %esi movq -0x18(%rbp), %r8 movzbl -0x5d(%rbp), %ecx andl $0x1, %ecx xorl %eax, %eax movl %eax, %r9d leaq -0x48(%rbp), %rdx callq 0x268c0 jmp 0x204a1 movq -0xa0(%rbp), %rax movq %rax, -0x20(%rbp) jmp 0x20563 movq -0xa0(%rbp), %rdi movq %rax, %rcx movl %edx, %eax movq %rcx, -0x58(%rbp) movl %eax, -0x5c(%rbp) movl $0x570, %esi # imm = 0x570 callq 0x6440 jmp 0x20588 movq -0x18(%rbp), %rdi leaq 0xa8d8(%rip), %rsi # 0x2adb6 callq 0x6420 movq %rax, -0xa8(%rbp) jmp 0x204ec movq -0xa8(%rbp), %rdi movq 0x15ab6(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x20501 jmp 0x20563 movq -0x18(%rbp), %rdi leaq 0xa8f0(%rip), %rsi # 0x2adfe callq 0x6420 movq %rax, -0xb0(%rbp) jmp 0x2051c movq -0xb0(%rbp), %rdi movq 0x15a86(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x20531 jmp 0x20563 movq -0x18(%rbp), %rdi leaq 0xa8e5(%rip), %rsi # 0x2ae23 callq 0x6420 movq %rax, -0xb8(%rbp) jmp 0x2054c movq -0xb8(%rbp), %rdi movq 0x15a56(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x20561 jmp 0x20563 movq -0x20(%rbp), %rax movq %rax, -0x8(%rbp) movl $0x1, -0x68(%rbp) leaq -0x48(%rbp), %rdi callq 0x62d0 movq -0x8(%rbp), %rax addq $0xc0, %rsp popq %rbp retq leaq -0x48(%rbp), %rdi callq 0x62d0 movq -0x58(%rbp), %rdi callq 0x67e0 nopw (%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/PortFactory.cpp
FirewirePort::Init()	bool FirewirePort::Init(void) { // create firewire port handle handle = raw1394_new_handle(); if (!handle) { outStr << "FirewirePort::Init: error, could not create handle" << std::endl; return false; } PortListType::const_iterator it; for (it = PortList.begin(); it != PortList.end(); it++) { if ((it)->PortNum == PortNum) outStr << "FirewirePort::Init: warning, port " << PortNum << " is already used (be careful about thread safety)" << std::endl; if ((it)->handle == handle) // should never happen outStr << "FirewirePort::Init: warning, handle is already used" << std::endl; } PortList.push_back(this); memset(Node2Board, BoardIO::MAX_BOARDS, sizeof(Node2Board)); // set the bus reset handler old_reset_handler = raw1394_set_bus_reset_handler(handle, reset_handler); // get number of ports int nports = raw1394_get_port_info(handle, NULL, 0); outStr << "FirewirePort::Init: number of ports = " << nports << std::endl; if (nports > 0) { struct raw1394_portinfo *pinfo = new raw1394_portinfo[nports]; raw1394_get_port_info(handle, pinfo, nports); for (int i = 0; i < nports; i++) outStr << " Port " << i << ": " << pinfo[i].name << ", " << pinfo[i].nodes << " nodes" << std::endl; delete [] pinfo; } if (nports < PortNum) { outStr << "FirewirePort::Init: port " << PortNum << " does not exist" << std::endl; raw1394_destroy_handle(handle); handle = NULL; return false; } if (raw1394_set_port(handle, PortNum)) { outStr << "FirewirePort::Init: error setting port to " << PortNum << std::endl; raw1394_destroy_handle(handle); handle = NULL; return false; } outStr << "FirewirePort::Init: successfully initialized port " << PortNum << std::endl; outStr << "Using libraw1394 version " << raw1394_get_libversion() << std::endl; // stop cycle start packet StopCycleStartPacket(); bool ret = ScanNodes(); if (ret) SetDefaultProtocol(); return ret; }	pushq %rbp movq %rsp, %rbp subq $0x70, %rsp movq %rdi, -0x10(%rbp) movq -0x10(%rbp), %rax movq %rax, -0x60(%rbp) callq 0x6670 movq %rax, %rcx movq -0x60(%rbp), %rax movq %rcx, 0x4e0(%rax) cmpq $0x0, 0x4e0(%rax) jne 0x2066d movq -0x60(%rbp), %rax movq 0x8(%rax), %rdi leaq 0xa810(%rip), %rsi # 0x2ae60 callq 0x6420 movq %rax, %rdi movq 0x15951(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x20aa5 leaq -0x18(%rbp), %rdi callq 0x21cf0 leaq 0x16d33(%rip), %rdi # 0x373b0 callq 0x21d10 movq %rax, -0x28(%rbp) leaq -0x20(%rbp), %rdi leaq -0x28(%rbp), %rsi callq 0x21d40 movq -0x20(%rbp), %rax movq %rax, -0x18(%rbp) leaq 0x16d0e(%rip), %rdi # 0x373b0 callq 0x21dc0 movq %rax, -0x30(%rbp) leaq -0x18(%rbp), %rdi leaq -0x30(%rbp), %rsi callq 0x21d80 testb $0x1, %al jne 0x206c1 jmp 0x20773 leaq -0x18(%rbp), %rdi callq 0x21df0 movq -0x60(%rbp), %rcx movq (%rax), %rax movl 0x28(%rax), %eax cmpl 0x28(%rcx), %eax jne 0x2071a movq -0x60(%rbp), %rax movq 0x8(%rax), %rdi leaq 0xa7ab(%rip), %rsi # 0x2ae93 callq 0x6420 movq %rax, %rdi movq -0x60(%rbp), %rax movl 0x28(%rax), %esi callq 0x67d0 movq %rax, %rdi leaq 0xa7b0(%rip), %rsi # 0x2aeb6 callq 0x6420 movq %rax, %rdi movq 0x1589b(%rip), %rsi # 0x35fb0 callq 0x6490 leaq -0x18(%rbp), %rdi callq 0x21df0 movq -0x60(%rbp), %rcx movq (%rax), %rax movq 0x4e0(%rax), %rax cmpq 0x4e0(%rcx), %rax jne 0x2075d movq -0x60(%rbp), %rax movq 0x8(%rax), %rdi leaq 0xa79f(%rip), %rsi # 0x2aee8 callq 0x6420 movq %rax, %rdi movq 0x15858(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x2075f leaq -0x18(%rbp), %rdi xorl %esi, %esi callq 0x21e10 movq %rax, -0x38(%rbp) jmp 0x2069b movq -0x60(%rbp), %rax movq %rax, -0x40(%rbp) leaq 0x16c2e(%rip), %rdi # 0x373b0 leaq -0x40(%rbp), %rsi callq 0x21e50 movq -0x60(%rbp), %rdi addq $0x480, %rdi # imm = 0x480 movl $0x10, %esi movl $0x40, %edx callq 0x62b0 movq -0x60(%rbp), %rax movq 0x4e0(%rax), %rdi leaq 0x2f9(%rip), %rsi # 0x20ab0 callq 0x6460 movq %rax, %rcx movq -0x60(%rbp), %rax movq %rcx, 0x4f0(%rax) movq 0x4e0(%rax), %rdi xorl %eax, %eax movl %eax, %esi xorl %edx, %edx callq 0x62e0 movl %eax, %ecx movq -0x60(%rbp), %rax movl %ecx, -0x44(%rbp) movq 0x8(%rax), %rdi leaq 0xa72c(%rip), %rsi # 0x2af1c callq 0x6420 movq %rax, %rdi movl -0x44(%rbp), %esi callq 0x67d0 movq %rax, %rdi movq 0x157a6(%rip), %rsi # 0x35fb0 callq 0x6490 cmpl $0x0, -0x44(%rbp) jle 0x20925 movslq -0x44(%rbp), %rax movl $0x24, %ecx mulq %rcx movq %rax, %rdi seto %cl movq $-0x1, %rax testb $0x1, %cl cmovneq %rax, %rdi callq 0x6030 movq %rax, %rcx movq -0x60(%rbp), %rax movq %rcx, -0x50(%rbp) movq 0x4e0(%rax), %rdi movq -0x50(%rbp), %rsi movl -0x44(%rbp), %edx callq 0x62e0 movl $0x0, -0x54(%rbp) movl -0x54(%rbp), %eax cmpl -0x44(%rbp), %eax jge 0x2090c movq -0x60(%rbp), %rax movq 0x8(%rax), %rdi leaq 0xa6c5(%rip), %rsi # 0x2af43 callq 0x6420 movq %rax, %rdi movl -0x54(%rbp), %esi callq 0x67d0 movq %rax, %rdi leaq 0x9e9d(%rip), %rsi # 0x2a735 callq 0x6420 movq %rax, %rdi movq -0x50(%rbp), %rsi movslq -0x54(%rbp), %rax imulq $0x24, %rax, %rax addq %rax, %rsi addq $0x4, %rsi callq 0x6420 movq %rax, %rdi leaq 0x8a9f(%rip), %rsi # 0x29361 callq 0x6420 movq %rax, %rdi movq -0x50(%rbp), %rax movslq -0x54(%rbp), %rcx imulq $0x24, %rcx, %rcx addq %rcx, %rax movl (%rax), %esi callq 0x67d0 movq %rax, %rdi leaq 0x91f2(%rip), %rsi # 0x29adc callq 0x6420 movq %rax, %rdi movq 0x156b7(%rip), %rsi # 0x35fb0 callq 0x6490 movl -0x54(%rbp), %eax addl $0x1, %eax movl %eax, -0x54(%rbp) jmp 0x20863 movq -0x50(%rbp), %rax movq %rax, -0x68(%rbp) cmpq $0x0, %rax je 0x20923 movq -0x68(%rbp), %rdi callq 0x6590 jmp 0x20925 movq -0x60(%rbp), %rcx movl -0x44(%rbp), %eax cmpl 0x28(%rcx), %eax jge 0x2099a movq -0x60(%rbp), %rax movq 0x8(%rax), %rdi leaq 0xa60b(%rip), %rsi # 0x2af4b callq 0x6420 movq %rax, %rdi movq -0x60(%rbp), %rax movl 0x28(%rax), %esi callq 0x67d0 movq %rax, %rdi leaq 0xa607(%rip), %rsi # 0x2af65 callq 0x6420 movq %rax, %rdi movq 0x15643(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x60(%rbp), %rax movq 0x4e0(%rax), %rdi callq 0x6040 movq -0x60(%rbp), %rax movq $0x0, 0x4e0(%rax) movb $0x0, -0x1(%rbp) jmp 0x20aa5 movq -0x60(%rbp), %rax movq 0x4e0(%rax), %rdi movl 0x28(%rax), %esi callq 0x6640 cmpl $0x0, %eax je 0x20a0c movq -0x60(%rbp), %rax movq 0x8(%rax), %rdi leaq 0xa5b4(%rip), %rsi # 0x2af75 callq 0x6420 movq %rax, %rdi movq -0x60(%rbp), %rax movl 0x28(%rax), %esi callq 0x67d0 movq %rax, %rdi movq 0x155d1(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x60(%rbp), %rax movq 0x4e0(%rax), %rdi callq 0x6040 movq -0x60(%rbp), %rax movq $0x0, 0x4e0(%rax) movb $0x0, -0x1(%rbp) jmp 0x20aa5 movq -0x60(%rbp), %rax movq 0x8(%rax), %rdi leaq 0xa585(%rip), %rsi # 0x2afa0 callq 0x6420 movq %rax, %rdi movq -0x60(%rbp), %rax movl 0x28(%rax), %esi callq 0x67d0 movq %rax, %rdi movq 0x15577(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x60(%rbp), %rax movq 0x8(%rax), %rdi leaq 0xa586(%rip), %rsi # 0x2afd3 callq 0x6420 movq %rax, -0x70(%rbp) callq 0x68c0 movq -0x70(%rbp), %rdi movq %rax, %rsi callq 0x6420 movq %rax, %rdi movq 0x1553f(%rip), %rsi # 0x35fb0 callq 0x6490 movq -0x60(%rbp), %rdi callq 0x20be0 movq -0x60(%rbp), %rdi movq (%rdi), %rax callq *0x18(%rax) andb $0x1, %al movb %al, -0x55(%rbp) testb $0x1, -0x55(%rbp) je 0x20a9d movq -0x60(%rbp), %rdi callq 0x16d40 movb -0x55(%rbp), %al andb $0x1, %al movb %al, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x70, %rsp popq %rbp retq	/jhu-cisst[P]mechatronics-software/lib/code/FirewirePort.cpp
FirewirePort::StopCycleStartPacket()	void FirewirePort::StopCycleStartPacket(void) { // IMPORTANT: Disable Cycle Start Packet, no isochronous int rc = 0; // return code quadlet_t data_stop_cmc = bswap_32(0x100); rc = raw1394_write(handle, raw1394_get_local_id(handle), CSR_REGISTER_BASE + CSR_STATE_CLEAR, 4, &data_stop_cmc); if (rc) { outStr << "FirewirePort::Init: error, can NOT disable cycle start packet" << std::endl; } else { outStr << "FirewirePort::Init: successfully disabled cycle start packet" << std::endl; } }	pushq %rbp movq %rsp, %rbp subq $0x20, %rsp movq %rdi, -0x8(%rbp) movq -0x8(%rbp), %rax movq %rax, -0x20(%rbp) movl $0x0, -0xc(%rbp) movl $0x100, %edi # imm = 0x100 callq 0x20ca0 movl %eax, %ecx movq -0x20(%rbp), %rax movl %ecx, -0x10(%rbp) movq 0x4e0(%rax), %rcx movq %rcx, -0x18(%rbp) movq 0x4e0(%rax), %rdi callq 0x63c0 movq -0x18(%rbp), %rdi movabsq $0xfffff0000000, %rdx # imm = 0xFFFFF0000000 movl $0x4, %ecx leaq -0x10(%rbp), %r8 movzwl %ax, %esi callq 0x63f0 movl %eax, -0xc(%rbp) cmpl $0x0, -0xc(%rbp) je 0x20c72 movq -0x20(%rbp), %rax movq 0x8(%rax), %rdi leaq 0xa391(%rip), %rsi # 0x2afed callq 0x6420 movq %rax, %rdi movq 0x15345(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x20c95 movq -0x20(%rbp), %rax movq 0x8(%rax), %rdi leaq 0xa3aa(%rip), %rsi # 0x2b02b callq 0x6420 movq %rax, %rdi movq 0x15320(%rip), %rsi # 0x35fb0 callq 0x6490 addq $0x20, %rsp popq %rbp retq nopl (%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/FirewirePort.cpp
FpgaIO::PromReadBlock25AA128(unsigned short, unsigned int*, unsigned int, unsigned char)	bool FpgaIO::PromReadBlock25AA128(uint16_t addr, quadlet_t data, unsigned int nquads, unsigned char chan) { // nquads sanity check if (nquads == 0 \|\| nquads > 16) { std::cout << "invalid number of quadlets" << std::endl; return false; } PromType prom_type = (chan == 1) ? PROM_25AA128_1 : (chan == 2) ? PROM_25AA128_2 : PROM_25AA128; // trigger read quadlet_t write_data = 0xFE000000\|(addr << 8)\|(nquads-1); nodeaddr_t address = GetPromAddress(prom_type, true); if (!port->WriteQuadlet(BoardId, address, write_data)) return false; // get result if (!port->ReadBlock(BoardId, (address\|0x0100), data, nquads 4)) return false; else return true; }	pushq %rbp movq %rsp, %rbp subq $0x50, %rsp movb %r8b, %al movq %rdi, -0x10(%rbp) movw %si, -0x12(%rbp) movq %rdx, -0x20(%rbp) movl %ecx, -0x24(%rbp) movb %al, -0x25(%rbp) movq -0x10(%rbp), %rax movq %rax, -0x40(%rbp) cmpl $0x0, -0x24(%rbp) je 0x24ad1 cmpl $0x10, -0x24(%rbp) jbe 0x24afc movq 0x114f0(%rip), %rdi # 0x35fc8 leaq 0x6a51(%rip), %rsi # 0x2b530 callq 0x6420 movq %rax, %rdi movq 0x114c2(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x24bc3 movzbl -0x25(%rbp), %eax cmpl $0x1, %eax jne 0x24b0f movl $0x3, %eax movl %eax, -0x44(%rbp) jmp 0x24b26 movzbl -0x25(%rbp), %edx movl $0x2, %eax movl $0x4, %ecx cmpl $0x2, %edx cmovel %ecx, %eax movl %eax, -0x44(%rbp) movq -0x40(%rbp), %rdi movl -0x44(%rbp), %eax movl %eax, -0x2c(%rbp) movzwl -0x12(%rbp), %eax shll $0x8, %eax orl $0xfe000000, %eax # imm = 0xFE000000 movl -0x24(%rbp), %ecx subl $0x1, %ecx orl %ecx, %eax movl %eax, -0x30(%rbp) movl -0x2c(%rbp), %esi movl $0x1, %edx callq 0x239d0 movq %rax, %rcx movq -0x40(%rbp), %rax movq %rcx, -0x38(%rbp) movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movq -0x38(%rbp), %rdx movl -0x30(%rbp), %ecx movq (%rdi), %rax movzbl %sil, %esi callq 0x120(%rax) testb $0x1, %al jne 0x24b85 movb $0x0, -0x1(%rbp) jmp 0x24bc3 movq -0x40(%rbp), %rax movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movq -0x38(%rbp), %rdx orq $0x100, %rdx # imm = 0x100 movq -0x20(%rbp), %rcx movl -0x24(%rbp), %r8d shll $0x2, %r8d movq (%rdi), %rax movzbl %sil, %esi callq 0x130(%rax) testb $0x1, %al jne 0x24bbf movb $0x0, -0x1(%rbp) jmp 0x24bc3 movb $0x1, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x50, %rsp popq %rbp retq nop	/jhu-cisst[P]mechatronics-software/lib/code/FpgaIO.cpp
FpgaIO::PromWriteBlock25AA128(unsigned short, unsigned int*, unsigned int, unsigned char)	bool FpgaIO::PromWriteBlock25AA128(uint16_t addr, quadlet_t data, unsigned int nquads, unsigned char chan) { // address sanity check if (nquads == 0 \|\| nquads > 16) { std::cout << "invalid number of quadlets" << std::endl; return false; } PromType prom_type = (chan == 1) ? PROM_25AA128_1 : (chan == 2) ? PROM_25AA128_2 : PROM_25AA128; nodeaddr_t address = GetPromAddress(prom_type, true); // block write data to buffer if (!port->WriteBlock(BoardId, (address\|0x0100), data, nquadssizeof(quadlet_t))) return false; // enable write PromWriteEnable(prom_type); // trigger write quadlet_t write_data = 0xFF000000\|(addr << 8)\|(nquads-1); return port->WriteQuadlet(BoardId, address, write_data); }	pushq %rbp movq %rsp, %rbp subq $0x50, %rsp movb %r8b, %al movq %rdi, -0x10(%rbp) movw %si, -0x12(%rbp) movq %rdx, -0x20(%rbp) movl %ecx, -0x24(%rbp) movb %al, -0x25(%rbp) movq -0x10(%rbp), %rax movq %rax, -0x48(%rbp) cmpl $0x0, -0x24(%rbp) je 0x24c01 cmpl $0x10, -0x24(%rbp) jbe 0x24c2c movq 0x113c0(%rip), %rdi # 0x35fc8 leaq 0x6921(%rip), %rsi # 0x2b530 callq 0x6420 movq %rax, %rdi movq 0x11392(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x24cf9 movzbl -0x25(%rbp), %eax cmpl $0x1, %eax jne 0x24c3f movl $0x3, %eax movl %eax, -0x4c(%rbp) jmp 0x24c56 movzbl -0x25(%rbp), %edx movl $0x2, %eax movl $0x4, %ecx cmpl $0x2, %edx cmovel %ecx, %eax movl %eax, -0x4c(%rbp) movq -0x48(%rbp), %rdi movl -0x4c(%rbp), %eax movl %eax, -0x2c(%rbp) movl -0x2c(%rbp), %esi movl $0x1, %edx callq 0x239d0 movq %rax, %rcx movq -0x48(%rbp), %rax movq %rcx, -0x38(%rbp) movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movq -0x38(%rbp), %rdx orq $0x100, %rdx # imm = 0x100 movq -0x20(%rbp), %rcx movl -0x24(%rbp), %eax shlq $0x2, %rax movl %eax, %r8d movq (%rdi), %rax movzbl %sil, %esi callq 0x138(%rax) testb $0x1, %al jne 0x24cb0 movb $0x0, -0x1(%rbp) jmp 0x24cf9 movq -0x48(%rbp), %rdi movl -0x2c(%rbp), %esi callq 0x23b00 movq -0x48(%rbp), %rax movzwl -0x12(%rbp), %ecx shll $0x8, %ecx orl $0xff000000, %ecx # imm = 0xFF000000 movl -0x24(%rbp), %edx subl $0x1, %edx orl %edx, %ecx movl %ecx, -0x3c(%rbp) movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movq -0x38(%rbp), %rdx movl -0x3c(%rbp), %ecx movq (%rdi), %rax movzbl %sil, %esi callq 0x120(%rax) andb $0x1, %al movb %al, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x50, %rsp popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/FpgaIO.cpp
FpgaIO::ReadKSZ8851DMA(unsigned short&)	bool FpgaIO::ReadKSZ8851DMA(uint16_t &rdata) { if (GetFirmwareVersion() < 5) return false; quadlet_t write_data = ETH_CTRL_DMA_V2 \| ETH_CTRL_WB_V2 \| rdata; if (!WriteEthernetControl(write_data)) return false; quadlet_t read_data; if (!ReadEthernetStatus(read_data)) return false; // Check if Ethernet is present if (!(read_data&ETH_STAT_PRESENT_V2)) return false; // Check if last command had an error if (read_data&ETH_STAT_REQ_ERR_V2) return false; rdata = static_cast<uint16_t>(read_data); return true; }	pushq %rbp movq %rsp, %rbp subq $0x30, %rsp movq %rdi, -0x10(%rbp) movq %rsi, -0x18(%rbp) movq -0x10(%rbp), %rdi movq %rdi, -0x28(%rbp) callq 0xdd60 cmpl $0x5, %eax jae 0x250d8 movb $0x0, -0x1(%rbp) jmp 0x2514b movq -0x28(%rbp), %rdi movq -0x18(%rbp), %rax movzwl (%rax), %eax orl $0x9000000, %eax # imm = 0x9000000 movl %eax, -0x1c(%rbp) movl -0x1c(%rbp), %esi callq 0x24d80 testb $0x1, %al jne 0x250fd movb $0x0, -0x1(%rbp) jmp 0x2514b movq -0x28(%rbp), %rdi leaq -0x20(%rbp), %rsi callq 0x24f00 testb $0x1, %al jne 0x25114 movb $0x0, -0x1(%rbp) jmp 0x2514b movl -0x20(%rbp), %eax andl $0x80000000, %eax # imm = 0x80000000 cmpl $0x0, %eax jne 0x25127 movb $0x0, -0x1(%rbp) jmp 0x2514b movl -0x20(%rbp), %eax andl $0x40000000, %eax # imm = 0x40000000 cmpl $0x0, %eax je 0x2513a movb $0x0, -0x1(%rbp) jmp 0x2514b movl -0x20(%rbp), %eax movw %ax, %cx movq -0x18(%rbp), %rax movw %cx, (%rax) movb $0x1, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x30, %rsp popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/FpgaIO.cpp
FpgaIO::WaitRTL8211F_Idle(char const*, unsigned int, unsigned int)	bool FpgaIO::WaitRTL8211F_Idle(const char *callerName, unsigned int chan, unsigned int loop_cnt) { // Should have firmware/hardware checks // First, wait 1 millisecond Amp1394_Sleep(0.001); // Now, check up to loop_cnt iterations nodeaddr_t address = 0x40a0 \| (chan << 8); quadlet_t read_data; bool isIdle = false; unsigned int i = 0; while (!isIdle && (i++ < loop_cnt)) { if (port->ReadQuadlet(BoardId, address, read_data)) isIdle = ((read_data&0x07000000) == 0); } if (!isIdle) { std::cout << callerName << " timeout waiting for idle, cnt " << i << ", read " << std::hex << read_data << std::dec << std::endl; } return isIdle; }	pushq %rbp movq %rsp, %rbp subq $0x40, %rsp movq %rdi, -0x8(%rbp) movq %rsi, -0x10(%rbp) movl %edx, -0x14(%rbp) movl %ecx, -0x18(%rbp) movq -0x8(%rbp), %rax movq %rax, -0x38(%rbp) movsd 0x38fa(%rip), %xmm0 # 0x28b00 callq 0x14790 movl -0x14(%rbp), %eax shll $0x8, %eax orl $0x40a0, %eax # imm = 0x40A0 movl %eax, %eax movq %rax, -0x20(%rbp) movb $0x0, -0x25(%rbp) movl $0x0, -0x2c(%rbp) xorl %eax, %eax testb $0x1, -0x25(%rbp) movb %al, -0x39(%rbp) jne 0x25246 movl -0x2c(%rbp), %eax movl %eax, %ecx addl $0x1, %ecx movl %ecx, -0x2c(%rbp) cmpl -0x18(%rbp), %eax setb %al movb %al, -0x39(%rbp) movb -0x39(%rbp), %al testb $0x1, %al jne 0x2524f jmp 0x2528b movq -0x38(%rbp), %rax movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movq -0x20(%rbp), %rdx movq (%rdi), %rax leaq -0x24(%rbp), %rcx movzbl %sil, %esi callq *0x118(%rax) testb $0x1, %al jne 0x25276 jmp 0x25289 movl -0x24(%rbp), %eax andl $0x7000000, %eax # imm = 0x7000000 cmpl $0x0, %eax sete %al andb $0x1, %al movb %al, -0x25(%rbp) jmp 0x25227 testb $0x1, -0x25(%rbp) jne 0x25302 movq -0x10(%rbp), %rsi movq 0x10d2c(%rip), %rdi # 0x35fc8 callq 0x6420 movq %rax, %rdi leaq 0x62b4(%rip), %rsi # 0x2b55f callq 0x6420 movq %rax, %rdi movl -0x2c(%rbp), %esi callq 0x65d0 movq %rax, %rdi leaq 0x62fe(%rip), %rsi # 0x2b5c3 callq 0x6420 movq %rax, %rdi leaq -0x10c14(%rip), %rsi # 0x146c0 callq 0x61f0 movq %rax, %rdi movl -0x24(%rbp), %esi callq 0x65d0 movq %rax, %rdi leaq -0x196ae(%rip), %rsi # 0xbc40 callq 0x61f0 movq %rax, %rdi movq 0x10cb3(%rip), %rsi # 0x35fb0 callq 0x6490 movb -0x25(%rbp), %al andb $0x1, %al addq $0x40, %rsp popq %rbp retq nopl (%rax)	/jhu-cisst[P]mechatronics-software/lib/code/FpgaIO.cpp
FpgaIO::ReadRTL8211F_Register(unsigned int, unsigned int, unsigned int, unsigned short&)	bool FpgaIO::ReadRTL8211F_Register(unsigned int chan, unsigned int phyAddr, unsigned int regAddr, uint16_t &data) { // Should have firmware/hardware checks // Wait for FPGA mdio interface to be idle if (!WaitRTL8211F_Idle("ReadRTL8211F_Register", chan, 20)) return false; nodeaddr_t address = 0x40a0 \| (chan << 8); // Format: 0110 PPPP PRRR RRXX X(16), where P indicates phyAddr, R indicates regAddr, X is don't care (0) uint32_t write_data = 0x60000000 \| ((phyAddr&0x1f) << 23) \| ((regAddr&0x1f) << 18); if (!port->WriteQuadlet(BoardId, address, write_data)) return false; // Read data is not valid unless FPGA mdio interface is in idle state. For most interfaces (e.g., Firewire, // Ethernet), this will already be the case, but the Zynq EMIO mmap interface is fast so some waiting is needed. // First, wait 1 millisecond Amp1394_Sleep(0.001); // Now, loop up to 20 times until mdio interface is idle and register address matches quadlet_t read_data; unsigned int regAddrRead; bool isIdle = false; bool regAddrMatch = false; unsigned int i = 0; while (!(isIdle && regAddrMatch) && (i++ < 20)) { if (port->ReadQuadlet(BoardId, address, read_data)) { isIdle = ((read_data&0x07000000) == 0); if (isIdle) { regAddrRead = (read_data & 0x001f0000)>>16; regAddrMatch = (regAddrRead == regAddr); } } } if (!isIdle) { std::cout << "ReadRTL8211F_Register timeout waiting for data, read " << std::hex << read_data << std::dec << std::endl; } else if (!regAddrMatch) { std::cout << "ReadRTL8211F_Register regAddr mismatch, expected " << std::hex << regAddr << ", received " << regAddrRead << std::dec << std::endl; } // Set data even if error, since it could be correct and caller may not check return value data = static_cast<uint16_t>(read_data & 0x0000ffff); return (isIdle & regAddrMatch); }	pushq %rbp movq %rsp, %rbp subq $0x60, %rsp movq %rdi, -0x10(%rbp) movl %esi, -0x14(%rbp) movl %edx, -0x18(%rbp) movl %ecx, -0x1c(%rbp) movq %r8, -0x28(%rbp) movq -0x10(%rbp), %rdi movq %rdi, -0x50(%rbp) movl -0x14(%rbp), %edx leaq 0x6244(%rip), %rsi # 0x2b57f movl $0x14, %ecx callq 0x251e0 testb $0x1, %al jne 0x25352 movb $0x0, -0x1(%rbp) jmp 0x2554b movq -0x50(%rbp), %rax movl -0x14(%rbp), %ecx shll $0x8, %ecx orl $0x40a0, %ecx # imm = 0x40A0 movl %ecx, %ecx movq %rcx, -0x30(%rbp) movl -0x18(%rbp), %ecx andl $0x1f, %ecx shll $0x17, %ecx orl $0x60000000, %ecx # imm = 0x60000000 movl -0x1c(%rbp), %edx andl $0x1f, %edx shll $0x12, %edx orl %edx, %ecx movl %ecx, -0x34(%rbp) movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movq -0x30(%rbp), %rdx movl -0x34(%rbp), %ecx movq (%rdi), %rax movzbl %sil, %esi callq 0x120(%rax) testb $0x1, %al jne 0x253ae movb $0x0, -0x1(%rbp) jmp 0x2554b movsd 0x374a(%rip), %xmm0 # 0x28b00 callq 0x14790 movb $0x0, -0x3d(%rbp) movb $0x0, -0x3e(%rbp) movl $0x0, -0x44(%rbp) testb $0x1, -0x3d(%rbp) je 0x253db xorl %eax, %eax testb $0x1, -0x3e(%rbp) movb %al, -0x51(%rbp) jne 0x253ef movl -0x44(%rbp), %eax movl %eax, %ecx addl $0x1, %ecx movl %ecx, -0x44(%rbp) cmpl $0x14, %eax setb %al movb %al, -0x51(%rbp) movb -0x51(%rbp), %al testb $0x1, %al jne 0x253f8 jmp 0x2545b movq -0x50(%rbp), %rax movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movq -0x30(%rbp), %rdx movq (%rdi), %rax leaq -0x38(%rbp), %rcx movzbl %sil, %esi callq 0x118(%rax) testb $0x1, %al jne 0x2541f jmp 0x25456 movl -0x38(%rbp), %eax andl $0x7000000, %eax # imm = 0x7000000 cmpl $0x0, %eax sete %al andb $0x1, %al movb %al, -0x3d(%rbp) testb $0x1, -0x3d(%rbp) je 0x25454 movl -0x38(%rbp), %eax andl $0x1f0000, %eax # imm = 0x1F0000 shrl $0x10, %eax movl %eax, -0x3c(%rbp) movl -0x3c(%rbp), %eax cmpl -0x1c(%rbp), %eax sete %al andb $0x1, %al movb %al, -0x3e(%rbp) jmp 0x25456 jmp 0x253ca testb $0x1, -0x3d(%rbp) jne 0x254ae movq 0x10b60(%rip), %rdi # 0x35fc8 leaq 0x6126(%rip), %rsi # 0x2b595 callq 0x6420 movq %rax, %rdi leaq -0x10dbe(%rip), %rsi # 0x146c0 callq 0x61f0 movq %rax, %rdi movl -0x38(%rbp), %esi callq 0x65d0 movq %rax, %rdi leaq -0x19858(%rip), %rsi # 0xbc40 callq 0x61f0 movq %rax, %rdi movq 0x10b09(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x2551b testb $0x1, -0x3e(%rbp) jne 0x25519 movq 0x10b0d(%rip), %rdi # 0x35fc8 leaq 0x6109(%rip), %rsi # 0x2b5cb callq 0x6420 movq %rax, %rdi leaq -0x10e11(%rip), %rsi # 0x146c0 callq 0x61f0 movq %rax, %rdi movl -0x1c(%rbp), %esi callq 0x65d0 movq %rax, %rdi leaq 0x6112(%rip), %rsi # 0x2b5fd callq 0x6420 movq %rax, %rdi movl -0x3c(%rbp), %esi callq 0x65d0 movq %rax, %rdi leaq -0x198c5(%rip), %rsi # 0xbc40 callq 0x61f0 movq %rax, %rdi movq 0x10a9c(%rip), %rsi # 0x35fb0 callq 0x6490 jmp 0x2551b movl -0x38(%rbp), %eax andl $0xffff, %eax # imm = 0xFFFF movw %ax, %cx movq -0x28(%rbp), %rax movw %cx, (%rax) movb -0x3d(%rbp), %al andb $0x1, %al movzbl %al, %eax movb -0x3e(%rbp), %cl andb $0x1, %cl movzbl %cl, %ecx andl %ecx, %eax cmpl $0x0, %eax setne %al andb $0x1, %al movb %al, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x60, %rsp popq %rbp retq nopw %cs:(%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/FpgaIO.cpp
FpgaIO::WriteEthernetPhyReset(unsigned int)	bool FpgaIO::WriteEthernetPhyReset(unsigned int chan) { quadlet_t write_data = ETH_CTRL_RESET_PHY; if (chan&1) write_data \|= ETH_PORT_CTRL_RESET_PHY; if (chan&2) write_data \|= (ETH_PORT_CTRL_RESET_PHY<<8); return WriteEthernetControl(write_data); }	pushq %rbp movq %rsp, %rbp subq $0x20, %rsp movq %rdi, -0x8(%rbp) movl %esi, -0xc(%rbp) movq -0x8(%rbp), %rax movq %rax, -0x18(%rbp) movl $0x4000000, -0x10(%rbp) # imm = 0x4000000 movl -0xc(%rbp), %eax andl $0x1, %eax cmpl $0x0, %eax je 0x256a4 movl -0x10(%rbp), %eax orl $0x80, %eax movl %eax, -0x10(%rbp) movl -0xc(%rbp), %eax andl $0x2, %eax cmpl $0x0, %eax je 0x256ba movl -0x10(%rbp), %eax orl $0x8000, %eax # imm = 0x8000 movl %eax, -0x10(%rbp) movq -0x18(%rbp), %rdi movl -0x10(%rbp), %esi callq 0x24d80 andb $0x1, %al addq $0x20, %rsp popq %rbp retq nop	/jhu-cisst[P]mechatronics-software/lib/code/FpgaIO.cpp
FpgaIO::ReadFirewireData(unsigned int*, unsigned int, unsigned int)	bool FpgaIO::ReadFirewireData(quadlet_t buffer, unsigned int offset, unsigned int nquads) { if (GetFirmwareVersion() < 5) return false; // Firmware currently cannot read more than 64 quadlets if (nquads > 64) return false; nodeaddr_t address = 0x5000 + offset; // ADDR_FW = 0x5000 bool ret = port->ReadBlock(BoardId, address, buffer, nquadssizeof(quadlet_t)); if (ret) { for (unsigned int i = 0; i < nquads; i++) buffer[i] = bswap_32(buffer[i]); } return ret; }	pushq %rbp movq %rsp, %rbp subq $0x40, %rsp movq %rdi, -0x10(%rbp) movq %rsi, -0x18(%rbp) movl %edx, -0x1c(%rbp) movl %ecx, -0x20(%rbp) movq -0x10(%rbp), %rdi movq %rdi, -0x38(%rbp) callq 0xdd60 cmpl $0x5, %eax jae 0x25841 movb $0x0, -0x1(%rbp) jmp 0x258d4 cmpl $0x40, -0x20(%rbp) jbe 0x25850 movb $0x0, -0x1(%rbp) jmp 0x258d4 movq -0x38(%rbp), %rax movl -0x1c(%rbp), %ecx addl $0x5000, %ecx # imm = 0x5000 movl %ecx, %ecx movq %rcx, -0x28(%rbp) movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movq -0x28(%rbp), %rdx movq -0x18(%rbp), %rcx movl -0x20(%rbp), %eax shlq $0x2, %rax movl %eax, %r8d movq (%rdi), %rax movzbl %sil, %esi callq *0x130(%rax) andb $0x1, %al movb %al, -0x29(%rbp) testb $0x1, -0x29(%rbp) je 0x258cc movl $0x0, -0x30(%rbp) movl -0x30(%rbp), %eax cmpl -0x20(%rbp), %eax jae 0x258ca movq -0x18(%rbp), %rax movl -0x30(%rbp), %ecx movl (%rax,%rcx,4), %edi callq 0x24870 movl %eax, %edx movq -0x18(%rbp), %rax movl -0x30(%rbp), %ecx movl %edx, (%rax,%rcx,4) movl -0x30(%rbp), %eax addl $0x1, %eax movl %eax, -0x30(%rbp) jmp 0x2589c jmp 0x258cc movb -0x29(%rbp), %al andb $0x1, %al movb %al, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x40, %rsp popq %rbp retq nop	/jhu-cisst[P]mechatronics-software/lib/code/FpgaIO.cpp
FpgaIO::ReadFirewirePhy(unsigned char, unsigned char&)	bool FpgaIO::ReadFirewirePhy(unsigned char addr, unsigned char &data) { if (addr > 15) { std::cout << "ReadFirewirePhy: invalid addr " << static_cast<unsigned int>(addr) << std::endl; return false; } quadlet_t write_data = addr; quadlet_t read_data = 0; if (!port->WriteQuadlet(BoardId, BoardIO::FW_PHY_REQ, write_data)) return false; if (!port->ReadQuadlet(BoardId, BoardIO::FW_PHY_RESP, read_data)) return false; // Register address in read response is bits 11-8 unsigned char read_addr = static_cast<unsigned char>(read_data>>8) & 0x0f; // Check that it matches the request address if (read_addr != addr) { std::cout << "ReadFirewirePhy: read addr " << static_cast<unsigned int>(read_addr) << ", expected " << static_cast<unsigned int>(addr) << std::endl; return false; } data = static_cast<unsigned char>(read_data); return true; }	pushq %rbp movq %rsp, %rbp subq $0x40, %rsp movb %sil, %al movq %rdi, -0x10(%rbp) movb %al, -0x11(%rbp) movq %rdx, -0x20(%rbp) movq -0x10(%rbp), %rax movq %rax, -0x38(%rbp) movzbl -0x11(%rbp), %eax cmpl $0xf, %eax jle 0x2593e movq 0x106ba(%rip), %rdi # 0x35fc8 leaq 0x5d0b(%rip), %rsi # 0x2b620 callq 0x6420 movq %rax, %rdi movzbl -0x11(%rbp), %esi callq 0x65d0 movq %rax, %rdi movq 0x10680(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x25a1f movq -0x38(%rbp), %rax movzbl -0x11(%rbp), %ecx movl %ecx, -0x24(%rbp) movl $0x0, -0x28(%rbp) movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movl -0x24(%rbp), %ecx movq (%rdi), %rax movl $0x1, %edx movzbl %sil, %esi callq 0x120(%rax) testb $0x1, %al jne 0x2597a movb $0x0, -0x1(%rbp) jmp 0x25a1f movq -0x38(%rbp), %rax movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movq (%rdi), %rax movl $0x2, %edx leaq -0x28(%rbp), %rcx movzbl %sil, %esi callq 0x118(%rax) testb $0x1, %al jne 0x259a6 movb $0x0, -0x1(%rbp) jmp 0x25a1f movl -0x28(%rbp), %eax shrl $0x8, %eax movzbl %al, %eax andl $0xf, %eax movb %al, -0x29(%rbp) movzbl -0x29(%rbp), %eax movzbl -0x11(%rbp), %ecx cmpl %ecx, %eax je 0x25a10 movq 0x10600(%rip), %rdi # 0x35fc8 leaq 0x5c70(%rip), %rsi # 0x2b63f callq 0x6420 movq %rax, %rdi movzbl -0x29(%rbp), %esi callq 0x65d0 movq %rax, %rdi leaq 0x5c07(%rip), %rsi # 0x2b5f1 callq 0x6420 movq %rax, %rdi movzbl -0x11(%rbp), %esi callq 0x65d0 movq %rax, %rdi movq 0x105ab(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x25a1f movl -0x28(%rbp), %eax movb %al, %cl movq -0x20(%rbp), %rax movb %cl, (%rax) movb $0x1, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x40, %rsp popq %rbp retq nopw (%rax,%rax)	/jhu-cisst[P]mechatronics-software/lib/code/FpgaIO.cpp
FpgaIO::WriteFirewirePhy(unsigned char, unsigned char)	bool FpgaIO::WriteFirewirePhy(unsigned char addr, unsigned char data) { if (addr > 15) { std::cout << "WriteFirewirePhy: invalid addr " << static_cast<unsigned int>(addr) << std::endl; return false; } // Set bit 12 to indicate write; addr in bits 11-8, data in bits 7-0 quadlet_t write_data = 0x00001000 \| static_cast<quadlet_t>(addr) << 8 \| static_cast<quadlet_t>(data); return port->WriteQuadlet(BoardId, BoardIO::FW_PHY_REQ, write_data); }	pushq %rbp movq %rsp, %rbp subq $0x20, %rsp movb %dl, %al movb %sil, %cl movq %rdi, -0x10(%rbp) movb %cl, -0x11(%rbp) movb %al, -0x12(%rbp) movq -0x10(%rbp), %rax movq %rax, -0x20(%rbp) movzbl -0x11(%rbp), %eax cmpl $0xf, %eax jle 0x25a8c movq 0x10569(%rip), %rdi # 0x35fc8 leaq 0x5bf5(%rip), %rsi # 0x2b65b callq 0x6420 movq %rax, %rdi movzbl -0x11(%rbp), %esi callq 0x65d0 movq %rax, %rdi movq 0x1052f(%rip), %rsi # 0x35fb0 callq 0x6490 movb $0x0, -0x1(%rbp) jmp 0x25ac8 movq -0x20(%rbp), %rax movzbl -0x11(%rbp), %ecx shll $0x8, %ecx orl $0x1000, %ecx # imm = 0x1000 movzbl -0x12(%rbp), %edx orl %edx, %ecx movl %ecx, -0x18(%rbp) movq 0x10(%rax), %rdi movb 0x8(%rax), %sil movl -0x18(%rbp), %ecx movq (%rdi), %rax movl $0x1, %edx movzbl %sil, %esi callq *0x120(%rax) andb $0x1, %al movb %al, -0x1(%rbp) movb -0x1(%rbp), %al andb $0x1, %al addq $0x20, %rsp popq %rbp retq nopw %cs:(%rax,%rax) nopl (%rax)	/jhu-cisst[P]mechatronics-software/lib/code/FpgaIO.cpp

Subsets and Splits

SQL Console for LLM4Binary/decompile-bench

Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.