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)
DERIVE... | 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... | /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)
DERIVE... | 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... | /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)
DERIVE... | 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... | /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)
DERIVE... | 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... | /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)
DERIVE... | 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... | /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)
DERIVE... | 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... | /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)
DERIVE... | 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... | /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)
DERIVE... | 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... | /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)
DERIVE... | 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... | /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)
DERIVE... | 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... | /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)
DERIVE... | 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... | /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)
DERIVE... | 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... | /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)
DERIVE... | 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... | /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)
DERIVE... | 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... | /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), %r... | /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 =... | 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
mov... | /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, ... | /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, ... | /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(createRandomi... | 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 0... | /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;
... | 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, ... | /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();
}
... | 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 # 0... | /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)
seria... | 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, ... | /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:... | 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-... | 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
mov... | /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, ... | /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=", ... | 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... | /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, 0x1... | /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
st... | 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
cm... | /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... | 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 $0... | /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 positi... | 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, 0... | /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 0xf5... | /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... | /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.numAssert... | 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... | /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... | 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
j... | /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
... | /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) {... | 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
mov... | /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,
... | 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 0... | /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 ... | /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;
}
... | 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... | /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... | 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... | /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()) st... | 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), ... | /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_... | 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<... | 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 %... | /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... | /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
ca... | /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 colle... | 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 ... | /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
m... | /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&0x4... | 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 # i... | /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 <... | 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), %... | /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... | 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 0xf8... | /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 %... | /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), %e... | /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 nu... | 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 %... | /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
le... | /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(Boar... | 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 $0... | /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;... | 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(%... | /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];
... | 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
... | /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... | 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 -0x... | /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 << "AmpI... | 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 # 0... | /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);
}
re... | 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
call... | /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() ... | 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(%... | /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->W... | 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(%rb... | /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... | 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 $0xff800... | /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... | 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 = 0... | /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 metho... | 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... | /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);
... | 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 0... | /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 f... | 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
m... | /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) retur... | 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
m... | /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::end... | 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 # ... | /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", "Undef... | 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 -... | /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 parame... | 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
... | /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 < Boar... | 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), %... | /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].updateTime*1e6;
... | 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 $... | /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),
IsAllBoard... | 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)
mo... | /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... | /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 st... | 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)... | /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;
IsAl... | 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 $0x... | /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));
... | 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 0x16c... | /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... | 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 # 0x298... | /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));... | 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,... | /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);
... | 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,... | /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 0x1a5... | /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;
... | 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(%rb... | /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... | 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 ==... | 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
call... | /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]
... | 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 %r... | /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;
... | 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 # 0x... | /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 << "Read... | 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 ... | /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 alloc... | 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, %ec... | /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 resul... | 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
m... | /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, IP... | 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... | /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.e... | 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
m... | /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_S... | 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... | /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... | 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 # 0... | /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 pro... | 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 # 0... | /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;
... | 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 = 0x90000... | /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;
... | 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... | /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 = 0x4... | 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 0x2... | /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(%rb... | /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-... | 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 0... | /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->W... | 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
mov... | /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
... | 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
cal... | /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.