name
string | code
string | asm
string | file
string |
|---|---|---|---|
void slang::ast::CheckerMemberVisitor::handle<slang::ast::ConcurrentAssertionStatement>(slang::ast::ConcurrentAssertionStatement const&)
|
void handle(const T& stmt) {
if (!currBlock)
return;
auto notAllowed = [&] {
auto& diag = body.addDiag(diag::InvalidStmtInChecker, stmt.sourceRange);
diag << SemanticFacts::getProcedureKindStr(currBlock->procedureKind);
};
auto checkTimed = [&] {
auto& timed = stmt.template as<TimedStatement>();
switch (timed.timing.kind) {
case TimingControlKind::Invalid:
case TimingControlKind::SignalEvent:
case TimingControlKind::EventList:
case TimingControlKind::ImplicitEvent:
return true;
default:
body.addDiag(diag::CheckerTimingControl, timed.sourceRange);
return false;
}
};
if (currBlock->procedureKind == ProceduralBlockKind::Initial) {
switch (stmt.kind) {
case StatementKind::Empty:
case StatementKind::List:
break;
case StatementKind::Timed:
if (!checkTimed())
return;
break;
case StatementKind::Block:
if (stmt.template as<BlockStatement>().blockKind !=
StatementBlockKind::Sequential) {
return notAllowed();
}
break;
case StatementKind::ImmediateAssertion:
case StatementKind::ConcurrentAssertion:
case StatementKind::ProceduralChecker:
return;
default:
return notAllowed();
}
}
else {
switch (stmt.kind) {
case StatementKind::Empty:
case StatementKind::List:
case StatementKind::Return:
case StatementKind::Continue:
case StatementKind::Break:
case StatementKind::Conditional:
case StatementKind::Case:
case StatementKind::ForLoop:
case StatementKind::RepeatLoop:
case StatementKind::ForeachLoop:
case StatementKind::WhileLoop:
case StatementKind::DoWhileLoop:
case StatementKind::ForeverLoop:
break;
case StatementKind::Timed:
if (!checkTimed())
return;
break;
case StatementKind::ExpressionStatement: {
auto& expr = stmt.template as<ExpressionStatement>().expr;
switch (expr.kind) {
case ExpressionKind::Call:
break;
case ExpressionKind::Assignment:
if (!expr.template as<AssignmentExpression>().isNonBlocking() &&
currBlock->procedureKind == ProceduralBlockKind::AlwaysFF) {
body.addDiag(diag::CheckerBlockingAssign, stmt.sourceRange);
return;
}
break;
default:
return notAllowed();
}
break;
}
case StatementKind::Block:
if (stmt.template as<BlockStatement>().blockKind !=
StatementBlockKind::Sequential) {
return notAllowed();
}
break;
case StatementKind::ImmediateAssertion:
case StatementKind::ConcurrentAssertion:
case StatementKind::ProceduralChecker:
return;
default:
return notAllowed();
}
}
visitDefault(stmt);
}
|
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1019d6
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movl 0x40(%rax), %ecx
movl (%rsi), %eax
testl %ecx, %ecx
je 0x1019d7
decl %eax
cmpl $0x1e, %eax
ja 0x101a2b
leaq 0x277889(%rip), %rdx # 0x379238
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0xfe77a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x101b52
addq $0x28, %rsp
popq %rbx
popq %r14
retq
cmpl $0x12, %eax
jle 0x101a17
leal -0x14(%rax), %ecx
cmpl $0x2, %ecx
jb 0x1019cf
cmpl $0x1f, %eax
je 0x1019cf
cmpl $0x13, %eax
jne 0x101a37
movq 0x20(%r14), %rax
movl (%rax), %eax
cmpl $0x4, %eax
ja 0x1019fe
cmpl $0x1, %eax
jne 0x1019b8
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
movl $0x180006, %esi # imm = 0x180006
jmp 0x101aaa
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x1019b8
cmpl $0x3, %eax
jne 0x101a37
cmpl $0x0, 0x30(%r14)
je 0x1019b8
leaq 0x8(%rsp), %rdi
callq 0x101b0c
jmp 0x1019cf
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
movl $0x670006, %esi # imm = 0x670006
callq 0x1ecb9a
movq %rax, %r14
movq 0x8(%rbx), %rax
movl 0x40(%rax), %edi
callq 0x1f4288
movq %r14, %rdi
movq %rax, %rsi
callq 0x83e5c
jmp 0x1019cf
movq 0x20(%r14), %rax
movl (%rax), %edx
cmpl $0x15, %edx
je 0x1019b8
cmpl $0xe, %edx
jne 0x101a2b
cmpl $0x5, %ecx
jne 0x1019b8
cmpb $0x0, 0x50(%rax)
jne 0x1019b8
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
movl $0x100006, %esi # imm = 0x100006
callq 0x1ecb9a
jmp 0x1019cf
leaq 0x18(%rsp), %rdi
callq 0x101acc
testb %al, %al
je 0x1019cf
jmp 0x1019b8
nop
|
/MikePopoloski[P]slang/source/ast/symbols/InstanceSymbols.cpp
|
void slang::ast::CheckerMemberVisitor::handle<slang::ast::DisableForkStatement>(slang::ast::DisableForkStatement const&)
|
void handle(const T& stmt) {
if (!currBlock)
return;
auto notAllowed = [&] {
auto& diag = body.addDiag(diag::InvalidStmtInChecker, stmt.sourceRange);
diag << SemanticFacts::getProcedureKindStr(currBlock->procedureKind);
};
auto checkTimed = [&] {
auto& timed = stmt.template as<TimedStatement>();
switch (timed.timing.kind) {
case TimingControlKind::Invalid:
case TimingControlKind::SignalEvent:
case TimingControlKind::EventList:
case TimingControlKind::ImplicitEvent:
return true;
default:
body.addDiag(diag::CheckerTimingControl, timed.sourceRange);
return false;
}
};
if (currBlock->procedureKind == ProceduralBlockKind::Initial) {
switch (stmt.kind) {
case StatementKind::Empty:
case StatementKind::List:
break;
case StatementKind::Timed:
if (!checkTimed())
return;
break;
case StatementKind::Block:
if (stmt.template as<BlockStatement>().blockKind !=
StatementBlockKind::Sequential) {
return notAllowed();
}
break;
case StatementKind::ImmediateAssertion:
case StatementKind::ConcurrentAssertion:
case StatementKind::ProceduralChecker:
return;
default:
return notAllowed();
}
}
else {
switch (stmt.kind) {
case StatementKind::Empty:
case StatementKind::List:
case StatementKind::Return:
case StatementKind::Continue:
case StatementKind::Break:
case StatementKind::Conditional:
case StatementKind::Case:
case StatementKind::ForLoop:
case StatementKind::RepeatLoop:
case StatementKind::ForeachLoop:
case StatementKind::WhileLoop:
case StatementKind::DoWhileLoop:
case StatementKind::ForeverLoop:
break;
case StatementKind::Timed:
if (!checkTimed())
return;
break;
case StatementKind::ExpressionStatement: {
auto& expr = stmt.template as<ExpressionStatement>().expr;
switch (expr.kind) {
case ExpressionKind::Call:
break;
case ExpressionKind::Assignment:
if (!expr.template as<AssignmentExpression>().isNonBlocking() &&
currBlock->procedureKind == ProceduralBlockKind::AlwaysFF) {
body.addDiag(diag::CheckerBlockingAssign, stmt.sourceRange);
return;
}
break;
default:
return notAllowed();
}
break;
}
case StatementKind::Block:
if (stmt.template as<BlockStatement>().blockKind !=
StatementBlockKind::Sequential) {
return notAllowed();
}
break;
case StatementKind::ImmediateAssertion:
case StatementKind::ConcurrentAssertion:
case StatementKind::ProceduralChecker:
return;
default:
return notAllowed();
}
}
visitDefault(stmt);
}
|
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x101cba
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movl 0x40(%rax), %eax
movl (%rsi), %ecx
testl %eax, %eax
je 0x101c1a
decl %ecx
cmpl $0x1e, %ecx
ja 0x101c68
leaq 0x2776e0(%rip), %rdx # 0x3792b4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x20(%rsi), %rcx
movl (%rcx), %edx
cmpl $0x15, %edx
je 0x101cb3
cmpl $0xe, %edx
jne 0x101c68
cmpl $0x5, %eax
jne 0x101cb3
cmpb $0x0, 0x50(%rcx)
jne 0x101cb3
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rcx
movl $0x100006, %esi # imm = 0x100006
jmp 0x101c5b
cmpl $0x1f, %ecx
ja 0x101c74
movl $0x80300006, %eax # imm = 0x80300006
btl %ecx, %eax
jb 0x101cb3
cmpl $0x3, %ecx
je 0x101c62
cmpl $0x13, %ecx
jne 0x101c74
movq 0x20(%rsi), %rax
movl (%rax), %eax
cmpl $0x4, %eax
ja 0x101c47
cmpl $0x1, %eax
jne 0x101cb3
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rcx
movl $0x180006, %esi # imm = 0x180006
callq 0x1ecb9a
jmp 0x101cb3
cmpl $0x0, 0x30(%rsi)
je 0x101cb3
leaq 0x8(%rsp), %rdi
callq 0x101cfc
jmp 0x101cb3
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rcx
movl $0x670006, %esi # imm = 0x670006
callq 0x1ecb9a
movq %rax, %r14
movq 0x8(%rbx), %rax
movl 0x40(%rax), %edi
callq 0x1f4288
movq %r14, %rdi
movq %rax, %rsi
callq 0x83e5c
jmp 0x101cb3
leaq 0x18(%rsp), %rdi
callq 0x101cbc
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/InstanceSymbols.cpp
|
void slang::ast::ASTVisitor<slang::ast::CheckerMemberVisitor, true, true, false, false>::visitDefault<slang::ast::GenvarSymbol>(slang::ast::GenvarSymbol const&)
|
void visitDefault(const T& t) {
if constexpr (VisitExpressions && HasVisitExprs<T, TDerived>) {
t.visitExprs(DERIVED);
}
else if constexpr (VisitExpressions && std::is_base_of_v<Symbol, T>) {
if (auto declaredType = t.getDeclaredType()) {
if (auto init = declaredType->getInitializer())
init->visit(DERIVED);
}
}
if constexpr (VisitStatements && requires { t.visitStmts(DERIVED); }) {
t.visitStmts(DERIVED);
}
if constexpr (std::is_base_of_v<GenericClassDefSymbol, T>) {
for (auto&& spec : t.specializations())
spec.visit(DERIVED);
}
if constexpr (std::is_base_of_v<Scope, T>) {
for (auto& member : t.members())
member.visit(DERIVED);
}
if constexpr (std::is_same_v<InstanceSymbol, T>) {
if constexpr (VisitCanonical) {
const auto& body = t.getCanonicalBody() ? *t.getCanonicalBody() : t.body;
body.visit(DERIVED);
}
else {
t.body.visit(DERIVED);
}
}
if constexpr (std::is_same_v<CheckerInstanceSymbol, T>) {
t.body.visit(DERIVED);
}
}
|
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x200dae
testq %rax, %rax
je 0x10312f
movq %rax, %rdi
callq 0x15bc4e
testq %rax, %rax
je 0x10312f
movq %rax, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
jmp 0xfda5e
popq %rbx
retq
nop
|
/MikePopoloski[P]slang/source/../include/slang/ast/ASTVisitor.h
|
void slang::ast::ASTVisitor<slang::ast::CheckerMemberVisitor, true, true, false, false>::visitDefault<slang::ast::ElabSystemTaskSymbol>(slang::ast::ElabSystemTaskSymbol const&)
|
void visitDefault(const T& t) {
if constexpr (VisitExpressions && HasVisitExprs<T, TDerived>) {
t.visitExprs(DERIVED);
}
else if constexpr (VisitExpressions && std::is_base_of_v<Symbol, T>) {
if (auto declaredType = t.getDeclaredType()) {
if (auto init = declaredType->getInitializer())
init->visit(DERIVED);
}
}
if constexpr (VisitStatements && requires { t.visitStmts(DERIVED); }) {
t.visitStmts(DERIVED);
}
if constexpr (std::is_base_of_v<GenericClassDefSymbol, T>) {
for (auto&& spec : t.specializations())
spec.visit(DERIVED);
}
if constexpr (std::is_base_of_v<Scope, T>) {
for (auto& member : t.members())
member.visit(DERIVED);
}
if constexpr (std::is_same_v<InstanceSymbol, T>) {
if constexpr (VisitCanonical) {
const auto& body = t.getCanonicalBody() ? *t.getCanonicalBody() : t.body;
body.visit(DERIVED);
}
else {
t.body.visit(DERIVED);
}
}
if constexpr (std::is_same_v<CheckerInstanceSymbol, T>) {
t.body.visit(DERIVED);
}
}
|
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x200dae
testq %rax, %rax
je 0x10315f
movq %rax, %rdi
callq 0x15bc4e
testq %rax, %rax
je 0x10315f
movq %rax, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
jmp 0xfda5e
popq %rbx
retq
nop
|
/MikePopoloski[P]slang/source/../include/slang/ast/ASTVisitor.h
|
void slang::ast::ASTVisitor<slang::ast::CheckerMemberVisitor, true, true, false, false>::visitDefault<slang::ast::PrimitivePortSymbol>(slang::ast::PrimitivePortSymbol const&)
|
void visitDefault(const T& t) {
if constexpr (VisitExpressions && HasVisitExprs<T, TDerived>) {
t.visitExprs(DERIVED);
}
else if constexpr (VisitExpressions && std::is_base_of_v<Symbol, T>) {
if (auto declaredType = t.getDeclaredType()) {
if (auto init = declaredType->getInitializer())
init->visit(DERIVED);
}
}
if constexpr (VisitStatements && requires { t.visitStmts(DERIVED); }) {
t.visitStmts(DERIVED);
}
if constexpr (std::is_base_of_v<GenericClassDefSymbol, T>) {
for (auto&& spec : t.specializations())
spec.visit(DERIVED);
}
if constexpr (std::is_base_of_v<Scope, T>) {
for (auto& member : t.members())
member.visit(DERIVED);
}
if constexpr (std::is_same_v<InstanceSymbol, T>) {
if constexpr (VisitCanonical) {
const auto& body = t.getCanonicalBody() ? *t.getCanonicalBody() : t.body;
body.visit(DERIVED);
}
else {
t.body.visit(DERIVED);
}
}
if constexpr (std::is_same_v<CheckerInstanceSymbol, T>) {
t.body.visit(DERIVED);
}
}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x40(%rsi), %rdi
callq 0x15bc4e
testq %rax, %rax
je 0x103591
movq %rax, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
jmp 0xfda5e
popq %rbx
retq
nop
|
/MikePopoloski[P]slang/source/../include/slang/ast/ASTVisitor.h
|
void slang::ast::CoverageBinSymbol::TransRangeList::visitExprs<slang::ast::CheckerMemberVisitor&>(slang::ast::CheckerMemberVisitor&) const
|
void visitExprs(TVisitor&& visitor) const {
for (auto item : items)
item->visit(visitor);
if (repeatFrom)
repeatFrom->visit(visitor);
if (repeatTo)
repeatTo->visit(visitor);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x103f92
movq (%r14), %r12
shlq $0x3, %r15
xorl %r13d, %r13d
movq (%r12,%r13), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
callq 0xfda5e
addq $0x8, %r13
cmpq %r13, %r15
jne 0x103f7a
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x103fa6
movq %rdi, %rsi
movq %rbx, %rdx
callq 0xfda5e
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x103fc3
movq %rdi, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xfda5e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/MikePopoloski[P]slang/source/../include/slang/ast/symbols/CoverSymbols.h
|
void slang::ast::ASTVisitor<slang::ast::CheckerMemberVisitor, true, true, false, false>::visitDefault<slang::ast::TimingPathSymbol>(slang::ast::TimingPathSymbol const&)
|
void visitDefault(const T& t) {
if constexpr (VisitExpressions && HasVisitExprs<T, TDerived>) {
t.visitExprs(DERIVED);
}
else if constexpr (VisitExpressions && std::is_base_of_v<Symbol, T>) {
if (auto declaredType = t.getDeclaredType()) {
if (auto init = declaredType->getInitializer())
init->visit(DERIVED);
}
}
if constexpr (VisitStatements && requires { t.visitStmts(DERIVED); }) {
t.visitStmts(DERIVED);
}
if constexpr (std::is_base_of_v<GenericClassDefSymbol, T>) {
for (auto&& spec : t.specializations())
spec.visit(DERIVED);
}
if constexpr (std::is_base_of_v<Scope, T>) {
for (auto& member : t.members())
member.visit(DERIVED);
}
if constexpr (std::is_same_v<InstanceSymbol, T>) {
if constexpr (VisitCanonical) {
const auto& body = t.getCanonicalBody() ? *t.getCanonicalBody() : t.body;
body.visit(DERIVED);
}
else {
t.body.visit(DERIVED);
}
}
if constexpr (std::is_same_v<CheckerInstanceSymbol, T>) {
t.body.visit(DERIVED);
}
}
|
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x200dae
testq %rax, %rax
je 0x1040c5
movq %rax, %rdi
callq 0x15bc4e
testq %rax, %rax
je 0x1040c5
movq %rax, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
jmp 0xfda5e
popq %rbx
retq
nop
|
/MikePopoloski[P]slang/source/../include/slang/ast/ASTVisitor.h
|
void slang::ast::ASTVisitor<slang::ast::CheckerMemberVisitor, true, true, false, false>::visitDefault<slang::ast::FixedSizeUnpackedArrayType>(slang::ast::FixedSizeUnpackedArrayType const&)
|
void visitDefault(const T& t) {
if constexpr (VisitExpressions && HasVisitExprs<T, TDerived>) {
t.visitExprs(DERIVED);
}
else if constexpr (VisitExpressions && std::is_base_of_v<Symbol, T>) {
if (auto declaredType = t.getDeclaredType()) {
if (auto init = declaredType->getInitializer())
init->visit(DERIVED);
}
}
if constexpr (VisitStatements && requires { t.visitStmts(DERIVED); }) {
t.visitStmts(DERIVED);
}
if constexpr (std::is_base_of_v<GenericClassDefSymbol, T>) {
for (auto&& spec : t.specializations())
spec.visit(DERIVED);
}
if constexpr (std::is_base_of_v<Scope, T>) {
for (auto& member : t.members())
member.visit(DERIVED);
}
if constexpr (std::is_same_v<InstanceSymbol, T>) {
if constexpr (VisitCanonical) {
const auto& body = t.getCanonicalBody() ? *t.getCanonicalBody() : t.body;
body.visit(DERIVED);
}
else {
t.body.visit(DERIVED);
}
}
if constexpr (std::is_same_v<CheckerInstanceSymbol, T>) {
t.body.visit(DERIVED);
}
}
|
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x200dae
testq %rax, %rax
je 0x104387
movq %rax, %rdi
callq 0x15bc4e
testq %rax, %rax
je 0x104387
movq %rax, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
jmp 0xfda5e
popq %rbx
retq
nop
|
/MikePopoloski[P]slang/source/../include/slang/ast/ASTVisitor.h
|
void slang::ast::ASTVisitor<slang::ast::CheckerMemberVisitor, true, true, false, false>::visitDefault<slang::ast::DPIOpenArrayType>(slang::ast::DPIOpenArrayType const&)
|
void visitDefault(const T& t) {
if constexpr (VisitExpressions && HasVisitExprs<T, TDerived>) {
t.visitExprs(DERIVED);
}
else if constexpr (VisitExpressions && std::is_base_of_v<Symbol, T>) {
if (auto declaredType = t.getDeclaredType()) {
if (auto init = declaredType->getInitializer())
init->visit(DERIVED);
}
}
if constexpr (VisitStatements && requires { t.visitStmts(DERIVED); }) {
t.visitStmts(DERIVED);
}
if constexpr (std::is_base_of_v<GenericClassDefSymbol, T>) {
for (auto&& spec : t.specializations())
spec.visit(DERIVED);
}
if constexpr (std::is_base_of_v<Scope, T>) {
for (auto& member : t.members())
member.visit(DERIVED);
}
if constexpr (std::is_same_v<InstanceSymbol, T>) {
if constexpr (VisitCanonical) {
const auto& body = t.getCanonicalBody() ? *t.getCanonicalBody() : t.body;
body.visit(DERIVED);
}
else {
t.body.visit(DERIVED);
}
}
if constexpr (std::is_same_v<CheckerInstanceSymbol, T>) {
t.body.visit(DERIVED);
}
}
|
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x200dae
testq %rax, %rax
je 0x1043e7
movq %rax, %rdi
callq 0x15bc4e
testq %rax, %rax
je 0x1043e7
movq %rax, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
jmp 0xfda5e
popq %rbx
retq
nop
|
/MikePopoloski[P]slang/source/../include/slang/ast/ASTVisitor.h
|
void slang::ast::ASTVisitor<slang::ast::CheckerMemberVisitor, true, true, false, false>::visitDefault<slang::ast::UnpackedUnionType>(slang::ast::UnpackedUnionType const&)
|
void visitDefault(const T& t) {
if constexpr (VisitExpressions && HasVisitExprs<T, TDerived>) {
t.visitExprs(DERIVED);
}
else if constexpr (VisitExpressions && std::is_base_of_v<Symbol, T>) {
if (auto declaredType = t.getDeclaredType()) {
if (auto init = declaredType->getInitializer())
init->visit(DERIVED);
}
}
if constexpr (VisitStatements && requires { t.visitStmts(DERIVED); }) {
t.visitStmts(DERIVED);
}
if constexpr (std::is_base_of_v<GenericClassDefSymbol, T>) {
for (auto&& spec : t.specializations())
spec.visit(DERIVED);
}
if constexpr (std::is_base_of_v<Scope, T>) {
for (auto& member : t.members())
member.visit(DERIVED);
}
if constexpr (std::is_same_v<InstanceSymbol, T>) {
if constexpr (VisitCanonical) {
const auto& body = t.getCanonicalBody() ? *t.getCanonicalBody() : t.body;
body.visit(DERIVED);
}
else {
t.body.visit(DERIVED);
}
}
if constexpr (std::is_same_v<CheckerInstanceSymbol, T>) {
t.body.visit(DERIVED);
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x200dae
testq %rax, %rax
je 0x1045a8
movq %rax, %rdi
callq 0x15bc4e
testq %rax, %rax
je 0x1045a8
movq %rax, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xfda5e
cmpl $0x0, 0x70(%r14)
je 0x1045b8
leaq 0x48(%r14), %rdi
callq 0x1eeaba
movq 0x60(%r14), %r14
testq %r14, %r14
je 0x1045d2
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfb6f2
movq 0x28(%r14), %r14
jmp 0x1045bc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/MikePopoloski[P]slang/source/../include/slang/ast/ASTVisitor.h
|
void slang::ast::ASTVisitor<slang::ast::CheckerMemberVisitor, true, true, false, false>::visitDefault<slang::ast::VirtualInterfaceType>(slang::ast::VirtualInterfaceType const&)
|
void visitDefault(const T& t) {
if constexpr (VisitExpressions && HasVisitExprs<T, TDerived>) {
t.visitExprs(DERIVED);
}
else if constexpr (VisitExpressions && std::is_base_of_v<Symbol, T>) {
if (auto declaredType = t.getDeclaredType()) {
if (auto init = declaredType->getInitializer())
init->visit(DERIVED);
}
}
if constexpr (VisitStatements && requires { t.visitStmts(DERIVED); }) {
t.visitStmts(DERIVED);
}
if constexpr (std::is_base_of_v<GenericClassDefSymbol, T>) {
for (auto&& spec : t.specializations())
spec.visit(DERIVED);
}
if constexpr (std::is_base_of_v<Scope, T>) {
for (auto& member : t.members())
member.visit(DERIVED);
}
if constexpr (std::is_same_v<InstanceSymbol, T>) {
if constexpr (VisitCanonical) {
const auto& body = t.getCanonicalBody() ? *t.getCanonicalBody() : t.body;
body.visit(DERIVED);
}
else {
t.body.visit(DERIVED);
}
}
if constexpr (std::is_same_v<CheckerInstanceSymbol, T>) {
t.body.visit(DERIVED);
}
}
|
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x200dae
testq %rax, %rax
je 0x10489f
movq %rax, %rdi
callq 0x15bc4e
testq %rax, %rax
je 0x10489f
movq %rax, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
jmp 0xfda5e
popq %rbx
retq
nop
|
/MikePopoloski[P]slang/source/../include/slang/ast/ASTVisitor.h
|
slang::syntax::SeparatedSyntaxList<slang::syntax::PortConnectionSyntax>* slang::BumpAllocator::emplace<slang::syntax::SeparatedSyntaxList<slang::syntax::PortConnectionSyntax>, slang::syntax::SeparatedSyntaxList<slang::syntax::PortConnectionSyntax> const&>(slang::syntax::SeparatedSyntaxList<slang::syntax::PortConnectionSyntax> const&)
|
T* emplace(Args&&... args) {
static_assert(std::is_trivially_destructible_v<T>);
return new (allocate(sizeof(T), alignof(T))) T(std::forward<Args>(args)...);
}
|
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rcx
movq 0x8(%rcx), %rax
addq $0x7, %rax
andq $-0x8, %rax
leaq 0x38(%rax), %rdx
cmpq 0x8(%rdi), %rdx
jbe 0x104aec
movl $0x38, %esi
movl $0x8, %edx
callq 0xd7432
jmp 0x104af0
movq %rdx, 0x8(%rcx)
movq 0x18(%rbx), %rcx
movq %rcx, 0x18(%rax)
movups 0x8(%rbx), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x20(%rbx), %rcx
movq %rcx, 0x20(%rax)
leaq 0x3c2fa1(%rip), %rcx # 0x4c7ab0
movq %rcx, (%rax)
movups 0x28(%rbx), %xmm0
movups %xmm0, 0x28(%rax)
popq %rbx
retq
|
/MikePopoloski[P]slang/source/../include/slang/util/BumpAllocator.h
|
boost::unordered::detail::foa::table_locator<boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, std::pair<slang::ast::Symbol const* const, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>> boost::unordered::detail::foa::table_core<boost::unordered::detail::foa::flat_map_types<slang::ast::Symbol const*, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>, 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::ast::Symbol const*, void>, std::equal_to<slang::ast::Symbol const*>, std::allocator<std::pair<slang::ast::Symbol const* const, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>>>::nosize_unchecked_emplace_at<std::pair<slang::ast::Symbol const*&&, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>&&>>(boost::unordered::detail::foa::table_arrays<std::pair<slang::ast::Symbol const* const, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::pow2_size_policy, std::allocator<std::pair<slang::ast::Symbol const* const, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>>> const&, unsigned long, unsigned long, std::pair<slang::ast::Symbol const*&&, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>&&>&&)
|
locator nosize_unchecked_emplace_at(const arrays_type& arrays_, std::size_t pos0,
std::size_t hash, Args&&... args) {
for (prober pb(pos0);; pb.next(arrays_.groups_size_mask)) {
auto pos = pb.get();
auto pg = arrays_.groups() + pos;
auto mask = pg->match_available();
if (BOOST_LIKELY(mask != 0)) {
auto n = unchecked_countr_zero(mask);
auto p = arrays_.elements() + pos * N + n;
construct_element(p, std::forward<Args>(args)...);
pg->set(n, hash);
BOOST_UNORDERED_ADD_STATS(cstats.insertion, (pb.length()));
return {pg, n, p};
}
else
pg->mark_overflow(hash);
}
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rsi
movq %rdi, %rax
movq 0x10(%rdx), %rdi
shlq $0x4, %rcx
pxor %xmm0, %xmm0
movdqa (%rdi,%rcx), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %ebp
andl $0x7fff, %ebp # imm = 0x7FFF
je 0x106169
addq %rcx, %rdi
movq %rdi, %rcx
bsfl %ebp, %edi
imulq $0x438, %rsi, %rsi # imm = 0x438
addq 0x18(%rdx), %rsi
leaq (%rdi,%rdi,8), %rdx
leaq (%rsi,%rdx,8), %rdx
movq (%r9), %rsi
movq (%rsi), %rsi
movq %rsi, (%rdx)
movq 0x8(%r9), %rsi
movq 0x30(%rsi), %r9
movq %r9, 0x38(%rdx)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups %xmm2, 0x28(%rdx)
movups %xmm1, 0x18(%rdx)
movups %xmm0, 0x8(%rdx)
movq 0x38(%rsi), %rsi
movq %rsi, 0x40(%rdx)
movzbl %r8b, %esi
leaq 0x26a5ce(%rip), %r8 # 0x370720
movb (%r8,%rsi,4), %sil
movb %sil, (%rcx,%rdi)
movq %rcx, (%rax)
movl %edi, 0x8(%rax)
movq %rdx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
movl %r8d, %ecx
andb $0x7, %cl
movb $0x1, %r10b
shlb %cl, %r10b
movq 0x8(%rdx), %r11
movl $0x1, %ebx
movq %rsi, %rcx
shlq $0x4, %rcx
orb %r10b, 0xf(%rdi,%rcx)
addq %rbx, %rsi
andq %r11, %rsi
movq %rsi, %r14
shlq $0x4, %r14
leaq (%rdi,%r14), %rcx
movdqa (%rdi,%r14), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %ebp
andl $0x7fff, %ebp # imm = 0x7FFF
incq %rbx
testl %ebp, %ebp
jne 0x1060fd
jmp 0x10617e
|
/MikePopoloski[P]slang/source/../external/boost_unordered.hpp
|
decltype(fp0(nullptr, 0, nullptr), (void)()) boost::unordered::detail::foa::table_core<boost::unordered::detail::foa::flat_map_types<slang::ast::Symbol const*, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>, 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::ast::Symbol const*, void>, std::equal_to<slang::ast::Symbol const*>, std::allocator<std::pair<slang::ast::Symbol const* const, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>>>::for_all_elements_while<boost::unordered::detail::foa::table_core<boost::unordered::detail::foa::flat_map_types<slang::ast::Symbol const*, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>, 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::ast::Symbol const*, void>, std::equal_to<slang::ast::Symbol const*>, std::allocator<std::pair<slang::ast::Symbol const* const, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>>>::unchecked_rehash(boost::unordered::detail::foa::table_arrays<std::pair<slang::ast::Symbol const* const, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::pow2_size_policy, std::allocator<std::pair<slang::ast::Symbol const* const, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>>>&)::'lambda'(boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>*, unsigned int, std::pair<slang::ast::Symbol const* const, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>*)>(boost::unordered::detail::foa::table_arrays<std::pair<slang::ast::Symbol const* const, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::pow2_size_policy, std::allocator<std::pair<slang::ast::Symbol const* const, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>>> const&, boost::unordered::detail::foa::table_core<boost::unordered::detail::foa::flat_map_types<slang::ast::Symbol const*, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>, 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::ast::Symbol const*, void>, std::equal_to<slang::ast::Symbol const*>, std::allocator<std::pair<slang::ast::Symbol const* const, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>>>::unchecked_rehash(boost::unordered::detail::foa::table_arrays<std::pair<slang::ast::Symbol const* const, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::pow2_size_policy, std::allocator<std::pair<slang::ast::Symbol const* const, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>>>&)::'lambda'(boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>*, unsigned int, std::pair<slang::ast::Symbol const* const, std::tuple<slang::syntax::PropertyExprSyntax const*, slang::ast::ASTContext>>*))
|
static auto for_all_elements_while(const arrays_type& arrays_, F f)
-> decltype(f(nullptr, 0, nullptr), bool()) {
auto p = arrays_.elements();
if (p) {
for (auto pg = arrays_.groups(), last = pg + arrays_.groups_size_mask + 1; pg != last;
++pg, p += N) {
auto mask = match_really_occupied(pg, last);
while (mask) {
auto n = unchecked_countr_zero(mask);
if (!f(pg, n, p + n))
return false;
mask &= mask - 1;
}
}
}
return true;
}
|
movb $0x1, %al
cmpq $0x0, 0x18(%rdi)
je 0x106295
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdi
shlq $0x4, %rcx
leaq (%rdi,%rcx), %r8
addq $0x10, %r8
cmpq %r8, %rdi
je 0x106295
pushq %rbx
addq %rdi, %rcx
pxor %xmm0, %xmm0
leaq 0x26a92b(%rip), %r8 # 0x370b20
movaps 0x26a3d4(%rip), %xmm1 # 0x3705d0
movdqa (%rdi), %xmm2
pcmpeqb %xmm0, %xmm2
pmovmskb %xmm2, %r9d
notl %r9d
xorl %r10d, %r10d
cmpq %rdi, %rcx
setne %r10b
shll $0xe, %r10d
orl $0x3fff, %r10d # imm = 0x3FFF
andl %r9d, %r10d
movzwl %r10w, %r9d
testl %r9d, %r9d
je 0x106280
bsfl %r9d, %r10d
leaq (%rdi,%r10), %r11
movzbl (%rdi,%r10), %ebx
orq $0xf, %r11
andl $0x7, %ebx
movb (%rbx,%r8), %bl
andb (%r11), %bl
negb %bl
movl $0x0, %r11d
sbbq %r11, %r11
movq %r11, %xmm2
shufps $0xe4, %xmm1, %xmm2 # xmm2 = xmm2[0,1],xmm1[2,3]
movb $0x0, (%rdi,%r10)
movdqu 0x20(%rsi), %xmm3
paddq %xmm2, %xmm3
movdqu %xmm3, 0x20(%rsi)
leal -0x1(%r9), %r10d
andl %r9d, %r10d
decq (%rdx)
movl %r10d, %r9d
jne 0x106228
jmp 0x106292
leaq 0x10(%rdi), %r9
cmpq %rdi, %rcx
movq %r9, %rdi
jne 0x1061fc
jmp 0x106294
xorl %eax, %eax
popq %rbx
retq
|
/MikePopoloski[P]slang/source/../external/boost_unordered.hpp
|
slang::ast::CheckerInstanceSymbol::Connection* slang::SmallVectorBase<slang::ast::CheckerInstanceSymbol::Connection>::emplaceRealloc<slang::ast::CheckerInstanceBodySymbol&, slang::ast::Symbol const&, slang::syntax::ExpressionSyntax const*&, std::span<slang::ast::AttributeSymbol const* const, 18446744073709551615ul>&>(slang::ast::CheckerInstanceSymbol::Connection*, slang::ast::CheckerInstanceBodySymbol&, slang::ast::Symbol const&, slang::syntax::ExpressionSyntax const*&, std::span<slang::ast::AttributeSymbol const* const, 18446744073709551615ul>&)
|
typename SmallVectorBase<T>::pointer SmallVectorBase<T>::emplaceRealloc(const pointer pos,
Args&&... args) {
if (len == max_size())
detail::throwLengthError();
auto newCap = calculateGrowth(len + 1);
auto offset = static_cast<size_type>(pos - begin());
auto newData = (pointer)::operator new(newCap * sizeof(T));
// First construct the new element in the new memory,
// so that we don't corrupt the new element if it relied on
// existing elements we're about to move around.
auto newPos = newData + offset;
new (newPos) T(std::forward<Args>(args)...);
// Now move elements to the new memory.
if (pos == end()) {
std::uninitialized_move(begin(), end(), newData);
}
else {
std::uninitialized_move(begin(), pos, newData);
std::uninitialized_move(pos, end(), newPos + 1);
}
cleanup();
len++;
cap = newCap;
data_ = newData;
return newPos;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %rcx, (%rsp)
movq %rdx, 0x8(%rsp)
movabsq $0x1c71c71c71c71c7, %rax # imm = 0x1C71C71C71C71C7
movq 0x8(%rdi), %r13
cmpq %rax, %r13
je 0x10642b
movq %r8, %r12
movq %rsi, %r14
movq %rdi, %rbx
incq %r13
movq 0x10(%rdi), %rcx
movq %rax, %rdx
subq %rcx, %rdx
leaq (%rcx,%rcx), %rsi
cmpq %r13, %rsi
cmovaq %rsi, %r13
cmpq %rdx, %rcx
cmovaq %rax, %r13
movq %r14, %rbp
subq (%rdi), %rbp
leaq (,%r13,8), %rax
leaq (%rax,%rax,8), %rdi
callq 0xe17d4
movq %rax, %r15
movq %rax, %r9
movq (%r12), %rax
movq 0x10(%rsp), %rcx
movups (%rcx), %xmm0
movq 0x8(%rsp), %rcx
movq %rcx, (%r15,%rbp)
movq (%rsp), %rcx
movq %rcx, 0x8(%r15,%rbp)
movq $0x0, 0x10(%r15,%rbp)
xorl %ecx, %ecx
movb %cl, 0x18(%r15,%rbp)
movups %xmm0, 0x20(%r15,%rbp)
movq %rax, 0x30(%r15,%rbp)
movb %cl, 0x40(%r15,%rbp)
movq (%rbx), %r10
movq 0x8(%rbx), %r12
leaq (%r12,%r12,8), %rax
leaq (%r10,%rax,8), %rax
subq %r14, %rax
je 0x1063c7
cmpq %r14, %r10
je 0x106386
movq %r9, %rdx
movq %r10, %r8
movl $0x9, %ecx
movq %rdx, %rdi
movq %r8, %rsi
rep movsq (%rsi), %es:(%rdi)
addq $0x48, %r8
addq $0x48, %rdx
cmpq %r14, %r8
jne 0x10636b
leaq (%r15,%rbp), %rdi
addq $0x48, %rdi
addq $-0x48, %rax
movabsq $-0x1c71c71c71c71c71, %rcx # imm = 0xE38E38E38E38E38F
mulq %rcx
shrq $0x6, %rdx
leaq (%rdx,%rdx,8), %rax
leaq 0x48(,%rax,8), %rdx
movq %r14, %rsi
movq %r9, (%rsp)
movq %r10, %r14
callq 0x374b0
movq %r14, %r10
movq (%rsp), %r9
jmp 0x1063ed
testq %r12, %r12
je 0x1063ed
movq %r9, %rax
movq %r10, %rdx
movl $0x9, %ecx
movq %rax, %rdi
movq %rdx, %rsi
rep movsq (%rsi), %es:(%rdi)
addq $0x48, %rdx
addq $0x48, %rax
cmpq %r14, %rdx
jne 0x1063d2
addq %rbp, %r15
leaq 0x18(%rbx), %rax
cmpq %rax, %r10
je 0x10640b
movq %r10, %rdi
movq %r9, %r14
callq 0xe17c0
movq %r14, %r9
movq 0x8(%rbx), %r12
incq %r12
movq %r12, 0x8(%rbx)
movq %r13, 0x10(%rbx)
movq %r9, (%rbx)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xdf8d1
|
/MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h
|
slang::ast::EmptyMemberSymbol::fromSyntax(slang::ast::Compilation&, slang::ast::Scope const&, slang::syntax::EmptyMemberSyntax const&)
|
EmptyMemberSymbol& EmptyMemberSymbol::fromSyntax(Compilation& compilation, const Scope& scope,
const EmptyMemberSyntax& syntax) {
auto result = compilation.emplace<EmptyMemberSymbol>(syntax.semi.location());
result->setAttributes(scope, syntax.attributes);
// Report a warning if this is just an empty semicolon hanging out for no reason,
// but don't report if this was inserted due to an error elsewhere.
if (syntax.attributes.empty() && !syntax.semi.isMissing()) {
// If there are skipped nodes behind this semicolon don't report the warning,
// as it's likely it's due to the error itself.
bool anySkipped = false;
for (auto trivia : syntax.getFirstToken().trivia()) {
if (trivia.kind == TriviaKind::SkippedTokens) {
anySkipped = true;
break;
}
}
if (!anySkipped)
scope.addDiag(diag::EmptyMember, syntax.sourceRange());
}
return *result;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x88(%rdx), %rdi
callq 0xc6cd6
movq %rsp, %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x10e1d0
movq %rax, %r15
movq 0x40(%r14), %rdx
movq 0x48(%r14), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x201620
cmpq $0x0, 0x48(%r14)
jne 0x1066ac
testb $0x1, 0x8a(%r14)
jne 0x1066ac
movq %r14, %rdi
callq 0xc91c4
movq %rsp, %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0xc6cf0
testq %rdx, %rdx
je 0x106691
shlq $0x4, %rdx
xorl %ecx, %ecx
cmpb $0x6, 0xd(%rax,%rcx)
je 0x1066ac
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x106681
movq %r14, %rdi
callq 0xc9084
movq %rdx, %rcx
movq %rbx, %rdi
movl $0xee0006, %esi # imm = 0xEE0006
movq %rax, %rdx
callq 0x1ecb9a
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
slang::ast::ModportPortSymbol::fromSyntax(slang::ast::ASTContext const&, slang::ast::ArgumentDirection, slang::syntax::ModportExplicitPortSyntax const&)
|
ModportPortSymbol& ModportPortSymbol::fromSyntax(const ASTContext& parentContext,
ArgumentDirection direction,
const ModportExplicitPortSyntax& syntax) {
ASTContext context = parentContext.resetFlags(ASTFlags::NonProcedural | ASTFlags::NotADriver);
auto& comp = context.getCompilation();
auto name = syntax.name;
auto result = comp.emplace<ModportPortSymbol>(name.valueText(), name.location(), direction);
result->setSyntax(syntax);
if (!syntax.expr) {
result->setType(comp.getVoidType());
return *result;
}
bitmask<ASTFlags> extraFlags;
if (direction == ArgumentDirection::Out || direction == ArgumentDirection::InOut) {
extraFlags = ASTFlags::LValue;
if (direction == ArgumentDirection::InOut)
extraFlags |= ASTFlags::LAndRValue;
}
auto& expr = Expression::bind(*syntax.expr, context, extraFlags);
result->explicitConnection = &expr;
result->connExpr = &expr;
if (expr.bad()) {
result->setType(comp.getErrorType());
return *result;
}
result->setType(*expr.type);
Expression::checkConnectionDirection(expr, direction, context, result->location);
return *result;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r15
movq %rdi, %rax
leaq 0x4(%rsp), %r14
movl %esi, (%r14)
leaq 0x38(%rsp), %rbx
movabsq $0x100000020, %rdx # imm = 0x100000020
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1617c8
movq (%rbx), %rax
movq (%rax), %rbx
movups 0x28(%r15), %xmm0
leaq 0x10(%rsp), %r12
movaps %xmm0, (%r12)
movq %r12, %rdi
callq 0xc6c10
leaq 0x28(%rsp), %r13
movq %rax, (%r13)
movq %rdx, 0x8(%r13)
movq %r12, %rdi
callq 0xc6cd6
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rcx
callq 0x10e234
movq %rax, %r14
movq %r15, 0x38(%rax)
movq 0x48(%r15), %rdi
testq %rdi, %rdi
je 0x106ccd
movl 0x4(%rsp), %eax
leal -0x1(%rax), %ecx
xorl %esi, %esi
cmpl $0x2, %eax
sete %sil
shlq $0x26, %rsi
orq $0x100000, %rsi # imm = 0x100000
xorl %edx, %edx
cmpl $0x2, %ecx
cmovbq %rsi, %rdx
leaq 0x38(%rsp), %rsi
callq 0x1cdde8
movq %rax, %r15
movq %rax, 0x160(%r14)
movq %rax, 0x168(%r14)
movq %rax, %rdi
callq 0x1cf488
testb %al, %al
je 0x106cda
movq 0x190(%rbx), %rax
jmp 0x106cd4
movq 0x188(%rbx), %rax
movq %rax, 0x48(%r14)
jmp 0x106cfa
movq 0x8(%r15), %rax
movq %rax, 0x48(%r14)
movl 0x4(%rsp), %esi
movq 0x18(%r14), %rcx
leaq 0x38(%rsp), %rdx
movq %r15, %rdi
xorl %r8d, %r8d
callq 0x1cf78c
movq %r14, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
slang::ast::ContinuousAssignSymbol::getAssignment() const
|
const Expression& ContinuousAssignSymbol::getAssignment() const {
if (assign)
return *assign;
auto scope = getParentScope();
auto syntax = getSyntax();
SLANG_ASSERT(scope && syntax);
ASTContext context(*scope, LookupLocation::after(*this), ASTFlags::NonProcedural);
assign = &Expression::bind(syntax->as<ExpressionSyntax>(), context,
ASTFlags::AssignmentAllowed);
return *assign;
}
|
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x1077e2
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %r15
movq 0x38(%rdi), %r14
callq 0x1e1a74
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movl %edx, 0x8(%rsi)
movq $0x20, 0x10(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsi)
movups %xmm0, 0x28(%rsi)
movl $0x8, %edx
movq %r14, %rdi
callq 0x1cdde8
movq %rax, 0x40(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
slang::ast::ContinuousAssignSymbol::getDelay() const
|
const TimingControl* ContinuousAssignSymbol::getDelay() const {
if (delay)
return *delay;
auto scope = getParentScope();
auto syntax = getSyntax();
if (!scope || !syntax || !syntax->parent) {
delay = nullptr;
return nullptr;
}
auto delaySyntax = syntax->parent->as<ContinuousAssignSyntax>().delay;
if (!delaySyntax) {
delay = nullptr;
return nullptr;
}
ASTContext context(*scope, LookupLocation::before(*this), ASTFlags::NonProcedural);
delay = &TimingControl::bind(*delaySyntax, context);
// A multi-delay is disallowed if the lhs references variables.
auto& d = *delay.value();
if (d.kind == TimingControlKind::Delay3) {
auto& d3 = d.as<Delay3Control>();
if (d3.expr2) {
auto& expr = getAssignment();
if (expr.kind == ExpressionKind::Assignment) {
auto& left = expr.as<AssignmentExpression>().left();
ExpressionVarVisitor visitor;
left.visit(visitor);
if (visitor.anyVars)
context.addDiag(diag::Delay3OnVar, left.sourceRange);
}
}
}
return *delay;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x50(%rdi)
jne 0x10784c
movq 0x48(%rbx), %rax
jmp 0x1078c3
movq 0x20(%rbx), %r15
movq 0x38(%rbx), %rax
testq %r15, %r15
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x1078b5
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x1078b5
movq 0x68(%rax), %r14
testq %r14, %r14
je 0x1078b5
movq %rbx, %rdi
callq 0x1e1a6c
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movl %edx, 0x8(%rsi)
movq $0x20, 0x10(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsi)
movups %xmm0, 0x28(%rsi)
movq %r14, %rdi
callq 0x201684
cmpb $0x0, 0x50(%rbx)
je 0x1078cd
movq %rax, 0x48(%rbx)
jne 0x1078d5
callq 0xb37c3
movb $0x1, 0x50(%rbx)
movq $0x0, 0x48(%rbx)
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, 0x50(%rbx)
movq %rax, 0x48(%rbx)
cmpl $0x6, (%rax)
jne 0x107846
cmpq $0x0, 0x28(%rax)
je 0x107846
movq %rbx, %rdi
callq 0x1077d8
cmpl $0xe, (%rax)
jne 0x107846
movq 0x40(%rax), %r14
leaq 0x7(%rsp), %r15
movb $0x0, (%r15)
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x10f346
cmpb $0x1, (%r15)
jne 0x107846
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
leaq 0x8(%rsp), %rdi
movl $0x2c0006, %esi # imm = 0x2C0006
callq 0x160b40
jmp 0x107846
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
slang::ast::GenvarSymbol::fromSyntax(slang::ast::Scope const&, slang::syntax::GenvarDeclarationSyntax const&, slang::SmallVectorBase<slang::ast::GenvarSymbol const*>&)
|
void GenvarSymbol::fromSyntax(const Scope& parent, const GenvarDeclarationSyntax& syntax,
SmallVectorBase<const GenvarSymbol*>& results) {
auto& comp = parent.getCompilation();
for (auto id : syntax.identifiers) {
auto name = id->identifier;
if (name.valueText().empty())
continue;
auto genvar = comp.emplace<GenvarSymbol>(name.valueText(), name.location());
genvar->setSyntax(*id);
genvar->setAttributes(parent, syntax.attributes);
results.push_back(genvar);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, (%rsp)
movq 0x90(%rsi), %rbx
incq %rbx
cmpq $0x2, %rbx
jb 0x107b8f
movq %rsi, %r14
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
shrq %rbx
xorl %r12d, %r12d
leaq 0x30(%rsp), %r13
leaq 0x20(%rsp), %rbp
movq 0x88(%r14), %rdi
addq %r12, %rdi
callq 0xa1cb9
movq (%rax), %r15
movups 0x18(%r15), %xmm0
movaps %xmm0, 0x30(%rsp)
movq %r13, %rdi
callq 0xc6c10
testq %rax, %rax
je 0x107b82
movq %r13, %rdi
callq 0xc6c10
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq %r13, %rdi
callq 0xc6cd6
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
leaq 0x18(%rsp), %rdx
callq 0xe47dc
movq %rax, 0x20(%rsp)
movq %r15, 0x38(%rax)
movq 0x40(%r14), %rdx
movq 0x48(%r14), %rcx
movq %rax, %rdi
movq (%rsp), %rsi
callq 0x201620
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x117668
addq $0x30, %r12
decq %rbx
jne 0x107afe
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
slang::ast::ElabSystemTaskSymbol::createMessage(slang::ast::ASTContext const&, std::span<slang::ast::Expression const* const, 18446744073709551615ul>)
|
std::optional<std::string_view> ElabSystemTaskSymbol::createMessage(
const ASTContext& context, std::span<const Expression* const> args) {
// Check all arguments.
if (!FmtHelpers::checkDisplayArgs(context, args))
return {};
// Format the message to string.
EvalContext evalCtx(context);
std::optional<std::string> str = FmtHelpers::formatDisplay(*context.scope, evalCtx, args);
evalCtx.reportAllDiags();
if (!str)
return {};
if (str->empty())
return ""sv;
str->insert(0, ": ");
// Copy the string into permanent memory.
auto mem = context.getCompilation().allocate(str->size(), alignof(char));
memcpy(mem, str->data(), str->size());
return std::string_view(reinterpret_cast<char*>(mem), str->size());
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x390, %rsp # imm = 0x390
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rsi
movq %rdx, (%rsi)
movq %rcx, 0x8(%rsi)
movq %r14, %rdi
callq 0x1e0320
testb %al, %al
je 0x108072
movq 0x30(%r14), %rax
leaq 0xa8(%rsp), %rcx
movq %rax, -0x38(%rcx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movaps %xmm2, -0x48(%rcx)
movaps %xmm1, -0x58(%rcx)
movaps %xmm0, -0x68(%rcx)
xorl %eax, %eax
movb %al, -0x30(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, -0x2c(%rcx)
movl $0x0, -0x1c(%rcx)
movq %rcx, -0x18(%rcx)
movq %rax, -0x10(%rcx)
movl $0x2, %edx
movq %rdx, -0x8(%rcx)
leaq 0x160(%rsp), %r13
movq %r13, -0x18(%r13)
movq %rax, -0x10(%r13)
movq $0x5, -0x8(%r13)
leaq 0x1a0(%rsp), %rcx
movq %rcx, -0x18(%rcx)
movq %rax, -0x10(%rcx)
movq %rdx, -0x8(%rcx)
leaq 0x298(%rsp), %rcx
movq %rcx, -0x18(%rcx)
movq %rax, -0x10(%rcx)
movq %rdx, -0x8(%rcx)
movb %al, 0xf0(%rcx)
movups %xmm0, 0xe0(%rcx)
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rdx
leaq 0x30(%rsp), %rcx
callq 0x1e06de
leaq 0x40(%rsp), %rdi
callq 0x1cd368
movb 0x28(%rsp), %al
testb %al, %al
je 0x10807b
cmpq $0x0, 0x10(%rsp)
je 0x108081
leaq 0x2ac161(%rip), %rcx # 0x3b418c
leaq 0x8(%rsp), %rdi
movl $0x2, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x6d842
movq (%r14), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rdi), %rcx
movq 0x8(%rcx), %r14
leaq (%r14,%rax), %rdx
cmpq 0x8(%rdi), %rdx
jbe 0x108099
movl $0x1, %edx
movq %rax, %rsi
callq 0xd7432
movq %rax, %r14
movq 0x10(%rsp), %rax
jmp 0x10809d
movb $0x0, 0x10(%rbx)
jmp 0x108126
movb $0x0, 0x10(%rbx)
jmp 0x1080c1
movq $0x0, (%rbx)
leaq 0x26fd5d(%rip), %rcx # 0x377dec
movq %rcx, 0x8(%rbx)
movb $0x1, 0x10(%rbx)
jmp 0x1080c1
movq %rdx, 0x8(%rcx)
movq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x374b0
movq 0x10(%rsp), %rax
movq %rax, (%rbx)
movq %r14, 0x8(%rbx)
movb $0x1, 0x10(%rbx)
movb 0x28(%rsp), %al
leaq 0x188(%rsp), %r14
leaq 0x280(%rsp), %r15
testb $0x1, %al
je 0x1080f4
leaq 0x18(%rsp), %rax
movb $0x0, 0x10(%rax)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1080f4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xe17e8
leaq 0x90(%rsp), %r12
movq %r15, %rdi
callq 0x6aac8
movq %r14, %rdi
callq 0x6aac8
movq 0xb8(%r12), %rdi
cmpq %r13, %rdi
je 0x10811e
callq 0xe17c0
movq %r12, %rdi
callq 0x6ab56
movq %rbx, %rax
addq $0x390, %rsp # imm = 0x390
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x108141
movq %rax, %rbx
jmp 0x10816a
movq %rax, %rbx
cmpb $0x1, 0x28(%rsp)
jne 0x10816a
leaq 0x18(%rsp), %rax
movb $0x0, 0x10(%rax)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10816a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xe17e8
leaq 0x40(%rsp), %rdi
callq 0x6aa86
movq %rbx, %rdi
callq 0x37b10
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
slang::ast::AssertionPortSymbol::buildPorts(slang::ast::Scope&, slang::syntax::AssertionItemPortListSyntax const&, slang::SmallVectorBase<slang::ast::AssertionPortSymbol const*>&)
|
void AssertionPortSymbol::buildPorts(Scope& scope, const AssertionItemPortListSyntax& syntax,
SmallVectorBase<const AssertionPortSymbol*>& results) {
auto& comp = scope.getCompilation();
auto parentKind = scope.asSymbol().kind;
auto& untyped = comp.getType(SyntaxKind::Untyped);
const DataTypeSyntax* lastType = nullptr;
std::optional<ArgumentDirection> lastDir;
for (auto item : syntax.ports) {
if (item->previewNode)
scope.addMembers(*item->previewNode);
auto port = comp.emplace<AssertionPortSymbol>(item->name.valueText(),
item->name.location());
port->setSyntax(*item);
port->setAttributes(scope, item->attributes);
if (!item->dimensions.empty())
port->declaredType.setDimensionSyntax(item->dimensions);
if (item->local) {
port->direction = item->direction ? SemanticFacts::getDirection(item->direction.kind)
: ArgumentDirection::In;
// If we have a direction we can never inherit the previous type.
lastType = nullptr;
}
else if (isEmptyType(*item->type)) {
port->direction = lastDir;
}
// 'local' direction requires that we have a sequence type. This flag needs to be
// added prior to setting a resolved type in the branches below.
if (port->direction)
port->declaredType.addFlags(DeclaredTypeFlags::RequireSequenceType);
if (isEmptyType(*item->type)) {
if (lastType)
port->declaredType.setTypeSyntax(*lastType);
else {
port->declaredType.setType(untyped);
if (!item->dimensions.empty()) {
scope.addDiag(diag::InvalidArrayElemType, item->dimensions.sourceRange())
<< untyped;
}
if (item->local && parentKind != SymbolKind::LetDecl)
scope.addDiag(diag::LocalVarTypeRequired, item->local.range());
}
}
else {
port->declaredType.setTypeSyntax(*item->type);
lastType = item->type;
// Ports of type 'property' are not allowed in sequences,
// and let declarations cannot have ports of type 'sequence' or 'property'.
auto itemKind = item->type->kind;
if (itemKind == SyntaxKind::PropertyType && parentKind == SymbolKind::Sequence) {
scope.addDiag(diag::PropertyPortInSeq, item->type->sourceRange());
}
else if ((itemKind == SyntaxKind::PropertyType ||
itemKind == SyntaxKind::SequenceType) &&
parentKind == SymbolKind::LetDecl) {
scope.addDiag(diag::PropertyPortInLet, item->type->sourceRange())
<< item->type->getFirstToken().valueText();
}
}
lastDir = port->direction;
if (item->defaultValue) {
if (port->direction == ArgumentDirection::Out ||
port->direction == ArgumentDirection::InOut) {
scope.addDiag(diag::AssertionPortOutputDefault,
item->defaultValue->expr->sourceRange());
}
else {
port->defaultValueSyntax = item->defaultValue->expr;
}
}
scope.addMember(*port);
results.push_back(port);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x48(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
movq 0x8(%r15), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movq %rdi, 0x38(%rsp)
movl $0x1ff, %esi # imm = 0x1FF
callq 0x19e75c
movq %rax, 0x18(%rsp)
movq %rbx, 0x40(%rsp)
movq 0x58(%rbx), %r12
incq %r12
cmpq $0x2, %r12
jae 0x10abe1
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rbx
shrq %r12
xorl %ecx, %ecx
movq $0x0, 0x10(%rsp)
xorl %ebp, %ebp
xorl %r15d, %r15d
movq %rbx, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rdi
movq %rcx, 0x50(%rsp)
addq %rcx, %rdi
callq 0xa1cb9
movq (%rax), %r13
movq 0x10(%r13), %rsi
testq %rsi, %rsi
je 0x10ac26
movq %rbx, %rdi
callq 0x1ececa
leaq 0x78(%r13), %rbx
movq %rbx, %rdi
callq 0xc6c10
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rbx, %rdi
movq 0x20(%rsp), %rbx
callq 0xc6cd6
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x10e83c
movq %rax, 0x8(%rsp)
movq %r13, 0x38(%rax)
movq 0x40(%r13), %rdx
movq 0x48(%r13), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x201620
cmpq $0x0, 0xb8(%r13)
je 0x10ac9d
leaq 0x88(%r13), %rsi
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
callq 0x15af22
cmpq $0x0, 0x58(%r13)
je 0x10ace6
cmpq $0x0, 0x68(%r13)
movabsq $0x100000000, %r15 # imm = 0x100000000
movq %r15, %rax
movl 0x4(%rsp), %ebp
movq 0x18(%rsp), %rsi
je 0x10acd6
movzwl 0x60(%r13), %edi
movq %rsi, %r14
callq 0x1f40ca
movq %r14, %rsi
movl %eax, %eax
orq %r15, %rax
movq 0x8(%rsp), %rcx
movq %rax, 0x88(%rcx)
xorl %edx, %edx
jmp 0x10ad3a
movq 0x70(%r13), %rax
cmpl $0xf7, (%rax)
jne 0x10ad2c
cmpq $0x0, 0x20(%rax)
movq 0x10(%rsp), %rdx
jne 0x10ad21
cmpq $0x0, 0x58(%rax)
jne 0x10ad21
movq 0x8(%rsp), %rax
movabsq $0xffffffffff, %rcx # imm = 0xFFFFFFFFFF
andq %rcx, %r15
orq %rbp, %r15
movq %r15, 0x88(%rax)
movl 0x4(%rsp), %ebp
movq 0x18(%rsp), %rsi
jmp 0x10ad3a
movl 0x4(%rsp), %ebp
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rax
cmpb $0x1, 0x8c(%rax)
jne 0x10ad4c
orb $0x20, 0x79(%rax)
movq 0x70(%r13), %rcx
cmpl $0xf7, (%rcx)
jne 0x10ad6a
cmpq $0x0, 0x20(%rcx)
jne 0x10ad6a
cmpq $0x0, 0x58(%rcx)
je 0x10aebb
movl %ebp, %edx
xorl $0x4f, %edx
movq %rcx, 0x50(%rax)
andb $0x7f, 0x7f(%rax)
movq 0x70(%r13), %rdi
movl (%rdi), %eax
movl %eax, %ecx
xorl $0x180, %ecx # imm = 0x180
orl %edx, %ecx
movq %rdi, 0x10(%rsp)
jne 0x10ada8
callq 0xc9084
movq %rdx, %rcx
movq %rbx, %rdi
movl $0xb10006, %esi # imm = 0xB10006
movq %rax, %rdx
callq 0x1ecb9a
jmp 0x10ae0e
cmpl $0x180, %eax # imm = 0x180
sete %cl
cmpl $0x55, %ebp
sete %dl
cmpl $0x1a5, %eax # imm = 0x1A5
sete %al
orb %cl, %al
andb %dl, %al
cmpb $0x1, %al
jne 0x10ae0e
callq 0xc9084
movq %rdx, %rcx
movq %rbx, %rdi
movl $0xb00006, %esi # imm = 0xB00006
movq %rax, %rdx
callq 0x1ecb9a
movq %rax, %rbx
movq 0x70(%r13), %rdi
callq 0xc91c4
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xc6c10
movq %rbx, %rdi
movq 0x20(%rsp), %rbx
movq %rax, %rsi
callq 0x83e5c
movq 0x8(%rsp), %rsi
movq 0x88(%rsi), %r15
movq 0xc0(%r13), %rax
testq %rax, %rax
je 0x10ae71
movabsq $0x100000000, %rcx # imm = 0x100000000
testq %rcx, %r15
setne %cl
leal -0x1(%r15), %edx
cmpl $0x2, %edx
setb %dl
andb %cl, %dl
movq 0x28(%rax), %rdi
cmpb $0x1, %dl
jne 0x10ae6a
callq 0xc9084
movq %rdx, %rcx
movq %rbx, %rdi
movl $0x20006, %esi # imm = 0x20006
movq %rax, %rdx
callq 0x1ecb9a
movq 0x8(%rsp), %rsi
jmp 0x10ae71
movq %rdi, 0x80(%rsi)
movq %r15, %rbp
movabsq $-0x10000000000, %rax # imm = 0xFFFFFF0000000000
andq %rax, %rbp
movq 0x20(%rbx), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x1ee400
movq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x118098
movq 0x50(%rsp), %rcx
addq $0x30, %rcx
decq %r12
jne 0x10abfc
jmp 0x10abd2
testq %rdx, %rdx
je 0x10aed2
movq %rdx, 0x10(%rsp)
movq %rdx, 0x50(%rax)
andb $0x7f, 0x7f(%rax)
jmp 0x10ae0e
movq %rsi, 0x48(%rax)
cmpq $0x0, 0xb8(%r13)
je 0x10af0d
leaq 0x90(%r13), %rdi
movq %rsi, %r15
callq 0xc9084
movq %rdx, %rcx
movq %rbx, %rdi
movl $0xb0009, %esi # imm = 0xB0009
movq %rax, %rdx
callq 0x1ecb9a
movq %rax, %rdi
movq %r15, %rsi
callq 0x15f621
cmpl $0x55, %ebp
setne %al
cmpq $0x0, 0x58(%r13)
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x10af3e
leaq 0x50(%r13), %rdi
callq 0xc6caa
movq %rdx, %rcx
movq %rbx, %rdi
movl $0x6b0006, %esi # imm = 0x6B0006
movq %rax, %rdx
callq 0x1ecb9a
movq $0x0, 0x10(%rsp)
jmp 0x10ae0e
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
slang::ast::AssertionPortSymbol::clone(slang::ast::Scope&) const
|
AssertionPortSymbol& AssertionPortSymbol::clone(Scope& newScope) const {
auto& comp = newScope.getCompilation();
auto result = comp.emplace<AssertionPortSymbol>(name, location);
result->declaredType.setLink(declaredType);
result->defaultValueSyntax = defaultValueSyntax;
result->direction = direction;
if (auto syntax = getSyntax()) {
result->setSyntax(*syntax);
result->setAttributes(newScope, syntax->as<AssertionItemPortSyntax>().attributes);
}
return *result;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rdi
leaq 0x8(%r15), %rsi
leaq 0x18(%r15), %rdx
callq 0x10e8ca
movq %rax, %r14
leaq 0x40(%rax), %rdi
leaq 0x40(%r15), %rsi
callq 0x15af18
movq 0x80(%r15), %rax
movq %rax, 0x80(%r14)
movq 0x88(%r15), %rax
movq %rax, 0x88(%r14)
movq 0x38(%r15), %rax
testq %rax, %rax
je 0x10afb3
movq %rax, 0x38(%r14)
movq 0x40(%rax), %rdx
movq 0x48(%rax), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x201620
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
slang::ast::SequenceSymbol::fromSyntax(slang::ast::Scope const&, slang::syntax::SequenceDeclarationSyntax const&)
|
SequenceSymbol& SequenceSymbol::fromSyntax(const Scope& scope,
const SequenceDeclarationSyntax& syntax) {
auto& comp = scope.getCompilation();
auto result = comp.emplace<SequenceSymbol>(comp, syntax.name.valueText(),
syntax.name.location());
result->setSyntax(syntax);
result->setAttributes(scope, syntax.attributes);
SmallVector<const AssertionPortSymbol*> ports;
if (syntax.portList)
AssertionPortSymbol::buildPorts(*result, *syntax.portList, ports);
result->ports = ports.copy(comp);
return *result;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rbx
leaq 0x60(%rsi), %r14
movq %r14, %rdi
callq 0xc6c10
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
movq %rdx, 0x8(%r13)
movq %r14, %rdi
callq 0xc6cd6
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rbx, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x10e958
movq %rax, %r14
movq %r15, 0x38(%rax)
movq 0x40(%r15), %rdx
movq 0x48(%r15), %rcx
movq %rax, %rdi
movq %r12, %rsi
callq 0x201620
leaq 0x28(%rsp), %r12
movq %r12, -0x18(%r12)
movq $0x0, -0x10(%r12)
movq $0x5, -0x8(%r12)
movq 0x70(%r15), %rsi
testq %rsi, %rsi
je 0x10b0e4
leaq 0x40(%r14), %rdi
leaq 0x10(%rsp), %rdx
callq 0x10ab86
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x10e9f4
movq %rax, 0x78(%r14)
movq %rdx, 0x80(%r14)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x10b10b
callq 0xe17c0
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x10b11e
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x10b130
callq 0xe17c0
movq %rbx, %rdi
callq 0x37b10
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
slang::ast::ClockingBlockSymbol::serializeTo(slang::ast::ASTSerializer&) const
|
void ClockingBlockSymbol::serializeTo(ASTSerializer& serializer) const {
serializer.write("event", getEvent());
if (auto skew = getDefaultInputSkew(); skew.hasValue()) {
serializer.writeProperty("defaultInputSkew");
serializer.startObject();
skew.serializeTo(serializer);
serializer.endObject();
}
if (auto skew = getDefaultOutputSkew(); skew.hasValue()) {
serializer.writeProperty("defaultOutputSkew");
serializer.startObject();
skew.serializeTo(serializer);
serializer.endObject();
}
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x10ba22
leaq 0x29730d(%rip), %rdx # 0x3a2eea
movl $0x5, %esi
movq %rbx, %rdi
movq %rax, %rcx
callq 0x161ac2
movq %r14, %rdi
callq 0x10ba84
movl %eax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
testq %rdx, %rdx
setne %cl
testl %eax, %eax
setne %al
orb %cl, %al
cmpb $0x1, %al
jne 0x10bc40
leaq 0x26e0a9(%rip), %rdx # 0x379cbf
movl $0x10, %esi
movq %rbx, %rdi
callq 0x161e4e
movq %rbx, %rdi
callq 0x161e3a
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x1f497c
movq %rbx, %rdi
callq 0x161e44
movq %r14, %rdi
callq 0x10bb24
movl %eax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
testq %rdx, %rdx
setne %cl
testl %eax, %eax
setne %al
orb %cl, %al
cmpb $0x1, %al
jne 0x10bc93
leaq 0x26e067(%rip), %rdx # 0x379cd0
movl $0x11, %esi
movq %rbx, %rdi
callq 0x161e4e
movq %rbx, %rdi
callq 0x161e3a
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x1f497c
movq %rbx, %rdi
callq 0x161e44
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
slang::ast::RandSeqProductionSymbol::RandSeqProductionSymbol(slang::ast::Compilation&, std::basic_string_view<char, std::char_traits<char>>, slang::SourceLocation)
|
RandSeqProductionSymbol::RandSeqProductionSymbol(Compilation& compilation, std::string_view name,
SourceLocation loc) :
Symbol(SymbolKind::RandSeqProduction, name, loc), Scope(compilation, this),
declaredReturnType(*this) {
}
|
pushq %rbx
movq %rdi, %rbx
movl $0x59, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq %r8, 0x18(%rdi)
movq $0x0, 0x38(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movl $0x0, 0x30(%rdi)
addq $0x40, %rdi
movq %rbx, %rdx
callq 0x1ec9b0
leaq 0x78(%rbx), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x15abf4
xorps %xmm0, %xmm0
movups %xmm0, 0xb8(%rbx)
movb $0x0, 0xd8(%rbx)
popq %rbx
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
slang::ast::RandSeqProductionSymbol::fromSyntax(slang::ast::Scope const&, slang::syntax::ProductionSyntax const&)
|
RandSeqProductionSymbol& RandSeqProductionSymbol::fromSyntax(const Scope& scope,
const ProductionSyntax& syntax) {
auto& comp = scope.getCompilation();
auto result = comp.emplace<RandSeqProductionSymbol>(comp, syntax.name.valueText(),
syntax.name.location());
result->setSyntax(syntax);
if (syntax.dataType)
result->declaredReturnType.setTypeSyntax(*syntax.dataType);
else
result->declaredReturnType.setType(comp.getVoidType());
if (syntax.portList) {
SmallVector<const FormalArgumentSymbol*> args;
SubroutineSymbol::buildArguments(*result, scope, *syntax.portList,
VariableLifetime::Automatic, args);
result->arguments = args.copy(comp);
}
for (auto rule : syntax.rules) {
if (rule->previewNode)
result->addMembers(*rule->previewNode);
auto& ruleBlock = StatementBlockSymbol::fromSyntax(*result, *rule);
result->addMember(ruleBlock);
}
return *result;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movq (%rdi), %r15
leaq 0x20(%rsi), %r14
movq %r14, %rdi
callq 0xc6c10
leaq 0x8(%rsp), %r13
movq %rax, (%r13)
movq %rdx, 0x8(%r13)
movq %r14, %rdi
callq 0xc6cd6
movq %rsp, %rcx
movq %rax, (%rcx)
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x10ecf4
movq %rax, %r14
movq %rbx, 0x38(%rax)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x10bd63
movq %rax, 0x88(%r14)
andb $0x7f, 0xb7(%r14)
jmp 0x10bd71
movq 0x188(%r15), %rax
movq %rax, 0x80(%r14)
movq 0x30(%rbx), %rdx
testq %rdx, %rdx
je 0x10bdd0
leaq 0x20(%rsp), %r13
movq %r13, -0x18(%r13)
movq $0x0, -0x10(%r13)
movq $0x5, -0x8(%r13)
leaq 0x40(%r14), %rdi
leaq 0x8(%rsp), %r8
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x144c36
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xf0132
movq %rax, 0xb8(%r14)
movq %rdx, 0xc0(%r14)
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x10bdd0
callq 0xe17c0
movq 0x78(%rbx), %r13
incq %r13
cmpq $0x2, %r13
jb 0x10be35
shrq %r13
movq %r14, %r15
addq $0x40, %r15
xorl %ebp, %ebp
movq 0x70(%rbx), %rdi
addq %rbp, %rdi
callq 0xa1cb9
movq (%rax), %r12
movq 0x10(%r12), %rsi
testq %rsi, %rsi
je 0x10be0a
movq %r15, %rdi
callq 0x1ececa
movq %r15, %rdi
movq %r12, %rsi
callq 0xe21d2
movq 0x60(%r14), %rdx
movq %r15, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x1ee400
addq $0x30, %rbp
decq %r13
jne 0x10bde9
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10be49
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x10be5b
callq 0xe17c0
movq %rbx, %rdi
callq 0x37b10
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
slang::ast::RandSeqProductionSymbol::createRuleVariables(slang::syntax::RsRuleSyntax const&, slang::ast::Scope const&, slang::SmallVectorBase<slang::ast::Symbol const*>&)
|
void RandSeqProductionSymbol::createRuleVariables(const RsRuleSyntax& syntax, const Scope& scope,
SmallVectorBase<const Symbol*>& results) {
SmallMap<const RandSeqProductionSymbol*, uint32_t, 8> prodMap;
auto countProd = [&](const RsProdItemSyntax& item) {
auto symbol = Lookup::unqualified(scope, item.name.valueText(),
LookupFlags::AllowDeclaredAfter);
if (symbol && symbol->kind == SymbolKind::RandSeqProduction) {
auto& prod = symbol->as<RandSeqProductionSymbol>();
auto& type = prod.getReturnType();
if (!type.isVoid()) {
auto [it, inserted] = prodMap.emplace(&prod, 1);
if (!inserted)
it->second++;
}
}
};
for (auto p : syntax.prods) {
switch (p->kind) {
case SyntaxKind::RsProdItem:
countProd(p->as<RsProdItemSyntax>());
break;
case SyntaxKind::RsCodeBlock:
break;
case SyntaxKind::RsIfElse: {
auto& ries = p->as<RsIfElseSyntax>();
countProd(*ries.ifItem);
if (ries.elseClause)
countProd(*ries.elseClause->item);
break;
}
case SyntaxKind::RsRepeat:
countProd(*p->as<RsRepeatSyntax>().item);
break;
case SyntaxKind::RsCase:
for (auto item : p->as<RsCaseSyntax>().items) {
switch (item->kind) {
case SyntaxKind::StandardRsCaseItem:
countProd(*item->as<StandardRsCaseItemSyntax>().item);
break;
case SyntaxKind::DefaultRsCaseItem:
countProd(*item->as<DefaultRsCaseItemSyntax>().item);
break;
default:
SLANG_UNREACHABLE;
}
}
break;
default:
SLANG_UNREACHABLE;
}
}
auto& comp = scope.getCompilation();
for (auto [symbol, count] : prodMap) {
auto var = comp.emplace<VariableSymbol>(symbol->name, syntax.getFirstToken().location(),
VariableLifetime::Automatic);
var->flags |= VariableFlags::Const | VariableFlags::CompilerGenerated;
if (count == 1) {
var->setType(symbol->getReturnType());
}
else {
ConstantRange range{1, int32_t(count)};
var->setType(
FixedSizeUnpackedArrayType::fromDim(scope, symbol->getReturnType(), range, syntax));
}
results.push_back(var);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rdx, 0x40(%rsp)
leaq 0x90(%rsp), %rax
movq %rax, 0x80(%rax)
movq %rax, 0x88(%rax)
leaq 0x120(%rsp), %rdx
movq $0x3f, (%rdx)
movq $0x1, 0x8(%rdx)
pxor %xmm0, %xmm0
movdqa %xmm0, 0x10(%rdx)
leaq 0x264049(%rip), %rcx # 0x370b30
movq %rcx, 0x10(%rdx)
movdqa %xmm0, 0x20(%rdx)
movq %rsi, 0x38(%rsp)
movq %rsi, 0x60(%rsp)
movq %rax, 0x68(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x10cbca
movq 0x28(%rsp), %rcx
movq 0x48(%rcx), %r15
leaq (%r15,%rax,8), %rax
movq %rax, 0x20(%rsp)
leaq 0x26cf4e(%rip), %r13 # 0x379a78
leaq 0x60(%rsp), %rbx
movq (%r15), %r14
movl (%r14), %eax
movl $0xfffffe69, %ecx # imm = 0xFFFFFE69
addl %ecx, %eax
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq 0x80(%r14), %rbp
testq %rbp, %rbp
je 0x10cbbb
movq 0x78(%r14), %r14
shlq $0x3, %rbp
xorl %r12d, %r12d
movq (%r14,%r12), %rax
cmpl $0x1b8, (%rax) # imm = 0x1B8
je 0x10cb6f
addq $0x38, %rax
jmp 0x10cb73
addq $0x60, %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x10cdb8
addq $0x8, %r12
cmpq %r12, %rbp
jne 0x10cb5d
jmp 0x10cbbb
movq 0x50(%r14), %rsi
movq %rbx, %rdi
callq 0x10cdb8
movq 0x58(%r14), %rax
testq %rax, %rax
je 0x10cbbb
movq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x10cdb8
jmp 0x10cbbb
movq 0x50(%r14), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10cdb8
addq $0x8, %r15
cmpq 0x20(%rsp), %r15
jne 0x10cb2f
leaq 0x118(%rsp), %rdi
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
callq 0x3cc54
testq %rdx, %rdx
je 0x10cd62
movq %rax, %r15
movq %rdx, %rbp
leaq 0x48(%rsp), %rbx
movq (%rbp), %r12
movl 0x8(%rbp), %r14d
movq 0x28(%rsp), %rdi
callq 0xc91c4
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq %rbx, %rdi
callq 0xc6cd6
leaq 0x8(%r12), %rsi
movq %rax, 0x58(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rdx
leaq 0x34(%rsp), %rcx
callq 0x10f1aa
movq %rax, %r13
orb $0x3, 0x154(%rax)
addq $0x78, %r12
cmpl $0x1, %r14d
jne 0x10cc60
movq %r12, %rdi
callq 0x15ac12
jmp 0x10ccae
movq %r12, %rdi
callq 0x15ac12
shlq $0x20, %r14
incq %r14
pxor %xmm0, %xmm0
movdqa %xmm0, 0x70(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, 0x80(%rsp)
movq 0x80(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movdqa 0x70(%rsp), %xmm0
movdqu %xmm0, (%rsp)
movq 0x38(%rsp), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x156c58
movq %rax, 0x48(%r13)
movq %r13, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0xf1c12
leaq 0x2(%r15), %rax
movq %r15, %rcx
addq $0x12, %rcx
pxor %xmm1, %xmm1
addq $0x10, %rbp
movl %r15d, %edx
andl $0xf, %edx
cmpl $0xe, %edx
je 0x10cd04
movzbl -0x1(%rax), %edx
incq %rax
incq %r15
incq %rcx
testl %edx, %edx
je 0x10ccd3
cmpl $0x1, %edx
je 0x10cd62
addq $-0x2, %rax
movq %rax, %r15
jmp 0x10cbf8
movdqa (%rax), %xmm0
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %edx
movl $0x7fff, %esi # imm = 0x7FFF
andl %esi, %edx
cmpl %esi, %edx
jne 0x10cd3f
addq $0xf0, %rbp
movdqa (%rcx), %xmm0
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %edx
andl %esi, %edx
addq $0x10, %rcx
cmpl %esi, %edx
je 0x10cd1b
addq $-0x10, %rcx
movq %rcx, %rax
movzwl %dx, %ecx
xorl $0x7fff, %ecx # imm = 0x7FFF
bsfl %ecx, %ecx
cmpb $0x1, (%rax,%rcx)
je 0x10cd62
addq %rcx, %rax
shll $0x4, %ecx
addq %rcx, %rbp
movq %rax, %r15
jmp 0x10cbf8
movq 0x118(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0x112a18
addq $0x158, %rsp # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10cd97
jmp 0x10cd97
jmp 0x10cd97
jmp 0x10cd97
jmp 0x10cd97
jmp 0x10cd97
jmp 0x10cd97
movq %rax, %rbx
movq 0x118(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0x112a18
movq %rbx, %rdi
callq 0x37b10
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
slang::ast::NetAliasSymbol::getNetReferences() const
|
std::span<const Expression* const> NetAliasSymbol::getNetReferences() const {
if (netRefs)
return *netRefs;
auto scope = getParentScope();
auto syntax = getSyntax();
SLANG_ASSERT(scope && syntax);
SmallVector<const Expression*> buffer;
ASTContext context(*scope, LookupLocation::after(*this),
ASTFlags::NonProcedural | ASTFlags::NotADriver);
EvalContext evalCtx(context);
NetAliasVisitor visitor(context, evalCtx);
SmallVector<SmallVector<NetAlias>> netAliases;
bitwidth_t bitWidth = 0;
bool issuedError = false;
for (auto exprSyntax : syntax->as<NetAliasSyntax>().nets) {
auto& netRef = Expression::bind(*exprSyntax, context);
if (!netRef.requireLValue(context))
continue;
if (!bitWidth) {
bitWidth = netRef.type->getBitWidth();
}
else if (bitWidth != netRef.type->getBitWidth() && !issuedError) {
auto& diag = context.addDiag(diag::NetAliasWidthMismatch, netRef.sourceRange);
diag << netRef.type->getBitWidth() << bitWidth;
issuedError = true;
}
netRef.visit(visitor);
buffer.push_back(&netRef);
if (!visitor.netAliases.empty()) {
netAliases.emplace_back(std::move(visitor.netAliases));
visitor.netAliases.clear();
}
}
netRefs = buffer.copy(scope->getCompilation());
if (issuedError || netAliases.empty())
return *netRefs;
// Compare every net alias expression to every other, finding the set of
// bits that overlap and adding drivers for them so that we can catch
// and report on duplicate and/or self aliases.
auto& comp = scope->getCompilation();
const size_t numAliases = netAliases.size();
for (size_t i = 0; i < numAliases - 1; i++) {
for (size_t j = i + 1; j < numAliases; j++) {
auto& first = netAliases[i];
auto& second = netAliases[j];
auto firstIt = first.begin();
auto firstEnd = first.end();
auto secondIt = second.begin();
auto secondEnd = second.end();
// Compare each net reference or selection from the left hand side
// to the corresponding elements on the right hand side. The individual
// elements can differ in width, so consume bits from the larger side
// and only advance when a side has been consumed.
std::optional<std::pair<DriverBitRange, bool>> remainder;
while (firstIt != firstEnd && secondIt != secondEnd) {
auto& firstAlias = *firstIt;
auto& secondAlias = *secondIt;
auto firstRange = firstAlias.bounds;
auto secondRange = secondAlias.bounds;
if (remainder) {
if (remainder->second)
firstRange = remainder->first;
else
secondRange = remainder->first;
remainder.reset();
}
auto firstWidth = firstRange.second - firstRange.first + 1;
auto secondWidth = secondRange.second - secondRange.first + 1;
uint64_t width;
if (firstWidth < secondWidth) {
width = firstWidth;
remainder = std::pair(
DriverBitRange(secondRange.first, secondRange.second - width), false);
firstIt++;
}
else {
width = secondWidth;
secondIt++;
if (firstWidth == secondWidth)
firstIt++;
else {
remainder = std::pair(
DriverBitRange(firstRange.first, firstRange.second - width), true);
}
}
comp.noteNetAlias(*scope, *firstAlias.sym,
{firstRange.second - width + 1, firstRange.second},
*firstAlias.expr, *secondAlias.sym,
{secondRange.second - width + 1, secondRange.second},
*secondAlias.expr);
}
}
}
return *netRefs;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x598, %rsp # imm = 0x598
movq %rdi, %r14
cmpb $0x1, 0x50(%rdi)
jne 0x10dbbf
movq 0x40(%r14), %r12
movq 0x48(%r14), %r13
jmp 0x10e0ec
movq 0x20(%r14), %rbx
movq 0x38(%r14), %r12
leaq 0xa0(%rsp), %rax
movq %rax, -0x18(%rax)
movq $0x0, -0x10(%rax)
movq $0x5, -0x8(%rax)
movq %r14, %rdi
callq 0x1e1a74
leaq 0x140(%rsp), %rax
movq %rbx, (%rax)
movl %edx, 0x8(%rax)
movabsq $0x100000020, %rcx # imm = 0x100000020
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movq 0x30(%rax), %rcx
leaq 0x2a8(%rsp), %rdx
movq %rcx, -0x38(%rdx)
movups 0x20(%rax), %xmm1
movaps %xmm1, -0x48(%rdx)
movq 0x10(%rax), %rcx
movq %rcx, -0x58(%rdx)
movq 0x18(%rax), %rcx
movq %rcx, -0x50(%rdx)
movq (%rax), %rcx
movq %rcx, -0x68(%rdx)
movl 0x8(%rax), %ecx
movl %ecx, -0x60(%rdx)
movl 0xc(%rax), %ecx
movl %ecx, -0x5c(%rdx)
xorl %r15d, %r15d
movb %r15b, -0x30(%rdx)
movups %xmm0, -0x2c(%rdx)
movl $0x0, -0x1c(%rdx)
movq %rdx, -0x18(%rdx)
movq %r15, -0x10(%rdx)
movl $0x2, %ecx
movq %rcx, -0x8(%rdx)
leaq 0x360(%rsp), %rdx
movq %rdx, -0x18(%rdx)
movq %r15, -0x10(%rdx)
movq $0x5, -0x8(%rdx)
leaq 0x3a0(%rsp), %rdx
movq %rdx, -0x18(%rdx)
movq %r15, -0x10(%rdx)
movq %rcx, -0x8(%rdx)
leaq 0x498(%rsp), %rdx
movq %rdx, -0x18(%rdx)
movq %r15, -0x10(%rdx)
movq %rcx, -0x8(%rdx)
movb %r15b, 0xf0(%rdx)
movups %xmm0, 0xe0(%rdx)
leaq 0xf0(%rsp), %rdx
movq %rax, -0x28(%rdx)
movq %r15, -0x20(%rdx)
movq %rdx, -0x18(%rdx)
movq %r15, -0x10(%rdx)
movq %rcx, -0x8(%rdx)
leaq 0x240(%rsp), %rax
movq %rax, 0x40(%rdx)
movb %r15b, 0x48(%rdx)
leaq 0x190(%rsp), %rax
movq %rax, -0x18(%rax)
movq %r15, -0x10(%rax)
movq %rcx, -0x8(%rax)
movq 0x90(%r12), %rbp
incq %rbp
cmpq %rcx, %rbp
jb 0x10de55
movq %r14, 0x30(%rsp)
movq %rbx, 0x38(%rsp)
shrq %rbp
xorl %r13d, %r13d
xorl %ebx, %ebx
movq %r12, %r14
movq 0x88(%r12), %rdi
addq %r13, %rdi
callq 0xa1cb9
movq (%rax), %rdi
leaq 0x140(%rsp), %rsi
xorl %edx, %edx
callq 0x1cdde8
movq %rax, %r12
movq %rax, %rdi
leaq 0x140(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1ce692
testb %al, %al
je 0x10de38
movq 0x8(%r12), %rdi
testl %r15d, %r15d
je 0x10ddda
callq 0x15ca6c
cmpl %eax, %r15d
je 0x10dde2
testb $0x1, %bl
jne 0x10dde2
movq 0x20(%r12), %rdx
movq 0x28(%r12), %rcx
leaq 0x140(%rsp), %rdi
movl $0x890006, %esi # imm = 0x890006
callq 0x160b40
movq %rax, %rbx
movq 0x8(%r12), %rdi
callq 0x15ca6c
movl %eax, %eax
movq %rax, 0x28(%rsp)
movq %rbx, %rdi
leaq 0x28(%rsp), %rsi
callq 0xeafd0
movl %r15d, %eax
movq %rax, 0x28(%rsp)
movq %rbx, %rdi
leaq 0x28(%rsp), %rsi
callq 0xeafd0
movb $0x1, %bl
jmp 0x10dde2
callq 0x15ca6c
movl %eax, %r15d
movq %r12, %rdi
movq %r12, %rsi
leaq 0xc8(%rsp), %rdx
callq 0x112d16
movq %r12, 0x28(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf1698
cmpq $0x0, 0xe0(%rsp)
je 0x10de38
leaq 0x178(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x10f304
movq $0x0, 0xe0(%rsp)
addq $0x30, %r13
decq %rbp
movq %r14, %r12
jne 0x10dd24
movl %ebx, %r15d
movq 0x38(%rsp), %rbx
movq 0x30(%rsp), %r14
movq (%rbx), %rsi
leaq 0x88(%rsp), %rdi
callq 0xf0296
movq %rax, %r12
movq %rdx, %r13
cmpb $0x0, 0x50(%r14)
jne 0x10de77
movb $0x1, 0x50(%r14)
movq %r12, 0x40(%r14)
movq %r13, 0x48(%r14)
testb $0x1, %r15b
jne 0x10e062
movq 0x180(%rsp), %rax
testq %rax, %rax
je 0x10e062
movq %rax, %rcx
decq %rcx
movq %rcx, 0x40(%rsp)
je 0x10e062
movq %r14, 0x30(%rsp)
movq %rbx, 0x38(%rsp)
movq (%rbx), %rcx
movq %rcx, 0x68(%rsp)
xorl %edx, %edx
movl %ecx, 0x24(%rsp)
movq %rax, 0x50(%rsp)
imulq $0x58, %rdx, %rsi
movq %rsi, 0x58(%rsp)
incq %rdx
movq %rdx, 0x48(%rsp)
movq %rdx, %rsi
movq 0x178(%rsp), %rdx
movq %rsi, 0x60(%rsp)
imulq $0x58, %rsi, %rdi
movq 0x58(%rsp), %rsi
movq (%rdx,%rsi), %rax
movq 0x8(%rdx,%rsi), %rsi
shlq $0x5, %rsi
addq %rax, %rsi
movq %rsi, 0x70(%rsp)
movq (%rdx,%rdi), %rsi
movq 0x8(%rdx,%rdi), %r13
shlq $0x5, %r13
addq %rsi, %r13
xorl %r14d, %r14d
cmpq 0x70(%rsp), %rax
je 0x10e02f
cmpq %r13, %rsi
je 0x10e02f
movq 0x10(%rax), %rdx
movq 0x18(%rax), %r8
movq 0x10(%rsi), %r15
movq 0x18(%rsi), %rdi
testb $0x1, %r14b
je 0x10df5f
testb $0x1, 0x24(%rsp)
je 0x10df56
xorl %r14d, %r14d
movq %rcx, %rdx
movq %rbp, %r8
jmp 0x10df5f
xorl %r14d, %r14d
movq %rcx, %r15
movq %rbp, %rdi
movq %r8, %r10
subq %rdx, %r10
leaq 0x1(%r10), %rbx
movq %rdi, %r9
subq %r15, %r9
leaq 0x1(%r9), %r11
cmpq %r11, %rbx
jae 0x10dfa0
movq %rdi, %rbp
subq %rbx, %rbp
testb $0x1, %r14b
movzbl %r14b, %r14d
movl $0x1, %ecx
cmovel %ecx, %r14d
leaq 0x20(%rax), %r12
movl $0x0, 0x24(%rsp)
movq %rsi, %rbx
jmp 0x10dfd8
leaq 0x20(%rsi), %rbx
cmpq %r9, %r10
jne 0x10dfb2
leaq 0x20(%rax), %r12
movq %rcx, %r15
jmp 0x10dfd8
movq %r8, %rbp
subq %r11, %rbp
movzbl %r14b, %r14d
testb $0x1, %r14b
movl $0x1, %ecx
cmovel %ecx, %r14d
movb $0x1, %cl
movl %ecx, 0x24(%rsp)
movq %rdx, %r15
movq %rax, %r12
movq %r9, %r10
movq %r8, %rcx
subq %r10, %rcx
movq (%rax), %rdx
movq 0x8(%rax), %r9
movq (%rsi), %rax
movq %rdi, %r11
subq %r10, %r11
movq %r11, 0x78(%rsp)
movq %rdi, 0x80(%rsp)
movq 0x8(%rsi), %rsi
movups 0x78(%rsp), %xmm0
movups %xmm0, 0x8(%rsp)
movq %rsi, 0x18(%rsp)
movq %rax, (%rsp)
movq 0x68(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x19b060
movq %r15, %rcx
movq %r12, %rax
movq %rbx, %rsi
jmp 0x10df1a
movq 0x60(%rsp), %rsi
incq %rsi
movq 0x50(%rsp), %rax
cmpq %rax, %rsi
jb 0x10dedc
movq 0x48(%rsp), %rdx
cmpq 0x40(%rsp), %rdx
jne 0x10dec8
movq 0x30(%rsp), %rax
movq 0x40(%rax), %r12
movq 0x48(%rax), %r13
leaq 0x388(%rsp), %rbx
leaq 0x480(%rsp), %r15
leaq 0x178(%rsp), %rdi
callq 0x1174cc
movq 0xd8(%rsp), %rdi
leaq 0xf0(%rsp), %rax
cmpq %rax, %rdi
je 0x10e099
callq 0xe17c0
leaq 0x290(%rsp), %r14
movq %r15, %rdi
callq 0x6aac8
movq %rbx, %rdi
callq 0x6aac8
movq 0xb8(%r14), %rdi
leaq 0x360(%rsp), %rax
cmpq %rax, %rdi
je 0x10e0ca
callq 0xe17c0
movq %r14, %rdi
callq 0x6ab56
movq 0x88(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x10e0ec
callq 0xe17c0
movq %r12, %rax
movq %r13, %rdx
addq $0x598, %rsp # imm = 0x598
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10e113
movq %rax, %rbx
jmp 0x10e14a
jmp 0x10e113
jmp 0x10e113
jmp 0x10e113
jmp 0x10e113
movq %rax, %rbx
leaq 0x178(%rsp), %rdi
callq 0x1174cc
movq 0xd8(%rsp), %rdi
leaq 0xf0(%rsp), %rax
cmpq %rax, %rdi
je 0x10e13d
callq 0xe17c0
leaq 0x240(%rsp), %rdi
callq 0x6aa86
movq 0x88(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x10e164
callq 0xe17c0
movq %rbx, %rdi
callq 0x37b10
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
slang::ast::NetAliasSymbol::serializeTo(slang::ast::ASTSerializer&) const
|
void NetAliasSymbol::serializeTo(ASTSerializer& serializer) const {
serializer.startArray("netReferences");
for (auto expr : getNetReferences())
serializer.serialize(*expr);
serializer.endArray();
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x26bbbc(%rip), %rdx # 0x379d3d
movl $0xd, %esi
movq %rbx, %rdi
callq 0x161e18
movq %r14, %rdi
callq 0x10db98
testq %rdx, %rdx
je 0x10e1bd
movq %rax, %r14
movq %rdx, %r15
shlq $0x3, %r15
xorl %r12d, %r12d
movq (%r14,%r12), %rsi
movq %rbx, %rdi
callq 0x161856
addq $0x8, %r12
cmpq %r12, %r15
jne 0x10e1a8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x161e30
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
slang::SmallVectorBase<slang::ast::PrimitivePortSymbol const*>::copy(slang::BumpAllocator&) const
|
[[nodiscard]] std::span<T> copy(BumpAllocator& alloc) const {
if (len == 0)
return {};
pointer dest = reinterpret_cast<pointer>(alloc.allocate(len * sizeof(T), alignof(T)));
std::ranges::uninitialized_copy(begin(), end(), dest, dest + len);
return std::span<T>(dest, len);
}
|
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x10e766
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdx
movq 0x8(%rdx), %rax
addq $0x7, %rax
andq $-0x8, %rax
leaq (%rax,%rcx,8), %rdi
cmpq 0x8(%rsi), %rdi
jbe 0x10e76c
shlq $0x3, %rcx
movl $0x8, %edx
movq %rsi, %rdi
movq %rcx, %rsi
callq 0xd7432
movq 0x8(%rbx), %rcx
jmp 0x10e770
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x10e794
movq %rdi, 0x8(%rdx)
testq %rcx, %rcx
jle 0x10e793
movq (%rbx), %rdx
leaq 0x1(%rcx), %rsi
xorl %edi, %edi
movq (%rdx,%rdi), %r8
movq %r8, (%rax,%rdi)
decq %rsi
addq $0x8, %rdi
cmpq $0x1, %rsi
ja 0x10e77e
popq %rbx
movq %rcx, %rdx
retq
|
/MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h
|
slang::ast::AssertionPortSymbol* slang::BumpAllocator::emplace<slang::ast::AssertionPortSymbol, std::basic_string_view<char, std::char_traits<char>>, slang::SourceLocation>(std::basic_string_view<char, std::char_traits<char>>&&, slang::SourceLocation&&)
|
T* emplace(Args&&... args) {
static_assert(std::is_trivially_destructible_v<T>);
return new (allocate(sizeof(T), alignof(T))) T(std::forward<Args>(args)...);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq (%rdi), %rax
movq 0x8(%rax), %rbx
addq $0x7, %rbx
andq $-0x8, %rbx
leaq 0x90(%rbx), %rcx
cmpq 0x8(%rdi), %rcx
jbe 0x10e877
movl $0x90, %esi
movl $0x8, %edx
callq 0xd7432
movq %rax, %rbx
jmp 0x10e87b
movq %rcx, 0x8(%rax)
movups (%r15), %xmm0
movq (%r14), %rax
movl $0x51, (%rbx)
movups %xmm0, 0x8(%rbx)
movq %rax, 0x18(%rbx)
xorl %r14d, %r14d
movq %r14, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movl $0x0, 0x30(%rbx)
leaq 0x40(%rbx), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x15abf4
movq %r14, 0x80(%rbx)
movb $0x0, 0x8c(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
|
/MikePopoloski[P]slang/source/../include/slang/util/BumpAllocator.h
|
slang::ast::SequenceSymbol* slang::BumpAllocator::emplace<slang::ast::SequenceSymbol, slang::ast::Compilation&, std::basic_string_view<char, std::char_traits<char>>, slang::SourceLocation>(slang::ast::Compilation&, std::basic_string_view<char, std::char_traits<char>>&&, slang::SourceLocation&&)
|
T* emplace(Args&&... args) {
static_assert(std::is_trivially_destructible_v<T>);
return new (allocate(sizeof(T), alignof(T))) T(std::forward<Args>(args)...);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %r14
addq $0x7, %r14
andq $-0x8, %r14
leaq 0x88(%r14), %rcx
cmpq 0x8(%rdi), %rcx
jbe 0x10e999
movl $0x88, %esi
movl $0x8, %edx
callq 0xd7432
movq %rax, %r14
jmp 0x10e99d
movq %rcx, 0x8(%rax)
movups (%r12), %xmm0
movq (%r15), %rax
movl $0x4f, (%r14)
movups %xmm0, 0x8(%r14)
movq %rax, 0x18(%r14)
movq $0x0, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
movl $0x0, 0x30(%r14)
leaq 0x40(%r14), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1ec9b0
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/MikePopoloski[P]slang/source/../include/slang/util/BumpAllocator.h
|
slang::ast::ClockingBlockSymbol* slang::BumpAllocator::emplace<slang::ast::ClockingBlockSymbol, slang::ast::Compilation&, std::basic_string_view<char, std::char_traits<char>>, slang::SourceLocation>(slang::ast::Compilation&, std::basic_string_view<char, std::char_traits<char>>&&, slang::SourceLocation&&)
|
T* emplace(Args&&... args) {
static_assert(std::is_trivially_destructible_v<T>);
return new (allocate(sizeof(T), alignof(T))) T(std::forward<Args>(args)...);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %r14
addq $0x7, %r14
andq $-0x8, %r14
leaq 0xc0(%r14), %rcx
cmpq 0x8(%rdi), %rcx
jbe 0x10ec85
movl $0xc0, %esi
movl $0x8, %edx
callq 0xd7432
movq %rax, %r14
jmp 0x10ec89
movq %rcx, 0x8(%rax)
movups (%r12), %xmm0
movq (%r15), %rax
movl $0x52, (%r14)
movups %xmm0, 0x8(%r14)
movq %rax, 0x18(%r14)
xorl %r15d, %r15d
movq %r15, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
movl $0x0, 0x30(%r14)
leaq 0x40(%r14), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1ec9b0
movq %r15, 0x78(%r14)
movb %r15b, 0x90(%r14)
movb %r15b, 0xa8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xb0(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/MikePopoloski[P]slang/source/../include/slang/util/BumpAllocator.h
|
slang::ast::RandSeqProductionSymbol* slang::BumpAllocator::emplace<slang::ast::RandSeqProductionSymbol, slang::ast::Compilation&, std::basic_string_view<char, std::char_traits<char>>, slang::SourceLocation>(slang::ast::Compilation&, std::basic_string_view<char, std::char_traits<char>>&&, slang::SourceLocation&&)
|
T* emplace(Args&&... args) {
static_assert(std::is_trivially_destructible_v<T>);
return new (allocate(sizeof(T), alignof(T))) T(std::forward<Args>(args)...);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %r12
addq $0x7, %r12
andq $-0x8, %r12
leaq 0xe0(%r12), %rcx
cmpq 0x8(%rdi), %rcx
jbe 0x10ed36
movl $0xe0, %esi
movl $0x8, %edx
callq 0xd7432
movq %rax, %r12
jmp 0x10ed3a
movq %rcx, 0x8(%rax)
movq (%r15), %rdx
movq 0x8(%r15), %rcx
movq (%r14), %r8
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10bc9c
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/MikePopoloski[P]slang/source/../include/slang/util/BumpAllocator.h
|
slang::SmallVectorBase<slang::ast::RandSeqProductionSymbol::Rule>::copy(slang::BumpAllocator&) const
|
[[nodiscard]] std::span<T> copy(BumpAllocator& alloc) const {
if (len == 0)
return {};
pointer dest = reinterpret_cast<pointer>(alloc.allocate(len * sizeof(T), alignof(T)));
std::ranges::uninitialized_copy(begin(), end(), dest, dest + len);
return std::span<T>(dest, len);
}
|
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x10ede8
pushq %rbx
movq %rdi, %rbx
shlq $0x3, %rax
leaq (%rax,%rax,8), %r8
movq (%rsi), %rcx
movq 0x8(%rcx), %rax
addq $0x7, %rax
andq $-0x8, %rax
leaq (%rax,%r8), %rdx
cmpq 0x8(%rsi), %rdx
jbe 0x10eded
movl $0x8, %edx
movq %rsi, %rdi
movq %r8, %rsi
callq 0xd7432
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x10ee2a
movq (%rbx), %r9
shlq $0x3, %rcx
leaq (%rcx,%rcx,8), %rcx
leaq (%r9,%rcx), %r8
movq %rax, %rdx
addq %rcx, %rdx
jmp 0x10edf7
xorl %eax, %eax
xorl %edx, %edx
retq
movq %rdx, 0x8(%rcx)
movq (%rbx), %r9
addq %r9, %r8
addq $0x48, %r9
leaq 0x48(%rax), %r10
leaq -0x48(%r9), %rsi
leaq -0x48(%r10), %rdi
movl $0x9, %ecx
rep movsq (%rsi), %es:(%rdi)
cmpq %r8, %r9
je 0x10ee24
addq $0x48, %r9
leaq 0x48(%r10), %rcx
cmpq %rdx, %r10
movq %rcx, %r10
jne 0x10edff
movq 0x8(%rbx), %rdx
popq %rbx
retq
xorl %edx, %edx
jmp 0x10ee28
|
/MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h
|
slang::ast::RandSeqProductionSymbol::RepeatProd* slang::BumpAllocator::emplace<slang::ast::RandSeqProductionSymbol::RepeatProd, slang::ast::Expression const&, slang::ast::RandSeqProductionSymbol::ProdItem&>(slang::ast::Expression const&, slang::ast::RandSeqProductionSymbol::ProdItem&)
|
T* emplace(Args&&... args) {
static_assert(std::is_trivially_destructible_v<T>);
return new (allocate(sizeof(T), alignof(T))) T(std::forward<Args>(args)...);
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdi), %rcx
movq 0x8(%rcx), %rax
addq $0x7, %rax
andq $-0x8, %rax
leaq 0x30(%rax), %rdx
cmpq 0x8(%rdi), %rdx
jbe 0x10f0d1
movl $0x30, %esi
movl $0x8, %edx
callq 0xd7432
jmp 0x10f0d5
movq %rdx, 0x8(%rcx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x3, (%rax)
movq %rbx, 0x8(%rax)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movups %xmm0, 0x10(%rax)
movups %xmm1, 0x20(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
|
/MikePopoloski[P]slang/source/../include/slang/util/BumpAllocator.h
|
slang::ast::Type::isNumeric() const
|
bool isNumeric() const { return isIntegral() || isFloating(); }
|
pushq %rbx
movq %rdi, %rbx
callq 0x15cad8
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x10f136
movq 0x40(%rbx), %rax
testq %rax, %rax
jne 0x10f130
movq %rbx, %rdi
callq 0x15f6a6
movq 0x40(%rbx), %rax
cmpl $0x9, (%rax)
sete %al
popq %rbx
retq
|
/MikePopoloski[P]slang/source/../include/slang/ast/types/Type.h
|
slang::SmallVectorBase<slang::ast::RandSeqProductionSymbol::ProdBase const*>::copy(slang::BumpAllocator&) const
|
[[nodiscard]] std::span<T> copy(BumpAllocator& alloc) const {
if (len == 0)
return {};
pointer dest = reinterpret_cast<pointer>(alloc.allocate(len * sizeof(T), alignof(T)));
std::ranges::uninitialized_copy(begin(), end(), dest, dest + len);
return std::span<T>(dest, len);
}
|
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x10f178
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdx
movq 0x8(%rdx), %rax
addq $0x7, %rax
andq $-0x8, %rax
leaq (%rax,%rcx,8), %rdi
cmpq 0x8(%rsi), %rdi
jbe 0x10f17e
shlq $0x3, %rcx
movl $0x8, %edx
movq %rsi, %rdi
movq %rcx, %rsi
callq 0xd7432
movq 0x8(%rbx), %rcx
jmp 0x10f182
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x10f1a6
movq %rdi, 0x8(%rdx)
testq %rcx, %rcx
jle 0x10f1a5
movq (%rbx), %rdx
leaq 0x1(%rcx), %rsi
xorl %edi, %edi
movq (%rdx,%rdi), %r8
movq %r8, (%rax,%rdi)
decq %rsi
addq $0x8, %rdi
cmpq $0x1, %rsi
ja 0x10f190
popq %rbx
movq %rcx, %rdx
retq
|
/MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h
|
slang::SmallVector<slang::ast::NetAlias, 2ul>& slang::SmallVectorBase<slang::SmallVector<slang::ast::NetAlias, 2ul>>::emplace_back<slang::SmallVector<slang::ast::NetAlias, 2ul>>(slang::SmallVector<slang::ast::NetAlias, 2ul>&&)
|
reference emplace_back(Args&&... args) {
if (len == cap)
return *emplaceRealloc(end(), std::forward<Args>(args)...);
new (end()) T(std::forward<Args>(args)...);
len++;
return back();
}
|
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
imulq $0x58, %rax, %rsi
addq (%rdi), %rsi
cmpq 0x10(%rdi), %rax
jne 0x10f325
movq %rbx, %rdi
popq %rbx
jmp 0x118976
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x118aaa
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rbx)
imulq $0x58, %rax, %rax
addq (%rbx), %rax
popq %rbx
retq
nop
|
/MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h
|
void slang::ast::ExpressionVarVisitor::visit<slang::ast::InvalidExpression>(slang::ast::InvalidExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::HierarchicalValue: {
if (auto sym = expr.getSymbolReference()) {
if (VariableSymbol::isKind(sym->kind))
anyVars = true;
}
break;
}
default:
if constexpr (HasVisitExprs<T, ExpressionVarVisitor>) {
expr.visitExprs(*this);
}
break;
}
}
}
|
movl (%rsi), %eax
andl $-0x2, %eax
cmpl $0x8, %eax
jne 0x10f4d8
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x10f4d7
movl (%rax), %eax
addl $-0x3c, %eax
cmpl $0x18, %eax
ja 0x10f4d7
movl $0x1800c0f, %ecx # imm = 0x1800C0F
btl %eax, %ecx
jae 0x10f4d7
movb $0x1, (%rbx)
popq %rbx
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::ExpressionVarVisitor::visit<slang::ast::RealLiteral>(slang::ast::RealLiteral const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::HierarchicalValue: {
if (auto sym = expr.getSymbolReference()) {
if (VariableSymbol::isKind(sym->kind))
anyVars = true;
}
break;
}
default:
if constexpr (HasVisitExprs<T, ExpressionVarVisitor>) {
expr.visitExprs(*this);
}
break;
}
}
}
|
movl (%rsi), %eax
andl $-0x2, %eax
cmpl $0x8, %eax
jne 0x10f54c
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x10f54b
movl (%rax), %eax
addl $-0x3c, %eax
cmpl $0x18, %eax
ja 0x10f54b
movl $0x1800c0f, %ecx # imm = 0x1800C0F
btl %eax, %ecx
jae 0x10f54b
movb $0x1, (%rbx)
popq %rbx
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::ExpressionVarVisitor::visit<slang::ast::NamedValueExpression>(slang::ast::NamedValueExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::HierarchicalValue: {
if (auto sym = expr.getSymbolReference()) {
if (VariableSymbol::isKind(sym->kind))
anyVars = true;
}
break;
}
default:
if constexpr (HasVisitExprs<T, ExpressionVarVisitor>) {
expr.visitExprs(*this);
}
break;
}
}
}
|
movl (%rsi), %eax
andl $-0x2, %eax
cmpl $0x8, %eax
jne 0x10f6a8
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x10f6a7
movl (%rax), %eax
addl $-0x3c, %eax
cmpl $0x18, %eax
ja 0x10f6a7
movl $0x1800c0f, %ecx # imm = 0x1800C0F
btl %eax, %ecx
jae 0x10f6a7
movb $0x1, (%rbx)
popq %rbx
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::ExpressionVarVisitor::visit<slang::ast::BinaryExpression>(slang::ast::BinaryExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::HierarchicalValue: {
if (auto sym = expr.getSymbolReference()) {
if (VariableSymbol::isKind(sym->kind))
anyVars = true;
}
break;
}
default:
if constexpr (HasVisitExprs<T, ExpressionVarVisitor>) {
expr.visitExprs(*this);
}
break;
}
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
andl $-0x2, %eax
cmpl $0x8, %eax
jne 0x10f773
movq %r14, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x10f76b
movl (%rax), %eax
addl $-0x3c, %eax
cmpl $0x18, %eax
ja 0x10f76b
movl $0x1800c0f, %ecx # imm = 0x1800C0F
btl %eax, %ecx
jae 0x10f76b
movb $0x1, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x30(%r14), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
callq 0x10f346
movq 0x38(%r14), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10f346
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::ExpressionVarVisitor::visit<slang::ast::AssignmentExpression>(slang::ast::AssignmentExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::HierarchicalValue: {
if (auto sym = expr.getSymbolReference()) {
if (VariableSymbol::isKind(sym->kind))
anyVars = true;
}
break;
}
default:
if constexpr (HasVisitExprs<T, ExpressionVarVisitor>) {
expr.visitExprs(*this);
}
break;
}
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
andl $-0x2, %eax
cmpl $0x8, %eax
jne 0x10f861
movq %r14, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x10f859
movl (%rax), %eax
addl $-0x3c, %eax
cmpl $0x18, %eax
ja 0x10f859
movl $0x1800c0f, %ecx # imm = 0x1800C0F
btl %eax, %ecx
jae 0x10f859
movb $0x1, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x40(%r14), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
callq 0x10f346
movq 0x48(%r14), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10f346
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::ExpressionVarVisitor::visit<slang::ast::ReplicationExpression>(slang::ast::ReplicationExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::HierarchicalValue: {
if (auto sym = expr.getSymbolReference()) {
if (VariableSymbol::isKind(sym->kind))
anyVars = true;
}
break;
}
default:
if constexpr (HasVisitExprs<T, ExpressionVarVisitor>) {
expr.visitExprs(*this);
}
break;
}
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
andl $-0x2, %eax
cmpl $0x8, %eax
jne 0x10f943
movq %r14, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x10f93b
movl (%rax), %eax
addl $-0x3c, %eax
cmpl $0x18, %eax
ja 0x10f93b
movl $0x1800c0f, %ecx # imm = 0x1800C0F
btl %eax, %ecx
jae 0x10f93b
movb $0x1, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x30(%r14), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
callq 0x10f346
movq 0x38(%r14), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10f346
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::ExpressionVarVisitor::visit<slang::ast::CallExpression>(slang::ast::CallExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::HierarchicalValue: {
if (auto sym = expr.getSymbolReference()) {
if (VariableSymbol::isKind(sym->kind))
anyVars = true;
}
break;
}
default:
if constexpr (HasVisitExprs<T, ExpressionVarVisitor>) {
expr.visitExprs(*this);
}
break;
}
}
}
|
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %eax
andl $-0x2, %eax
movq %rsi, %rdi
cmpl $0x8, %eax
jne 0x10fad9
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x10fad7
movl (%rax), %eax
addl $-0x3c, %eax
cmpl $0x18, %eax
ja 0x10fad7
movl $0x1800c0f, %ecx # imm = 0x1800C0F
btl %eax, %ecx
jae 0x10fad7
movb $0x1, (%rbx)
popq %rbx
retq
movq %rbx, %rsi
popq %rbx
jmp 0x1101e4
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::ExpressionVarVisitor::visit<slang::ast::ArbitrarySymbolExpression>(slang::ast::ArbitrarySymbolExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::HierarchicalValue: {
if (auto sym = expr.getSymbolReference()) {
if (VariableSymbol::isKind(sym->kind))
anyVars = true;
}
break;
}
default:
if constexpr (HasVisitExprs<T, ExpressionVarVisitor>) {
expr.visitExprs(*this);
}
break;
}
}
}
|
movl (%rsi), %eax
andl $-0x2, %eax
cmpl $0x8, %eax
jne 0x10fbd8
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x10fbd7
movl (%rax), %eax
addl $-0x3c, %eax
cmpl $0x18, %eax
ja 0x10fbd7
movl $0x1800c0f, %ecx # imm = 0x1800C0F
btl %eax, %ecx
jae 0x10fbd7
movb $0x1, (%rbx)
popq %rbx
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::ExpressionVarVisitor::visit<slang::ast::LValueReferenceExpression>(slang::ast::LValueReferenceExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::HierarchicalValue: {
if (auto sym = expr.getSymbolReference()) {
if (VariableSymbol::isKind(sym->kind))
anyVars = true;
}
break;
}
default:
if constexpr (HasVisitExprs<T, ExpressionVarVisitor>) {
expr.visitExprs(*this);
}
break;
}
}
}
|
movl (%rsi), %eax
andl $-0x2, %eax
cmpl $0x8, %eax
jne 0x10fc12
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x10fc11
movl (%rax), %eax
addl $-0x3c, %eax
cmpl $0x18, %eax
ja 0x10fc11
movl $0x1800c0f, %ecx # imm = 0x1800C0F
btl %eax, %ecx
jae 0x10fc11
movb $0x1, (%rbx)
popq %rbx
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::ExpressionVarVisitor::visit<slang::ast::DistExpression>(slang::ast::DistExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::HierarchicalValue: {
if (auto sym = expr.getSymbolReference()) {
if (VariableSymbol::isKind(sym->kind))
anyVars = true;
}
break;
}
default:
if constexpr (HasVisitExprs<T, ExpressionVarVisitor>) {
expr.visitExprs(*this);
}
break;
}
}
}
|
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %eax
andl $-0x2, %eax
movq %rsi, %rdi
cmpl $0x8, %eax
jne 0x10fe35
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x10fe33
movl (%rax), %eax
addl $-0x3c, %eax
cmpl $0x18, %eax
ja 0x10fe33
movl $0x1800c0f, %ecx # imm = 0x1800C0F
btl %eax, %ecx
jae 0x10fe33
movb $0x1, (%rbx)
popq %rbx
retq
movq %rbx, %rsi
popq %rbx
jmp 0x110378
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::ExpressionVarVisitor::visit<slang::ast::MinTypMaxExpression>(slang::ast::MinTypMaxExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::HierarchicalValue: {
if (auto sym = expr.getSymbolReference()) {
if (VariableSymbol::isKind(sym->kind))
anyVars = true;
}
break;
}
default:
if constexpr (HasVisitExprs<T, ExpressionVarVisitor>) {
expr.visitExprs(*this);
}
break;
}
}
}
|
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %eax
andl $-0x2, %eax
movq %rsi, %rdi
cmpl $0x8, %eax
jne 0x10ffcb
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x10ffc9
movl (%rax), %eax
addl $-0x3c, %eax
cmpl $0x18, %eax
ja 0x10ffc9
movl $0x1800c0f, %ecx # imm = 0x1800C0F
btl %eax, %ecx
jae 0x10ffc9
movb $0x1, (%rbx)
popq %rbx
retq
movq %rbx, %rsi
popq %rbx
jmp 0x110450
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::ExpressionVarVisitor::visit<slang::ast::ClockingEventExpression>(slang::ast::ClockingEventExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::HierarchicalValue: {
if (auto sym = expr.getSymbolReference()) {
if (VariableSymbol::isKind(sym->kind))
anyVars = true;
}
break;
}
default:
if constexpr (HasVisitExprs<T, ExpressionVarVisitor>) {
expr.visitExprs(*this);
}
break;
}
}
}
|
movl (%rsi), %eax
andl $-0x2, %eax
cmpl $0x8, %eax
jne 0x11000c
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x11000b
movl (%rax), %eax
addl $-0x3c, %eax
cmpl $0x18, %eax
ja 0x11000b
movl $0x1800c0f, %ecx # imm = 0x1800C0F
btl %eax, %ecx
jae 0x11000b
movb $0x1, (%rbx)
popq %rbx
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::BitTrie::nextNodesFor<slang::ast::BitTrie, void slang::ast::BitTrie::insert<slang::PoolAllocator<slang::ast::BitTrie, 72ul, 8ul>>(slang::syntax::UdpEntrySyntax const&, std::span<char const, 18446744073709551615ul>, char, slang::PoolAllocator<slang::ast::BitTrie, 72ul, 8ul>&, slang::SmallVector<slang::syntax::UdpEntrySyntax const*, 5ul>&)::'lambda'(slang::ast::BitTrie const&, slang::SmallVector<slang::ast::BitTrie*, 5ul>&, int, bool)&>(char, slang::SmallVector<slang::PoolAllocator<slang::ast::BitTrie, 72ul, 8ul>*, detail::calculateDefaultSmallVectorElems<slang::PoolAllocator<slang::ast::BitTrie, 72ul, 8ul>*>()>&, void slang::ast::BitTrie::insert<slang::PoolAllocator<slang::ast::BitTrie, 72ul, 8ul>>(slang::syntax::UdpEntrySyntax const&, std::span<char const, 18446744073709551615ul>, char, slang::PoolAllocator<slang::ast::BitTrie, 72ul, 8ul>&, slang::SmallVector<slang::syntax::UdpEntrySyntax const*, 5ul>&)::'lambda'(slang::ast::BitTrie const&, slang::SmallVector<slang::ast::BitTrie*, 5ul>&, int, bool)&) const
|
void nextNodesFor(char c, SmallVector<TNode*>& nextNodes, TCallback&& callback) const {
// Map the character to one or more of our child entries.
// The "primary" entry is the one that directly matches the
// character, and there can be several secondary entries that
// can match based on wildcard values.
auto handle = [&](int index, bool primary = false) {
callback(*this, nextNodes, index, primary);
};
switch (c) {
case '0':
handle(0, true);
handle(3);
handle(4);
handle(6);
break;
case '1':
handle(1, true);
handle(3);
handle(4);
handle(7);
break;
case 'x':
handle(2, true);
handle(3);
handle(6);
handle(7);
break;
case '?':
handle(3, true);
handle(0);
handle(1);
handle(2);
handle(4);
handle(6);
handle(7);
break;
case 'b':
handle(4, true);
handle(0);
handle(1);
handle(3);
break;
case '(':
case '*':
case 'r':
case 'f':
case 'p':
case 'n':
handle(5, true);
break;
// Below are implicit node identifiers that cannot be found in the UDP grammar. They are
// helpers for `p` and `n`.
case '6':
// Handling `0` or `x`.
handle(6, true);
handle(0);
handle(2);
handle(3);
break;
case '7':
// Handling `1` or `x` (for `p` and `n` matching cases).
handle(7, true);
handle(1);
handle(2);
handle(3);
break;
default:
// On error clear all nodes. Assume someone else
// (the parser) has reported the error already.
nextNodes.clear();
break;
}
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x3e, %esi
jle 0x110e4b
leal -0x62(%rsi), %eax
cmpl $0x16, %eax
ja 0x110efb
movl $0x15010, %ecx # imm = 0x15010
btl %eax, %ecx
jb 0x110e63
testl %eax, %eax
je 0x11107d
cmpl $0x16, %eax
jne 0x110efb
movq (%r15), %rcx
cmpq %rbx, (%rcx)
jne 0x110e24
movq 0x10(%rbx), %rax
testq %rax, %rax
jne 0x110e21
movq 0x8(%r15), %rdi
callq 0x11114e
movq %rax, 0x10(%rbx)
movq (%r15), %rcx
movq %rax, (%rcx)
cmpq $0x0, 0x10(%rbx)
je 0x110e37
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x1111ae
cmpq $0x0, 0x18(%rbx)
je 0x110f85
leaq 0x18(%rbx), %rsi
jmp 0x110f7d
leal -0x28(%rsi), %eax
cmpl $0x9, %eax
ja 0x110e9b
leaq 0x268cee(%rip), %rcx # 0x379b48
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%r15), %rcx
cmpq %rbx, (%rcx)
jne 0x110e87
movq 0x28(%rbx), %rax
testq %rax, %rax
jne 0x110e84
movq 0x8(%r15), %rdi
callq 0x11114e
movq %rax, 0x28(%rbx)
movq (%r15), %rcx
movq %rax, (%rcx)
cmpq $0x0, 0x28(%rbx)
je 0x111148
addq $0x28, %rbx
jmp 0x111138
cmpl $0x36, %esi
je 0x1110d2
cmpl $0x37, %esi
jne 0x110f92
movq (%r15), %rcx
cmpq %rbx, (%rcx)
jne 0x110ed1
movq 0x38(%rbx), %rax
testq %rax, %rax
jne 0x110ece
movq 0x8(%r15), %rdi
callq 0x11114e
movq %rax, 0x38(%rbx)
movq (%r15), %rcx
movq %rax, (%rcx)
cmpq $0x0, 0x38(%rbx)
je 0x110ee4
leaq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0x1111ae
cmpq $0x0, 0x8(%rbx)
je 0x11111a
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
jmp 0x111115
cmpl $0x3f, %esi
jne 0x110f92
movq (%r15), %rcx
cmpq %rbx, (%rcx)
jne 0x110f28
movq 0x18(%rbx), %rax
testq %rax, %rax
jne 0x110f25
movq 0x8(%r15), %rdi
callq 0x11114e
movq %rax, 0x18(%rbx)
movq (%r15), %rcx
movq %rax, (%rcx)
cmpq $0x0, 0x18(%rbx)
je 0x110f3b
leaq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x1111ae
cmpq $0x0, (%rbx)
je 0x110f4c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1111ae
cmpq $0x0, 0x8(%rbx)
je 0x110f5f
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1111ae
cmpq $0x0, 0x10(%rbx)
je 0x110f72
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x1111ae
cmpq $0x0, 0x20(%rbx)
je 0x110f85
leaq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x1111ae
cmpq $0x0, 0x30(%rbx)
je 0x110ffc
leaq 0x30(%rbx), %rsi
jmp 0x110ff4
movq $0x0, 0x8(%r14)
jmp 0x111148
movq (%r15), %rcx
cmpq %rbx, (%rcx)
jne 0x110fc3
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x110fc0
movq 0x8(%r15), %rdi
callq 0x11114e
movq %rax, 0x8(%rbx)
movq (%r15), %rcx
movq %rax, (%rcx)
cmpq $0x0, 0x8(%rbx)
je 0x110fd6
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1111ae
cmpq $0x0, 0x18(%rbx)
je 0x110fe9
leaq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x1111ae
cmpq $0x0, 0x20(%rbx)
je 0x110ffc
leaq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x1111ae
cmpq $0x0, 0x38(%rbx)
je 0x111148
addq $0x38, %rbx
jmp 0x111138
movq (%r15), %rcx
cmpq %rbx, (%rcx)
jne 0x111032
movq (%rbx), %rax
testq %rax, %rax
jne 0x11102f
movq 0x8(%r15), %rdi
callq 0x11114e
movq %rax, (%rbx)
movq (%r15), %rcx
movq %rax, (%rcx)
cmpq $0x0, (%rbx)
je 0x111043
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1111ae
cmpq $0x0, 0x18(%rbx)
je 0x111056
leaq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x1111ae
cmpq $0x0, 0x20(%rbx)
je 0x111069
leaq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x1111ae
cmpq $0x0, 0x30(%rbx)
je 0x111148
addq $0x30, %rbx
jmp 0x111138
movq (%r15), %rcx
cmpq %rbx, (%rcx)
jne 0x1110a1
movq 0x20(%rbx), %rax
testq %rax, %rax
jne 0x11109e
movq 0x8(%r15), %rdi
callq 0x11114e
movq %rax, 0x20(%rbx)
movq (%r15), %rcx
movq %rax, (%rcx)
cmpq $0x0, 0x20(%rbx)
je 0x1110b4
leaq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x1111ae
cmpq $0x0, (%rbx)
je 0x1110c5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1111ae
cmpq $0x0, 0x8(%rbx)
je 0x11112d
leaq 0x8(%rbx), %rsi
jmp 0x111125
movq (%r15), %rcx
cmpq %rbx, (%rcx)
jne 0x1110f6
movq 0x30(%rbx), %rax
testq %rax, %rax
jne 0x1110f3
movq 0x8(%r15), %rdi
callq 0x11114e
movq %rax, 0x30(%rbx)
movq (%r15), %rcx
movq %rax, (%rcx)
cmpq $0x0, 0x30(%rbx)
je 0x111109
leaq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0x1111ae
cmpq $0x0, (%rbx)
je 0x11111a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1111ae
cmpq $0x0, 0x10(%rbx)
je 0x11112d
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x1111ae
cmpq $0x0, 0x18(%rbx)
je 0x111148
addq $0x18, %rbx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1111ae
popq %rbx
popq %r14
popq %r15
retq
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
slang::SmallVectorBase<slang::ast::BitTrie*>::operator=(slang::SmallVectorBase<slang::ast::BitTrie*>&&)
|
SmallVectorBase<T>& SmallVectorBase<T>::operator=(SmallVectorBase<T>&& rhs) {
if (this == &rhs)
return *this;
// If the rhs isn't small, clear this vector and then steal its buffer.
if (!rhs.isSmall()) {
cleanup();
this->data_ = std::exchange(rhs.data_, nullptr);
this->len = std::exchange(rhs.len, 0);
this->cap = std::exchange(rhs.cap, 0);
return *this;
}
// If we already have sufficient space assign the common elements,
// then destroy any excess.
if (len >= rhs.size()) {
iterator newEnd;
if (rhs.size())
newEnd = std::ranges::move(rhs, begin()).out;
else
newEnd = begin();
std::ranges::destroy(newEnd, end());
len = rhs.size();
rhs.clear();
return *this;
}
if (capacity() < rhs.size()) {
// If we have to grow to have enough elements, destroy the current elements.
// This allows us to avoid copying them during the grow.
clear();
reserve(rhs.size());
}
else if (len) {
// Otherwise, use assignment for the already-constructed elements.
std::ranges::move(rhs.begin(), rhs.begin() + len, begin());
}
// Move construct the new elements in place.
std::uninitialized_move(rhs.begin() + len, rhs.end(), begin() + len);
len = rhs.size();
rhs.clear();
return *this;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1113d4
movq %rsi, %r14
movq (%rsi), %rsi
leaq 0x18(%r14), %rax
cmpq %rax, %rsi
je 0x11134e
movq (%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x111329
callq 0xe17c0
movq (%r14), %rsi
xorl %eax, %eax
movq %rax, (%r14)
movq %rsi, (%rbx)
movq 0x8(%r14), %rcx
movq %rax, 0x8(%r14)
movq %rcx, 0x8(%rbx)
movq 0x10(%r14), %rcx
movq %rax, 0x10(%r14)
movq %rcx, 0x10(%rbx)
jmp 0x1113d4
movq 0x8(%rbx), %rdx
movq 0x8(%r14), %rax
cmpq %rax, %rdx
jae 0x111377
cmpq %rax, 0x10(%rbx)
jae 0x111388
movq $0x0, 0x8(%rbx)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x1113e0
jmp 0x111399
testq %rax, %rax
je 0x1113c6
movq (%rbx), %rdi
shlq $0x3, %rax
movq %rax, %rdx
jmp 0x1113bb
testq %rdx, %rdx
je 0x111399
shlq $0x3, %rdx
movq (%rbx), %rdi
callq 0x379e0
movq 0x8(%rbx), %rdi
shlq $0x3, %rdi
movq 0x8(%r14), %rax
leaq (,%rax,8), %rdx
subq %rdi, %rdx
je 0x1113c8
movq (%r14), %rsi
addq %rdi, %rsi
addq (%rbx), %rdi
callq 0x379e0
movq 0x8(%r14), %rax
jmp 0x1113c8
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq $0x0, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h
|
void slang::ast::BitTrie::traverse<slang::ast::BitTrie const, slang::ast::BitTrie::contains(std::span<char const, 18446744073709551615ul>, char) const::'lambda'(slang::ast::BitTrie const&, slang::SmallVector<slang::ast::BitTrie const*, 5ul>&, int, bool)&>(slang::SmallVector<slang::ast::BitTrie const*, detail::calculateDefaultSmallVectorElems<slang::ast::BitTrie const*>()>&, std::span<char const, 18446744073709551615ul>, char, slang::ast::BitTrie::contains(std::span<char const, 18446744073709551615ul>, char) const::'lambda'(slang::ast::BitTrie const&, slang::SmallVector<slang::ast::BitTrie const*, 5ul>&, int, bool)&) const
|
void traverse(SmallVector<TNode*>& nodes, std::span<const char> inputs, char stateChar,
TCallback&& callback) const {
auto advance = [&](char c) {
SmallVector<TNode*> nextNodes;
for (auto node : nodes)
node->nextNodesFor(c, nextNodes, callback);
nodes = std::move(nextNodes);
};
for (char c : inputs) {
// Skip the closing paren, since it doesn't add
// any additional signal to the bitstring.
if (c == ')')
continue;
// Advance along the path.
advance(c);
// Check if we need special handling for this character.
switch (c) {
case '*':
advance('?');
advance('?');
break;
case 'r':
advance('0');
advance('1');
break;
case 'f':
advance('1');
advance('0');
break;
case 'p':
advance('6');
advance('7');
break;
case 'n':
advance('7');
advance('6');
break;
default:
break;
}
}
// Include the state field if present.
if (stateChar)
advance(stateChar);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %r14
movl %r8d, 0x5c(%rsp)
movq %rsi, 0x8(%rsp)
movq %rcx, 0x60(%rsp)
testq %rcx, %rcx
je 0x111d56
movq %rdx, %r15
addq %rdx, 0x60(%rsp)
leaq 0x28(%rsp), %rbx
leaq 0x10(%rsp), %r13
movzbl (%r15), %ebp
cmpl $0x29, %ebp
je 0x111d48
movq %r15, 0x50(%rsp)
movq %rbx, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x5, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x1118af
movq 0x8(%rsp), %rax
movq (%rax), %rbx
shlq $0x3, %r15
xorl %r12d, %r12d
movq (%rbx,%r12), %rdi
movsbl %bpl, %esi
movq %r13, %rdx
movq %r14, %rcx
callq 0x111f7c
addq $0x8, %r12
cmpq %r12, %r15
jne 0x111893
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x112328
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rbx
cmpq %rbx, %rdi
movq 0x50(%rsp), %r15
je 0x1118d5
callq 0xe17c0
cmpl $0x6d, %ebp
jle 0x1119ce
cmpl $0x6e, %ebp
je 0x111ab5
cmpl $0x70, %ebp
je 0x111b8a
cmpl $0x72, %ebp
jne 0x111d48
movq %rbx, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x5, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x11194a
movq 0x8(%rsp), %rax
movq (%rax), %rbx
shlq $0x3, %r15
xorl %r12d, %r12d
movq (%rbx,%r12), %rdi
movl $0x30, %esi
movq %r13, %rdx
movq %r14, %rcx
callq 0x111f7c
addq $0x8, %r12
cmpq %r12, %r15
jne 0x11192d
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x112328
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rbx
cmpq %rbx, %rdi
je 0x11196b
callq 0xe17c0
movq %rbx, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x5, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x1119bc
movq 0x8(%rsp), %rax
movq (%rax), %rbx
shlq $0x3, %r15
xorl %r12d, %r12d
movq (%rbx,%r12), %rdi
movl $0x31, %esi
movq %r13, %rdx
movq %r14, %rcx
callq 0x111f7c
addq $0x8, %r12
cmpq %r12, %r15
jne 0x11199f
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x112328
jmp 0x111d2f
cmpl $0x2a, %ebp
je 0x111c5f
cmpl $0x66, %ebp
jne 0x111d48
movq %rbx, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x5, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x111a31
movq 0x8(%rsp), %rax
movq (%rax), %rbx
shlq $0x3, %r15
xorl %r12d, %r12d
movq (%rbx,%r12), %rdi
movl $0x31, %esi
movq %r13, %rdx
movq %r14, %rcx
callq 0x111f7c
addq $0x8, %r12
cmpq %r12, %r15
jne 0x111a14
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x112328
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rbx
cmpq %rbx, %rdi
je 0x111a52
callq 0xe17c0
movq %rbx, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x5, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x111aa3
movq 0x8(%rsp), %rax
movq (%rax), %rbx
shlq $0x3, %r15
xorl %r12d, %r12d
movq (%rbx,%r12), %rdi
movl $0x30, %esi
movq %r13, %rdx
movq %r14, %rcx
callq 0x111f7c
addq $0x8, %r12
cmpq %r12, %r15
jne 0x111a86
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x112328
jmp 0x111d2f
movq %rbx, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x5, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x111b06
movq 0x8(%rsp), %rax
movq (%rax), %rbx
shlq $0x3, %r15
xorl %r12d, %r12d
movq (%rbx,%r12), %rdi
movl $0x37, %esi
movq %r13, %rdx
movq %r14, %rcx
callq 0x111f7c
addq $0x8, %r12
cmpq %r12, %r15
jne 0x111ae9
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x112328
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rbx
cmpq %rbx, %rdi
je 0x111b27
callq 0xe17c0
movq %rbx, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x5, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x111b78
movq 0x8(%rsp), %rax
movq (%rax), %rbx
shlq $0x3, %r15
xorl %r12d, %r12d
movq (%rbx,%r12), %rdi
movl $0x36, %esi
movq %r13, %rdx
movq %r14, %rcx
callq 0x111f7c
addq $0x8, %r12
cmpq %r12, %r15
jne 0x111b5b
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x112328
jmp 0x111d2f
movq %rbx, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x5, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x111bdb
movq 0x8(%rsp), %rax
movq (%rax), %rbx
shlq $0x3, %r15
xorl %r12d, %r12d
movq (%rbx,%r12), %rdi
movl $0x36, %esi
movq %r13, %rdx
movq %r14, %rcx
callq 0x111f7c
addq $0x8, %r12
cmpq %r12, %r15
jne 0x111bbe
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x112328
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rbx
cmpq %rbx, %rdi
je 0x111bfc
callq 0xe17c0
movq %rbx, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x5, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x111c4d
movq 0x8(%rsp), %rax
movq (%rax), %rbx
shlq $0x3, %r15
xorl %r12d, %r12d
movq (%rbx,%r12), %rdi
movl $0x37, %esi
movq %r13, %rdx
movq %r14, %rcx
callq 0x111f7c
addq $0x8, %r12
cmpq %r12, %r15
jne 0x111c30
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x112328
jmp 0x111d2f
movq %rbx, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x5, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x111cb0
movq 0x8(%rsp), %rax
movq (%rax), %rbx
shlq $0x3, %r15
xorl %r12d, %r12d
movq (%rbx,%r12), %rdi
movl $0x3f, %esi
movq %r13, %rdx
movq %r14, %rcx
callq 0x111f7c
addq $0x8, %r12
cmpq %r12, %r15
jne 0x111c93
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x112328
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rbx
cmpq %rbx, %rdi
je 0x111cd1
callq 0xe17c0
movq %rbx, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x5, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x111d22
movq 0x8(%rsp), %rax
movq (%rax), %rbx
shlq $0x3, %r15
xorl %r12d, %r12d
movq (%rbx,%r12), %rdi
movl $0x3f, %esi
movq %r13, %rdx
movq %r14, %rcx
callq 0x111f7c
addq $0x8, %r12
cmpq %r12, %r15
jne 0x111d05
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x112328
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rbx
cmpq %rbx, %rdi
movq 0x50(%rsp), %r15
je 0x111d48
callq 0xe17c0
incq %r15
cmpq 0x60(%rsp), %r15
jne 0x11184d
movl 0x5c(%rsp), %ecx
testb %cl, %cl
je 0x111dd8
leaq 0x28(%rsp), %rax
movq %rax, -0x18(%rax)
movq $0x0, -0x10(%rax)
movq $0x5, -0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r13
testq %r13, %r13
je 0x111db5
movq 0x8(%rsp), %rax
movq (%rax), %r12
shlq $0x3, %r13
xorl %ebx, %ebx
movsbl %cl, %ebp
leaq 0x10(%rsp), %r15
movq (%r12,%rbx), %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x111f7c
addq $0x8, %rbx
cmpq %rbx, %r13
jne 0x111d9b
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x112328
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x111dd8
callq 0xe17c0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
jmp 0x111e15
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x111e2c
callq 0xe17c0
movq %rbx, %rdi
callq 0x37b10
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
slang::ast::BitTrie const** slang::SmallVectorBase<slang::ast::BitTrie const*>::emplaceRealloc<slang::ast::BitTrie const* const&>(slang::ast::BitTrie const**, slang::ast::BitTrie const* const&)
|
typename SmallVectorBase<T>::pointer SmallVectorBase<T>::emplaceRealloc(const pointer pos,
Args&&... args) {
if (len == max_size())
detail::throwLengthError();
auto newCap = calculateGrowth(len + 1);
auto offset = static_cast<size_type>(pos - begin());
auto newData = (pointer)::operator new(newCap * sizeof(T));
// First construct the new element in the new memory,
// so that we don't corrupt the new element if it relied on
// existing elements we're about to move around.
auto newPos = newData + offset;
new (newPos) T(std::forward<Args>(args)...);
// Now move elements to the new memory.
if (pos == end()) {
std::uninitialized_move(begin(), end(), newData);
}
else {
std::uninitialized_move(begin(), pos, newData);
std::uninitialized_move(pos, end(), newPos + 1);
}
cleanup();
len++;
cap = newCap;
data_ = newData;
return newPos;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movabsq $0xfffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFFF
movq 0x8(%rdi), %r15
cmpq %rax, %r15
je 0x112323
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
incq %r15
movq 0x10(%rdi), %rcx
movq %rax, %rdx
subq %rcx, %rdx
leaq (%rcx,%rcx), %rsi
cmpq %r15, %rsi
cmovaq %rsi, %r15
cmpq %rdx, %rcx
cmovaq %rax, %r15
movq %r12, %r14
subq (%rdi), %r14
leaq (,%r15,8), %rdi
callq 0xe17d4
leaq (%rax,%r14), %rcx
movq %rcx, 0x10(%rsp)
movq (%r13), %rcx
movq %rax, 0x8(%rsp)
movq %rcx, (%rax,%r14)
movq (%rbx), %r13
movq 0x8(%rbx), %r14
leaq (,%r14,8), %rbp
addq %r13, %rbp
subq %r12, %rbp
je 0x1122cd
cmpq %r12, %r13
je 0x1122b7
movq %r12, %rdx
subq %r13, %rdx
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x379e0
movq 0x10(%rsp), %rax
leaq 0x8(%rax), %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x374b0
jmp 0x1122e7
testq %r14, %r14
je 0x1122e7
leaq (,%r14,8), %rdx
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x379e0
leaq 0x18(%rbx), %rax
cmpq %rax, %r13
je 0x1122fc
movq %r13, %rdi
callq 0xe17c0
movq 0x8(%rbx), %r14
incq %r14
movq %r14, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xdf8d1
|
/MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h
|
slang::SmallVectorBase<slang::ast::BitTrie const*>::operator=(slang::SmallVectorBase<slang::ast::BitTrie const*>&&)
|
SmallVectorBase<T>& SmallVectorBase<T>::operator=(SmallVectorBase<T>&& rhs) {
if (this == &rhs)
return *this;
// If the rhs isn't small, clear this vector and then steal its buffer.
if (!rhs.isSmall()) {
cleanup();
this->data_ = std::exchange(rhs.data_, nullptr);
this->len = std::exchange(rhs.len, 0);
this->cap = std::exchange(rhs.cap, 0);
return *this;
}
// If we already have sufficient space assign the common elements,
// then destroy any excess.
if (len >= rhs.size()) {
iterator newEnd;
if (rhs.size())
newEnd = std::ranges::move(rhs, begin()).out;
else
newEnd = begin();
std::ranges::destroy(newEnd, end());
len = rhs.size();
rhs.clear();
return *this;
}
if (capacity() < rhs.size()) {
// If we have to grow to have enough elements, destroy the current elements.
// This allows us to avoid copying them during the grow.
clear();
reserve(rhs.size());
}
else if (len) {
// Otherwise, use assignment for the already-constructed elements.
std::ranges::move(rhs.begin(), rhs.begin() + len, begin());
}
// Move construct the new elements in place.
std::uninitialized_move(rhs.begin() + len, rhs.end(), begin() + len);
len = rhs.size();
rhs.clear();
return *this;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x112406
movq %rsi, %r14
movq (%rsi), %rsi
leaq 0x18(%r14), %rax
cmpq %rax, %rsi
je 0x112380
movq (%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x11235b
callq 0xe17c0
movq (%r14), %rsi
xorl %eax, %eax
movq %rax, (%r14)
movq %rsi, (%rbx)
movq 0x8(%r14), %rcx
movq %rax, 0x8(%r14)
movq %rcx, 0x8(%rbx)
movq 0x10(%r14), %rcx
movq %rax, 0x10(%r14)
movq %rcx, 0x10(%rbx)
jmp 0x112406
movq 0x8(%rbx), %rdx
movq 0x8(%r14), %rax
cmpq %rax, %rdx
jae 0x1123a9
cmpq %rax, 0x10(%rbx)
jae 0x1123ba
movq $0x0, 0x8(%rbx)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x112412
jmp 0x1123cb
testq %rax, %rax
je 0x1123f8
movq (%rbx), %rdi
shlq $0x3, %rax
movq %rax, %rdx
jmp 0x1123ed
testq %rdx, %rdx
je 0x1123cb
shlq $0x3, %rdx
movq (%rbx), %rdi
callq 0x379e0
movq 0x8(%rbx), %rdi
shlq $0x3, %rdi
movq 0x8(%r14), %rax
leaq (,%rax,8), %rdx
subq %rdi, %rdx
je 0x1123fa
movq (%r14), %rsi
addq %rdi, %rsi
addq (%rbx), %rdi
callq 0x379e0
movq 0x8(%r14), %rax
jmp 0x1123fa
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq $0x0, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h
|
boost::unordered::detail::foa::table_locator<boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, std::pair<slang::ast::RandSeqProductionSymbol const* const, unsigned int>> boost::unordered::detail::foa::table_core<boost::unordered::detail::foa::flat_map_types<slang::ast::RandSeqProductionSymbol const*, unsigned int>, 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::ast::RandSeqProductionSymbol const*, void>, std::equal_to<slang::ast::RandSeqProductionSymbol const*>, slang::detail::hashing::StackAllocator<std::pair<slang::ast::RandSeqProductionSymbol const* const, unsigned int>, 128ul, 16ul>>::unchecked_emplace_with_rehash<boost::unordered::detail::foa::try_emplace_args_t, slang::ast::RandSeqProductionSymbol const*, int>(unsigned long, boost::unordered::detail::foa::try_emplace_args_t&&, slang::ast::RandSeqProductionSymbol const*&&, int&&)
|
BOOST_NOINLINE locator unchecked_emplace_with_rehash(std::size_t hash, Args&&... args) {
auto new_arrays_ = new_arrays_for_growth();
locator it;
BOOST_TRY {
/* strong exception guarantee -> try insertion before rehash */
it = nosize_unchecked_emplace_at(new_arrays_, position_for(hash, new_arrays_), hash,
std::forward<Args>(args)...);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, (%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r15
movq 0x30(%rsi), %rcx
movabsq $0xc9714fbcda3ac11, %rdx # imm = 0xC9714FBCDA3AC11
movq %rcx, %rax
mulq %rdx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x5, %rax
addq %rcx, %rax
incq %rax
testq %rax, %rax
js 0x11260a
cvtsi2ss %rax, %xmm0
jmp 0x11261f
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
divss 0x25dfb9(%rip), %xmm0 # 0x3705e0
callq 0x37330
cvttss2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subss 0x25dfa4(%rip), %xmm0 # 0x3705e4
cvttss2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x112900
xorl %eax, %eax
movq %rax, (%r14)
movl $0x0, 0x8(%r14)
movq %rax, 0x10(%r14)
movb (%r12), %cl
movq %rbp, %rax
shrq %cl, %rax
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %rax, %rcx
movq %rbp, %r8
movq %r13, %r9
pushq (%rsp)
pushq 0x10(%rsp)
callq 0x112702
addq $0x10, %rsp
movq 0x20(%rsp), %rax
movq %rax, 0x10(%r14)
movups 0x10(%rsp), %xmm0
movups %xmm0, (%r14)
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1127de
incq 0x30(%rbx)
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x37240
movq (%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x112a18
callq 0x378a0
movq %rax, %rbx
callq 0x379f0
movq %rbx, %rdi
callq 0x37b10
movq %rax, %rdi
callq 0x692cb
nop
|
/MikePopoloski[P]slang/source/../external/boost_unordered.hpp
|
void slang::ast::NetAliasVisitor::visit<slang::ast::IntegerLiteral>(slang::ast::IntegerLiteral const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::MemberAccess:
case ExpressionKind::ElementSelect:
case ExpressionKind::RangeSelect: {
if (auto sym = expr.getSymbolReference()) {
if (sym->kind != SymbolKind::Net) {
context.addDiag(diag::NetAliasNotANet, expr.sourceRange) << sym->name;
}
else {
auto& netSym = sym->template as<NetSymbol>();
if (auto bounds = ValueDriver::getBounds(expr, evalCtx,
netSym.getType())) {
netAliases.push_back({&netSym, &expr, *bounds});
}
auto& nt = netSym.netType;
if (!commonNetType) {
commonNetType = &nt;
}
else if (commonNetType != &nt && !issuedError) {
auto& diag = context.addDiag(diag::NetAliasCommonNetType,
expr.sourceRange);
diag << sym->name;
diag << nt.name << commonNetType->name;
issuedError = true;
}
}
}
break;
}
case ExpressionKind::HierarchicalValue:
context.addDiag(diag::NetAliasHierarchical, expr.sourceRange);
break;
default:
if constexpr (HasVisitExprs<T, NetAliasVisitor>)
expr.visitExprs(*this);
break;
}
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leal -0x12(%rax), %ecx
cmpl $0x3, %ecx
jb 0x11301d
cmpl $0x9, %eax
je 0x113137
cmpl $0x8, %eax
jne 0x11315d
movq %r14, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x11315d
movq %rax, %r15
cmpl $0x3b, (%rax)
jne 0x113105
movq 0x68(%rbx), %r12
movq %r15, %rdi
addq $0x40, %rdi
callq 0x15ac12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x14a35e
cmpb $0x1, 0x10(%r13)
jne 0x11308a
leaq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x10(%rsi)
callq 0x116ef4
movq 0x150(%r15), %r12
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x113159
cmpq %r12, %rax
je 0x11315d
cmpb $0x0, 0x70(%rbx)
jne 0x11315d
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x860006, %esi # imm = 0x860006
callq 0x160b40
movq %rax, %r14
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
callq 0x83e5c
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r14, %rdi
callq 0x83e5c
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
movq %rax, %rdi
callq 0x83e5c
movb $0x1, 0x70(%rbx)
jmp 0x11315d
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x880006, %esi # imm = 0x880006
callq 0x160b40
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x83e5c
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x870006, %esi # imm = 0x870006
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x160b40
movq %r12, 0x8(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::NetAliasVisitor::visit<slang::ast::UnboundedLiteral>(slang::ast::UnboundedLiteral const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::MemberAccess:
case ExpressionKind::ElementSelect:
case ExpressionKind::RangeSelect: {
if (auto sym = expr.getSymbolReference()) {
if (sym->kind != SymbolKind::Net) {
context.addDiag(diag::NetAliasNotANet, expr.sourceRange) << sym->name;
}
else {
auto& netSym = sym->template as<NetSymbol>();
if (auto bounds = ValueDriver::getBounds(expr, evalCtx,
netSym.getType())) {
netAliases.push_back({&netSym, &expr, *bounds});
}
auto& nt = netSym.netType;
if (!commonNetType) {
commonNetType = &nt;
}
else if (commonNetType != &nt && !issuedError) {
auto& diag = context.addDiag(diag::NetAliasCommonNetType,
expr.sourceRange);
diag << sym->name;
diag << nt.name << commonNetType->name;
issuedError = true;
}
}
}
break;
}
case ExpressionKind::HierarchicalValue:
context.addDiag(diag::NetAliasHierarchical, expr.sourceRange);
break;
default:
if constexpr (HasVisitExprs<T, NetAliasVisitor>)
expr.visitExprs(*this);
break;
}
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leal -0x12(%rax), %ecx
cmpl $0x3, %ecx
jb 0x113793
cmpl $0x9, %eax
je 0x1138ad
cmpl $0x8, %eax
jne 0x1138d3
movq %r14, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x1138d3
movq %rax, %r15
cmpl $0x3b, (%rax)
jne 0x11387b
movq 0x68(%rbx), %r12
movq %r15, %rdi
addq $0x40, %rdi
callq 0x15ac12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x14a35e
cmpb $0x1, 0x10(%r13)
jne 0x113800
leaq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x10(%rsi)
callq 0x116ef4
movq 0x150(%r15), %r12
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1138cf
cmpq %r12, %rax
je 0x1138d3
cmpb $0x0, 0x70(%rbx)
jne 0x1138d3
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x860006, %esi # imm = 0x860006
callq 0x160b40
movq %rax, %r14
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
callq 0x83e5c
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r14, %rdi
callq 0x83e5c
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
movq %rax, %rdi
callq 0x83e5c
movb $0x1, 0x70(%rbx)
jmp 0x1138d3
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x880006, %esi # imm = 0x880006
callq 0x160b40
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x83e5c
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x870006, %esi # imm = 0x870006
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x160b40
movq %r12, 0x8(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::NetAliasVisitor::visit<slang::ast::HierarchicalValueExpression>(slang::ast::HierarchicalValueExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::MemberAccess:
case ExpressionKind::ElementSelect:
case ExpressionKind::RangeSelect: {
if (auto sym = expr.getSymbolReference()) {
if (sym->kind != SymbolKind::Net) {
context.addDiag(diag::NetAliasNotANet, expr.sourceRange) << sym->name;
}
else {
auto& netSym = sym->template as<NetSymbol>();
if (auto bounds = ValueDriver::getBounds(expr, evalCtx,
netSym.getType())) {
netAliases.push_back({&netSym, &expr, *bounds});
}
auto& nt = netSym.netType;
if (!commonNetType) {
commonNetType = &nt;
}
else if (commonNetType != &nt && !issuedError) {
auto& diag = context.addDiag(diag::NetAliasCommonNetType,
expr.sourceRange);
diag << sym->name;
diag << nt.name << commonNetType->name;
issuedError = true;
}
}
}
break;
}
case ExpressionKind::HierarchicalValue:
context.addDiag(diag::NetAliasHierarchical, expr.sourceRange);
break;
default:
if constexpr (HasVisitExprs<T, NetAliasVisitor>)
expr.visitExprs(*this);
break;
}
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leal -0x12(%rax), %ecx
cmpl $0x3, %ecx
jb 0x113c0d
cmpl $0x9, %eax
je 0x113d27
cmpl $0x8, %eax
jne 0x113d4d
movq %r14, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x113d4d
movq %rax, %r15
cmpl $0x3b, (%rax)
jne 0x113cf5
movq 0x68(%rbx), %r12
movq %r15, %rdi
addq $0x40, %rdi
callq 0x15ac12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x14a35e
cmpb $0x1, 0x10(%r13)
jne 0x113c7a
leaq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x10(%rsi)
callq 0x116ef4
movq 0x150(%r15), %r12
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x113d49
cmpq %r12, %rax
je 0x113d4d
cmpb $0x0, 0x70(%rbx)
jne 0x113d4d
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x860006, %esi # imm = 0x860006
callq 0x160b40
movq %rax, %r14
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
callq 0x83e5c
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r14, %rdi
callq 0x83e5c
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
movq %rax, %rdi
callq 0x83e5c
movb $0x1, 0x70(%rbx)
jmp 0x113d4d
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x880006, %esi # imm = 0x880006
callq 0x160b40
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x83e5c
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x870006, %esi # imm = 0x870006
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x160b40
movq %r12, 0x8(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::NetAliasVisitor::visit<slang::ast::InsideExpression>(slang::ast::InsideExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::MemberAccess:
case ExpressionKind::ElementSelect:
case ExpressionKind::RangeSelect: {
if (auto sym = expr.getSymbolReference()) {
if (sym->kind != SymbolKind::Net) {
context.addDiag(diag::NetAliasNotANet, expr.sourceRange) << sym->name;
}
else {
auto& netSym = sym->template as<NetSymbol>();
if (auto bounds = ValueDriver::getBounds(expr, evalCtx,
netSym.getType())) {
netAliases.push_back({&netSym, &expr, *bounds});
}
auto& nt = netSym.netType;
if (!commonNetType) {
commonNetType = &nt;
}
else if (commonNetType != &nt && !issuedError) {
auto& diag = context.addDiag(diag::NetAliasCommonNetType,
expr.sourceRange);
diag << sym->name;
diag << nt.name << commonNetType->name;
issuedError = true;
}
}
}
break;
}
case ExpressionKind::HierarchicalValue:
context.addDiag(diag::NetAliasHierarchical, expr.sourceRange);
break;
default:
if constexpr (HasVisitExprs<T, NetAliasVisitor>)
expr.visitExprs(*this);
break;
}
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leal -0x12(%rax), %ecx
cmpl $0x3, %ecx
jb 0x114267
cmpl $0x9, %eax
je 0x114381
cmpl $0x8, %eax
jne 0x1143a3
movq %r14, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x1143bf
movq %rax, %r15
cmpl $0x3b, (%rax)
jne 0x11434f
movq 0x68(%rbx), %r12
movq %r15, %rdi
addq $0x40, %rdi
callq 0x15ac12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x14a35e
cmpb $0x1, 0x10(%r13)
jne 0x1142d4
leaq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x10(%rsi)
callq 0x116ef4
movq 0x150(%r15), %r12
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1143bb
cmpq %r12, %rax
je 0x1143bf
cmpb $0x0, 0x70(%rbx)
jne 0x1143bf
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x860006, %esi # imm = 0x860006
callq 0x160b40
movq %rax, %r14
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
callq 0x83e5c
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r14, %rdi
callq 0x83e5c
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
movq %rax, %rdi
callq 0x83e5c
movb $0x1, 0x70(%rbx)
jmp 0x1143bf
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x880006, %esi # imm = 0x880006
callq 0x160b40
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x83e5c
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x870006, %esi # imm = 0x870006
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x160b40
movq %r14, %rdi
movq %rbx, %rsi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1170e8
movq %r12, 0x8(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::NetAliasVisitor::visit<slang::ast::ConcatenationExpression>(slang::ast::ConcatenationExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::MemberAccess:
case ExpressionKind::ElementSelect:
case ExpressionKind::RangeSelect: {
if (auto sym = expr.getSymbolReference()) {
if (sym->kind != SymbolKind::Net) {
context.addDiag(diag::NetAliasNotANet, expr.sourceRange) << sym->name;
}
else {
auto& netSym = sym->template as<NetSymbol>();
if (auto bounds = ValueDriver::getBounds(expr, evalCtx,
netSym.getType())) {
netAliases.push_back({&netSym, &expr, *bounds});
}
auto& nt = netSym.netType;
if (!commonNetType) {
commonNetType = &nt;
}
else if (commonNetType != &nt && !issuedError) {
auto& diag = context.addDiag(diag::NetAliasCommonNetType,
expr.sourceRange);
diag << sym->name;
diag << nt.name << commonNetType->name;
issuedError = true;
}
}
}
break;
}
case ExpressionKind::HierarchicalValue:
context.addDiag(diag::NetAliasHierarchical, expr.sourceRange);
break;
default:
if constexpr (HasVisitExprs<T, NetAliasVisitor>)
expr.visitExprs(*this);
break;
}
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leal -0x12(%rax), %ecx
cmpl $0x3, %ecx
jb 0x1145a9
cmpl $0x9, %eax
je 0x1146c6
cmpl $0x8, %eax
jne 0x1146e8
movq %r14, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x11471a
movq %rax, %r15
cmpl $0x3b, (%rax)
jne 0x114694
movq 0x68(%rbx), %r12
movq %r15, %rdi
addq $0x40, %rdi
callq 0x15ac12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x14a35e
cmpb $0x1, 0x10(%r13)
jne 0x114616
leaq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x10(%rsi)
callq 0x116ef4
movq 0x150(%r15), %r12
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x114716
cmpq %r12, %rax
je 0x11471a
cmpb $0x0, 0x70(%rbx)
jne 0x11471a
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x860006, %esi # imm = 0x860006
callq 0x160b40
movq %rax, %r14
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
callq 0x83e5c
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r14, %rdi
callq 0x83e5c
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
movq %rax, %rdi
callq 0x83e5c
movb $0x1, 0x70(%rbx)
jmp 0x11471a
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x880006, %esi # imm = 0x880006
callq 0x160b40
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x83e5c
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x870006, %esi # imm = 0x870006
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x160b40
movq 0x38(%r14), %r15
testq %r15, %r15
je 0x11471a
movq 0x30(%r14), %r14
shlq $0x3, %r15
xorl %r12d, %r12d
movq (%r14,%r12), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
callq 0x112d16
addq $0x8, %r12
cmpq %r12, %r15
jne 0x1146fc
jmp 0x11471a
movq %r12, 0x8(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::NetAliasVisitor::visit<slang::ast::ReplicationExpression>(slang::ast::ReplicationExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::MemberAccess:
case ExpressionKind::ElementSelect:
case ExpressionKind::RangeSelect: {
if (auto sym = expr.getSymbolReference()) {
if (sym->kind != SymbolKind::Net) {
context.addDiag(diag::NetAliasNotANet, expr.sourceRange) << sym->name;
}
else {
auto& netSym = sym->template as<NetSymbol>();
if (auto bounds = ValueDriver::getBounds(expr, evalCtx,
netSym.getType())) {
netAliases.push_back({&netSym, &expr, *bounds});
}
auto& nt = netSym.netType;
if (!commonNetType) {
commonNetType = &nt;
}
else if (commonNetType != &nt && !issuedError) {
auto& diag = context.addDiag(diag::NetAliasCommonNetType,
expr.sourceRange);
diag << sym->name;
diag << nt.name << commonNetType->name;
issuedError = true;
}
}
}
break;
}
case ExpressionKind::HierarchicalValue:
context.addDiag(diag::NetAliasHierarchical, expr.sourceRange);
break;
default:
if constexpr (HasVisitExprs<T, NetAliasVisitor>)
expr.visitExprs(*this);
break;
}
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leal -0x12(%rax), %ecx
cmpl $0x3, %ecx
jb 0x114757
cmpl $0x9, %eax
je 0x114874
cmpl $0x8, %eax
jne 0x114896
movq %r14, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x1148c5
movq %rax, %r15
cmpl $0x3b, (%rax)
jne 0x114842
movq 0x68(%rbx), %r12
movq %r15, %rdi
addq $0x40, %rdi
callq 0x15ac12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x14a35e
cmpb $0x1, 0x10(%r13)
jne 0x1147c4
leaq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x10(%rsi)
callq 0x116ef4
movq 0x150(%r15), %r12
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1148c1
cmpq %r12, %rax
je 0x1148c5
cmpb $0x0, 0x70(%rbx)
jne 0x1148c5
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x860006, %esi # imm = 0x860006
callq 0x160b40
movq %rax, %r14
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
callq 0x83e5c
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r14, %rdi
callq 0x83e5c
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
movq %rax, %rdi
callq 0x83e5c
movb $0x1, 0x70(%rbx)
jmp 0x1148c5
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x880006, %esi # imm = 0x880006
callq 0x160b40
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x83e5c
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x870006, %esi # imm = 0x870006
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x160b40
movq 0x30(%r14), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
callq 0x112d16
movq 0x38(%r14), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x112d16
movq %r12, 0x8(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::NetAliasVisitor::visit<slang::ast::CallExpression>(slang::ast::CallExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::MemberAccess:
case ExpressionKind::ElementSelect:
case ExpressionKind::RangeSelect: {
if (auto sym = expr.getSymbolReference()) {
if (sym->kind != SymbolKind::Net) {
context.addDiag(diag::NetAliasNotANet, expr.sourceRange) << sym->name;
}
else {
auto& netSym = sym->template as<NetSymbol>();
if (auto bounds = ValueDriver::getBounds(expr, evalCtx,
netSym.getType())) {
netAliases.push_back({&netSym, &expr, *bounds});
}
auto& nt = netSym.netType;
if (!commonNetType) {
commonNetType = &nt;
}
else if (commonNetType != &nt && !issuedError) {
auto& diag = context.addDiag(diag::NetAliasCommonNetType,
expr.sourceRange);
diag << sym->name;
diag << nt.name << commonNetType->name;
issuedError = true;
}
}
}
break;
}
case ExpressionKind::HierarchicalValue:
context.addDiag(diag::NetAliasHierarchical, expr.sourceRange);
break;
default:
if constexpr (HasVisitExprs<T, NetAliasVisitor>)
expr.visitExprs(*this);
break;
}
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leal -0x12(%rax), %ecx
cmpl $0x3, %ecx
jb 0x114f75
cmpl $0x9, %eax
je 0x11508f
cmpl $0x8, %eax
jne 0x1150b1
movq %r14, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x1150cd
movq %rax, %r15
cmpl $0x3b, (%rax)
jne 0x11505d
movq 0x68(%rbx), %r12
movq %r15, %rdi
addq $0x40, %rdi
callq 0x15ac12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x14a35e
cmpb $0x1, 0x10(%r13)
jne 0x114fe2
leaq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x10(%rsi)
callq 0x116ef4
movq 0x150(%r15), %r12
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1150c9
cmpq %r12, %rax
je 0x1150cd
cmpb $0x0, 0x70(%rbx)
jne 0x1150cd
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x860006, %esi # imm = 0x860006
callq 0x160b40
movq %rax, %r14
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
callq 0x83e5c
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r14, %rdi
callq 0x83e5c
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
movq %rax, %rdi
callq 0x83e5c
movb $0x1, 0x70(%rbx)
jmp 0x1150cd
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x880006, %esi # imm = 0x880006
callq 0x160b40
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x83e5c
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x870006, %esi # imm = 0x870006
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x160b40
movq %r14, %rdi
movq %rbx, %rsi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1171ca
movq %r12, 0x8(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::NetAliasVisitor::visit<slang::ast::DataTypeExpression>(slang::ast::DataTypeExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::MemberAccess:
case ExpressionKind::ElementSelect:
case ExpressionKind::RangeSelect: {
if (auto sym = expr.getSymbolReference()) {
if (sym->kind != SymbolKind::Net) {
context.addDiag(diag::NetAliasNotANet, expr.sourceRange) << sym->name;
}
else {
auto& netSym = sym->template as<NetSymbol>();
if (auto bounds = ValueDriver::getBounds(expr, evalCtx,
netSym.getType())) {
netAliases.push_back({&netSym, &expr, *bounds});
}
auto& nt = netSym.netType;
if (!commonNetType) {
commonNetType = &nt;
}
else if (commonNetType != &nt && !issuedError) {
auto& diag = context.addDiag(diag::NetAliasCommonNetType,
expr.sourceRange);
diag << sym->name;
diag << nt.name << commonNetType->name;
issuedError = true;
}
}
}
break;
}
case ExpressionKind::HierarchicalValue:
context.addDiag(diag::NetAliasHierarchical, expr.sourceRange);
break;
default:
if constexpr (HasVisitExprs<T, NetAliasVisitor>)
expr.visitExprs(*this);
break;
}
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leal -0x12(%rax), %ecx
cmpl $0x3, %ecx
jb 0x1152a5
cmpl $0x9, %eax
je 0x1153bf
cmpl $0x8, %eax
jne 0x1153e5
movq %r14, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x1153e5
movq %rax, %r15
cmpl $0x3b, (%rax)
jne 0x11538d
movq 0x68(%rbx), %r12
movq %r15, %rdi
addq $0x40, %rdi
callq 0x15ac12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x14a35e
cmpb $0x1, 0x10(%r13)
jne 0x115312
leaq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x10(%rsi)
callq 0x116ef4
movq 0x150(%r15), %r12
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1153e1
cmpq %r12, %rax
je 0x1153e5
cmpb $0x0, 0x70(%rbx)
jne 0x1153e5
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x860006, %esi # imm = 0x860006
callq 0x160b40
movq %rax, %r14
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
callq 0x83e5c
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r14, %rdi
callq 0x83e5c
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
movq %rax, %rdi
callq 0x83e5c
movb $0x1, 0x70(%rbx)
jmp 0x1153e5
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x880006, %esi # imm = 0x880006
callq 0x160b40
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x83e5c
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x870006, %esi # imm = 0x870006
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x160b40
movq %r12, 0x8(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::NetAliasVisitor::visit<slang::ast::TypeReferenceExpression>(slang::ast::TypeReferenceExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::MemberAccess:
case ExpressionKind::ElementSelect:
case ExpressionKind::RangeSelect: {
if (auto sym = expr.getSymbolReference()) {
if (sym->kind != SymbolKind::Net) {
context.addDiag(diag::NetAliasNotANet, expr.sourceRange) << sym->name;
}
else {
auto& netSym = sym->template as<NetSymbol>();
if (auto bounds = ValueDriver::getBounds(expr, evalCtx,
netSym.getType())) {
netAliases.push_back({&netSym, &expr, *bounds});
}
auto& nt = netSym.netType;
if (!commonNetType) {
commonNetType = &nt;
}
else if (commonNetType != &nt && !issuedError) {
auto& diag = context.addDiag(diag::NetAliasCommonNetType,
expr.sourceRange);
diag << sym->name;
diag << nt.name << commonNetType->name;
issuedError = true;
}
}
}
break;
}
case ExpressionKind::HierarchicalValue:
context.addDiag(diag::NetAliasHierarchical, expr.sourceRange);
break;
default:
if constexpr (HasVisitExprs<T, NetAliasVisitor>)
expr.visitExprs(*this);
break;
}
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leal -0x12(%rax), %ecx
cmpl $0x3, %ecx
jb 0x115423
cmpl $0x9, %eax
je 0x11553d
cmpl $0x8, %eax
jne 0x115563
movq %r14, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x115563
movq %rax, %r15
cmpl $0x3b, (%rax)
jne 0x11550b
movq 0x68(%rbx), %r12
movq %r15, %rdi
addq $0x40, %rdi
callq 0x15ac12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x14a35e
cmpb $0x1, 0x10(%r13)
jne 0x115490
leaq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x10(%rsi)
callq 0x116ef4
movq 0x150(%r15), %r12
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x11555f
cmpq %r12, %rax
je 0x115563
cmpb $0x0, 0x70(%rbx)
jne 0x115563
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x860006, %esi # imm = 0x860006
callq 0x160b40
movq %rax, %r14
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
callq 0x83e5c
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r14, %rdi
callq 0x83e5c
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
movq %rax, %rdi
callq 0x83e5c
movb $0x1, 0x70(%rbx)
jmp 0x115563
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x880006, %esi # imm = 0x880006
callq 0x160b40
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x83e5c
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x870006, %esi # imm = 0x870006
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x160b40
movq %r12, 0x8(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::NetAliasVisitor::visit<slang::ast::ArbitrarySymbolExpression>(slang::ast::ArbitrarySymbolExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::MemberAccess:
case ExpressionKind::ElementSelect:
case ExpressionKind::RangeSelect: {
if (auto sym = expr.getSymbolReference()) {
if (sym->kind != SymbolKind::Net) {
context.addDiag(diag::NetAliasNotANet, expr.sourceRange) << sym->name;
}
else {
auto& netSym = sym->template as<NetSymbol>();
if (auto bounds = ValueDriver::getBounds(expr, evalCtx,
netSym.getType())) {
netAliases.push_back({&netSym, &expr, *bounds});
}
auto& nt = netSym.netType;
if (!commonNetType) {
commonNetType = &nt;
}
else if (commonNetType != &nt && !issuedError) {
auto& diag = context.addDiag(diag::NetAliasCommonNetType,
expr.sourceRange);
diag << sym->name;
diag << nt.name << commonNetType->name;
issuedError = true;
}
}
}
break;
}
case ExpressionKind::HierarchicalValue:
context.addDiag(diag::NetAliasHierarchical, expr.sourceRange);
break;
default:
if constexpr (HasVisitExprs<T, NetAliasVisitor>)
expr.visitExprs(*this);
break;
}
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leal -0x12(%rax), %ecx
cmpl $0x3, %ecx
jb 0x1155a1
cmpl $0x9, %eax
je 0x1156bb
cmpl $0x8, %eax
jne 0x1156e1
movq %r14, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x1156e1
movq %rax, %r15
cmpl $0x3b, (%rax)
jne 0x115689
movq 0x68(%rbx), %r12
movq %r15, %rdi
addq $0x40, %rdi
callq 0x15ac12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x14a35e
cmpb $0x1, 0x10(%r13)
jne 0x11560e
leaq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x10(%rsi)
callq 0x116ef4
movq 0x150(%r15), %r12
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1156dd
cmpq %r12, %rax
je 0x1156e1
cmpb $0x0, 0x70(%rbx)
jne 0x1156e1
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x860006, %esi # imm = 0x860006
callq 0x160b40
movq %rax, %r14
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
callq 0x83e5c
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r14, %rdi
callq 0x83e5c
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
movq %rax, %rdi
callq 0x83e5c
movb $0x1, 0x70(%rbx)
jmp 0x1156e1
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x880006, %esi # imm = 0x880006
callq 0x160b40
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x83e5c
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x870006, %esi # imm = 0x870006
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x160b40
movq %r12, 0x8(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::NetAliasVisitor::visit<slang::ast::EmptyArgumentExpression>(slang::ast::EmptyArgumentExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::MemberAccess:
case ExpressionKind::ElementSelect:
case ExpressionKind::RangeSelect: {
if (auto sym = expr.getSymbolReference()) {
if (sym->kind != SymbolKind::Net) {
context.addDiag(diag::NetAliasNotANet, expr.sourceRange) << sym->name;
}
else {
auto& netSym = sym->template as<NetSymbol>();
if (auto bounds = ValueDriver::getBounds(expr, evalCtx,
netSym.getType())) {
netAliases.push_back({&netSym, &expr, *bounds});
}
auto& nt = netSym.netType;
if (!commonNetType) {
commonNetType = &nt;
}
else if (commonNetType != &nt && !issuedError) {
auto& diag = context.addDiag(diag::NetAliasCommonNetType,
expr.sourceRange);
diag << sym->name;
diag << nt.name << commonNetType->name;
issuedError = true;
}
}
}
break;
}
case ExpressionKind::HierarchicalValue:
context.addDiag(diag::NetAliasHierarchical, expr.sourceRange);
break;
default:
if constexpr (HasVisitExprs<T, NetAliasVisitor>)
expr.visitExprs(*this);
break;
}
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leal -0x12(%rax), %ecx
cmpl $0x3, %ecx
jb 0x115d9f
cmpl $0x9, %eax
je 0x115eb9
cmpl $0x8, %eax
jne 0x115edf
movq %r14, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x115edf
movq %rax, %r15
cmpl $0x3b, (%rax)
jne 0x115e87
movq 0x68(%rbx), %r12
movq %r15, %rdi
addq $0x40, %rdi
callq 0x15ac12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x14a35e
cmpb $0x1, 0x10(%r13)
jne 0x115e0c
leaq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x10(%rsi)
callq 0x116ef4
movq 0x150(%r15), %r12
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x115edb
cmpq %r12, %rax
je 0x115edf
cmpb $0x0, 0x70(%rbx)
jne 0x115edf
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x860006, %esi # imm = 0x860006
callq 0x160b40
movq %rax, %r14
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
callq 0x83e5c
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r14, %rdi
callq 0x83e5c
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
movq %rax, %rdi
callq 0x83e5c
movb $0x1, 0x70(%rbx)
jmp 0x115edf
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x880006, %esi # imm = 0x880006
callq 0x160b40
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x83e5c
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x870006, %esi # imm = 0x870006
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x160b40
movq %r12, 0x8(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::NetAliasVisitor::visit<slang::ast::ValueRangeExpression>(slang::ast::ValueRangeExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::MemberAccess:
case ExpressionKind::ElementSelect:
case ExpressionKind::RangeSelect: {
if (auto sym = expr.getSymbolReference()) {
if (sym->kind != SymbolKind::Net) {
context.addDiag(diag::NetAliasNotANet, expr.sourceRange) << sym->name;
}
else {
auto& netSym = sym->template as<NetSymbol>();
if (auto bounds = ValueDriver::getBounds(expr, evalCtx,
netSym.getType())) {
netAliases.push_back({&netSym, &expr, *bounds});
}
auto& nt = netSym.netType;
if (!commonNetType) {
commonNetType = &nt;
}
else if (commonNetType != &nt && !issuedError) {
auto& diag = context.addDiag(diag::NetAliasCommonNetType,
expr.sourceRange);
diag << sym->name;
diag << nt.name << commonNetType->name;
issuedError = true;
}
}
}
break;
}
case ExpressionKind::HierarchicalValue:
context.addDiag(diag::NetAliasHierarchical, expr.sourceRange);
break;
default:
if constexpr (HasVisitExprs<T, NetAliasVisitor>)
expr.visitExprs(*this);
break;
}
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leal -0x12(%rax), %ecx
cmpl $0x3, %ecx
jb 0x115f1d
cmpl $0x9, %eax
je 0x11603a
cmpl $0x8, %eax
jne 0x11605c
movq %r14, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x11608b
movq %rax, %r15
cmpl $0x3b, (%rax)
jne 0x116008
movq 0x68(%rbx), %r12
movq %r15, %rdi
addq $0x40, %rdi
callq 0x15ac12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x14a35e
cmpb $0x1, 0x10(%r13)
jne 0x115f8a
leaq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x10(%rsi)
callq 0x116ef4
movq 0x150(%r15), %r12
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x116087
cmpq %r12, %rax
je 0x11608b
cmpb $0x0, 0x70(%rbx)
jne 0x11608b
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x860006, %esi # imm = 0x860006
callq 0x160b40
movq %rax, %r14
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
callq 0x83e5c
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r14, %rdi
callq 0x83e5c
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
movq %rax, %rdi
callq 0x83e5c
movb $0x1, 0x70(%rbx)
jmp 0x11608b
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x880006, %esi # imm = 0x880006
callq 0x160b40
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x83e5c
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x870006, %esi # imm = 0x870006
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x160b40
movq 0x38(%r14), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
callq 0x112d16
movq 0x40(%r14), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x112d16
movq %r12, 0x8(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::NetAliasVisitor::visit<slang::ast::TaggedUnionExpression>(slang::ast::TaggedUnionExpression const&)
|
void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
switch (expr.kind) {
case ExpressionKind::NamedValue:
case ExpressionKind::MemberAccess:
case ExpressionKind::ElementSelect:
case ExpressionKind::RangeSelect: {
if (auto sym = expr.getSymbolReference()) {
if (sym->kind != SymbolKind::Net) {
context.addDiag(diag::NetAliasNotANet, expr.sourceRange) << sym->name;
}
else {
auto& netSym = sym->template as<NetSymbol>();
if (auto bounds = ValueDriver::getBounds(expr, evalCtx,
netSym.getType())) {
netAliases.push_back({&netSym, &expr, *bounds});
}
auto& nt = netSym.netType;
if (!commonNetType) {
commonNetType = &nt;
}
else if (commonNetType != &nt && !issuedError) {
auto& diag = context.addDiag(diag::NetAliasCommonNetType,
expr.sourceRange);
diag << sym->name;
diag << nt.name << commonNetType->name;
issuedError = true;
}
}
}
break;
}
case ExpressionKind::HierarchicalValue:
context.addDiag(diag::NetAliasHierarchical, expr.sourceRange);
break;
default:
if constexpr (HasVisitExprs<T, NetAliasVisitor>)
expr.visitExprs(*this);
break;
}
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leal -0x12(%rax), %ecx
cmpl $0x3, %ecx
jb 0x116d85
cmpl $0x9, %eax
je 0x116e9f
cmpl $0x8, %eax
jne 0x116ec1
movq %r14, %rdi
movl $0x1, %esi
callq 0x1cf5e2
testq %rax, %rax
je 0x116ee6
movq %rax, %r15
cmpl $0x3b, (%rax)
jne 0x116e6d
movq 0x68(%rbx), %r12
movq %r15, %rdi
addq $0x40, %rdi
callq 0x15ac12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x14a35e
cmpb $0x1, 0x10(%r13)
jne 0x116df2
leaq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x10(%rsi)
callq 0x116ef4
movq 0x150(%r15), %r12
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x116ee2
cmpq %r12, %rax
je 0x116ee6
cmpb $0x0, 0x70(%rbx)
jne 0x116ee6
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x860006, %esi # imm = 0x860006
callq 0x160b40
movq %rax, %r14
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
callq 0x83e5c
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r14, %rdi
callq 0x83e5c
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
movq %rax, %rdi
callq 0x83e5c
movb $0x1, 0x70(%rbx)
jmp 0x116ee6
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x880006, %esi # imm = 0x880006
callq 0x160b40
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rax, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x83e5c
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
movl $0x870006, %esi # imm = 0x870006
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x160b40
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x116ee6
movq %rdi, %rsi
movq %rbx, %rdx
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x112d16
movq %r12, 0x8(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/MikePopoloski[P]slang/source/ast/symbols/MemberSymbols.cpp
|
void slang::ast::ConditionalExpression::visitExprs<slang::ast::NetAliasVisitor&>(slang::ast::NetAliasVisitor&) const
|
void visitExprs(TVisitor&& visitor) const {
for (auto& cond : conditions) {
cond.expr->visit(visitor);
if (cond.pattern)
cond.pattern->visit(visitor);
}
left().visit(visitor);
right().visit(visitor);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rdi), %r15
testq %r15, %r15
je 0x1170c1
movq 0x30(%r14), %r12
shlq $0x4, %r15
xorl %r13d, %r13d
movq (%r12,%r13), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
callq 0x112d16
addq $0x10, %r13
cmpq %r13, %r15
jne 0x1170a9
movq 0x48(%r14), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
callq 0x112d16
movq 0x50(%r14), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x112d16
|
/MikePopoloski[P]slang/source/../include/slang/ast/expressions/OperatorExpressions.h
|
void slang::ast::StructuredAssignmentPatternExpression::visitExprs<slang::ast::NetAliasVisitor&>(slang::ast::NetAliasVisitor&) const
|
void visitExprs(TVisitor&& visitor) const {
for (auto& setter : memberSetters)
setter.expr->visit(visitor);
for (auto& setter : typeSetters)
setter.expr->visit(visitor);
for (auto& setter : indexSetters) {
setter.index->visit(visitor);
setter.expr->visit(visitor);
}
if (defaultSetter)
defaultSetter->visit(visitor);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rdi), %r15
testq %r15, %r15
je 0x1172ce
movq 0x40(%r14), %r12
shlq $0x4, %r15
xorl %r13d, %r13d
movq 0x8(%r12,%r13), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
callq 0x112d16
addq $0x10, %r13
cmpq %r13, %r15
jne 0x1172b5
movq 0x58(%r14), %r15
testq %r15, %r15
je 0x1172fb
movq 0x50(%r14), %r12
shlq $0x4, %r15
xorl %r13d, %r13d
movq 0x8(%r12,%r13), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
callq 0x112d16
addq $0x10, %r13
cmpq %r13, %r15
jne 0x1172e2
movq 0x68(%r14), %r15
testq %r15, %r15
je 0x117337
movq 0x60(%r14), %r12
shlq $0x4, %r15
addq %r12, %r15
movq (%r12), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
callq 0x112d16
movq 0x8(%r12), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
callq 0x112d16
addq $0x10, %r12
cmpq %r15, %r12
jne 0x11730f
movq 0x70(%r14), %rdi
testq %rdi, %rdi
je 0x117354
movq %rdi, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x112d16
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/MikePopoloski[P]slang/source/../include/slang/ast/expressions/AssignmentExpressions.h
|
slang::ast::ModportSymbol const*& slang::SmallVectorBase<slang::ast::ModportSymbol const*>::emplace_back<slang::ast::ModportSymbol const* const&>(slang::ast::ModportSymbol const* const&)
|
reference emplace_back(Args&&... args) {
if (len == cap)
return *emplaceRealloc(end(), std::forward<Args>(args)...);
new (end()) T(std::forward<Args>(args)...);
len++;
return back();
}
|
movq %rsi, %rdx
movq 0x8(%rdi), %rax
leaq (,%rax,8), %rsi
addq (%rdi), %rsi
cmpq 0x10(%rdi), %rax
je 0x117552
movq (%rdx), %rcx
movq %rcx, (%rsi)
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq (%rdi), %rcx
leaq (%rcx,%rax,8), %rax
retq
|
/MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h
|
slang::ast::GenvarSymbol const*& slang::SmallVectorBase<slang::ast::GenvarSymbol const*>::emplace_back<slang::ast::GenvarSymbol const* const&>(slang::ast::GenvarSymbol const* const&)
|
reference emplace_back(Args&&... args) {
if (len == cap)
return *emplaceRealloc(end(), std::forward<Args>(args)...);
new (end()) T(std::forward<Args>(args)...);
len++;
return back();
}
|
movq %rsi, %rdx
movq 0x8(%rdi), %rax
leaq (,%rax,8), %rsi
addq (%rdi), %rsi
cmpq 0x10(%rdi), %rax
je 0x11769a
movq (%rdx), %rcx
movq %rcx, (%rsi)
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq (%rdi), %rcx
leaq (%rcx,%rax,8), %rax
retq
|
/MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h
|
boost::unordered::detail::foa::table_arrays<std::pair<std::basic_string_view<char, std::char_traits<char>> const, slang::ast::PrimitivePortSymbol*>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::pow2_size_policy, slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, slang::ast::PrimitivePortSymbol*>, 96ul, 16ul>>::set_arrays(boost::unordered::detail::foa::table_arrays<std::pair<std::basic_string_view<char, std::char_traits<char>> const, slang::ast::PrimitivePortSymbol*>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::pow2_size_policy, slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, slang::ast::PrimitivePortSymbol*>, 96ul, 16ul>>&, slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, slang::ast::PrimitivePortSymbol*>, 96ul, 16ul>, unsigned long, std::integral_constant<bool, false>)
|
static void set_arrays(table_arrays& arrays, allocator_type al, std::size_t,
std::false_type /* always allocate */) {
using storage_traits = std::allocator_traits<allocator_type>;
auto groups_size_index = arrays.groups_size_index;
auto groups_size = size_policy::size(groups_size_index);
auto sal = allocator_type(al);
arrays.elements_ = storage_traits::allocate(sal, buffer_size(groups_size));
/* Align arrays.groups to sizeof(group_type). table_iterator critically
* depends on such alignment for its increment operation.
*/
auto p = reinterpret_cast<unsigned char*>(arrays.elements() + groups_size * N - 1);
p += (uintptr_t(sizeof(group_type)) - reinterpret_cast<uintptr_t>(p)) % sizeof(group_type);
arrays.groups_ = group_type_pointer_traits::pointer_to(*reinterpret_cast<group_type*>(p));
initialize_groups(arrays.groups(), groups_size,
is_trivially_default_constructible<group_type>{});
arrays.groups()[groups_size - 1].set_sentinel();
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rcx
movl $0x40, %r14d
subq %rcx, %r14
negq %rcx
movl $0x178, %eax # imm = 0x178
shlq %cl, %rax
addq $0xe, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq %rdx
andq $-0x8, %rdx
leaq (%rdx,%rdx,2), %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq 0x60(%rsi), %rax
addq $0x60, %rsi
movq %rsi, %rdi
subq %rax, %rdi
cmpq %rcx, %rdi
jae 0x117a57
leaq (%rdx,%rdx,2), %rdi
callq 0xe17d4
jmp 0x117a5d
addq %rax, %rcx
movq %rcx, (%rsi)
movl $0x1, %r15d
movl %r14d, %ecx
shlq %cl, %r15
movl $0x168, %edx # imm = 0x168
shlq %cl, %rdx
movq %rax, 0x18(%rbx)
leaq (%rax,%rdx), %rcx
addq %rdx, %rax
addq $-0x18, %rax
negl %eax
andl $0xf, %eax
leaq (%rax,%rcx), %rdi
addq $-0x18, %rdi
movq %rdi, 0x10(%rbx)
movl $0x10, %edx
movl %r14d, %ecx
shlq %cl, %rdx
xorl %esi, %esi
callq 0x37300
movq 0x10(%rbx), %rax
shlq $0x4, %r15
movb $0x1, -0x2(%rax,%r15)
popq %rbx
popq %r14
popq %r15
retq
nop
|
/MikePopoloski[P]slang/source/../external/boost_unordered.hpp
|
boost::unordered::detail::foa::table_core<boost::unordered::detail::foa::flat_map_types<std::basic_string_view<char, std::char_traits<char>>, slang::ast::PrimitivePortSymbol*>, 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<std::basic_string_view<char, std::char_traits<char>>, void>, std::equal_to<std::basic_string_view<char, std::char_traits<char>>>, slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, slang::ast::PrimitivePortSymbol*>, 96ul, 16ul>>::unchecked_rehash(boost::unordered::detail::foa::table_arrays<std::pair<std::basic_string_view<char, std::char_traits<char>> const, slang::ast::PrimitivePortSymbol*>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::pow2_size_policy, slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, slang::ast::PrimitivePortSymbol*>, 96ul, 16ul>>&)
|
BOOST_NOINLINE void unchecked_rehash(arrays_type& new_arrays_) {
std::size_t num_destroyed = 0;
BOOST_TRY {
for_all_elements([&, this](element_type* p) {
nosize_transfer_element(p, new_arrays_, num_destroyed);
});
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq $0x0, (%rax)
leaq 0x8(%rdi), %r15
leaq 0x18(%rsp), %rcx
movq %rdi, (%rcx)
movq %rsi, 0x8(%rcx)
movq %rax, 0x10(%rcx)
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
movq %r15, %rdi
callq 0x117e38
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x1104e6
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
leaq (%rax,%rax,4), %rax
leaq 0xe(%rax,%rax,2), %rax
cmoveq %rcx, %rax
testq %rax, %rax
js 0x117d99
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
jmp 0x117db3
movq %rax, %rcx
shrq %rcx
movl %eax, %edx
andl $0x1, %edx
orq %rcx, %rdx
xorps %xmm0, %xmm0
cvtsi2ss %rdx, %xmm0
addss %xmm0, %xmm0
mulss 0x258825(%rip), %xmm0 # 0x3705e0
cvttss2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subss 0x258815(%rip), %xmm0 # 0x3705e4
cvttss2si %xmm0, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
cmpq $0x1e, %rax
cmovbq %rax, %rsi
movq %rsi, 0x28(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x37240
cmpq $0x0, 0x8(%rsp)
je 0x117e10
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x117fbe
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x1104e6
callq 0x378a0
movq %rax, %rbx
callq 0x379f0
movq %rbx, %rdi
callq 0x37b10
movq %rax, %rdi
callq 0x692cb
|
/MikePopoloski[P]slang/source/../external/boost_unordered.hpp
|
slang::ast::RandSeqProductionSymbol::Rule& slang::SmallVectorBase<slang::ast::RandSeqProductionSymbol::Rule>::emplace_back<slang::ast::RandSeqProductionSymbol::Rule>(slang::ast::RandSeqProductionSymbol::Rule&&)
|
reference emplace_back(Args&&... args) {
if (len == cap)
return *emplaceRealloc(end(), std::forward<Args>(args)...);
new (end()) T(std::forward<Args>(args)...);
len++;
return back();
}
|
movq %rsi, %rdx
movq %rdi, %r8
movq 0x8(%rdi), %rax
leaq (%rax,%rax,8), %rsi
shlq $0x3, %rsi
addq (%rdi), %rsi
cmpq 0x10(%rdi), %rax
jne 0x118203
movq %r8, %rdi
jmp 0x11822a
movl $0x9, %ecx
movq %rsi, %rdi
movq %rdx, %rsi
rep movsq (%rsi), %es:(%rdi)
movq 0x8(%r8), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%r8)
leaq (%rax,%rax,8), %rax
shlq $0x3, %rax
addq (%r8), %rax
retq
nop
|
/MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h
|
slang::ast::RandSeqProductionSymbol::ProdItem& slang::SmallVectorBase<slang::ast::RandSeqProductionSymbol::ProdItem>::emplace_back<slang::ast::RandSeqProductionSymbol::ProdItem const&>(slang::ast::RandSeqProductionSymbol::ProdItem const&)
|
reference emplace_back(Args&&... args) {
if (len == cap)
return *emplaceRealloc(end(), std::forward<Args>(args)...);
new (end()) T(std::forward<Args>(args)...);
len++;
return back();
}
|
movq %rsi, %rdx
movq 0x8(%rdi), %rax
movq %rax, %rsi
shlq $0x5, %rsi
addq (%rdi), %rsi
cmpq 0x10(%rdi), %rax
je 0x1183cc
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
incq %rcx
movq %rcx, 0x8(%rdi)
shlq $0x5, %rcx
addq %rcx, %rax
addq $-0x20, %rax
retq
nop
|
/MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h
|
slang::ast::RandSeqProductionSymbol::CaseItem* slang::SmallVectorBase<slang::ast::RandSeqProductionSymbol::CaseItem>::emplaceRealloc<slang::ast::RandSeqProductionSymbol::CaseItem>(slang::ast::RandSeqProductionSymbol::CaseItem*, slang::ast::RandSeqProductionSymbol::CaseItem&&)
|
typename SmallVectorBase<T>::pointer SmallVectorBase<T>::emplaceRealloc(const pointer pos,
Args&&... args) {
if (len == max_size())
detail::throwLengthError();
auto newCap = calculateGrowth(len + 1);
auto offset = static_cast<size_type>(pos - begin());
auto newData = (pointer)::operator new(newCap * sizeof(T));
// First construct the new element in the new memory,
// so that we don't corrupt the new element if it relied on
// existing elements we're about to move around.
auto newPos = newData + offset;
new (newPos) T(std::forward<Args>(args)...);
// Now move elements to the new memory.
if (pos == end()) {
std::uninitialized_move(begin(), end(), newData);
}
else {
std::uninitialized_move(begin(), pos, newData);
std::uninitialized_move(pos, end(), newPos + 1);
}
cleanup();
len++;
cap = newCap;
data_ = newData;
return newPos;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movabsq $0x2aaaaaaaaaaaaaa, %rax # imm = 0x2AAAAAAAAAAAAAA
movq 0x8(%rdi), %r13
cmpq %rax, %r13
je 0x118829
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
incq %r13
movq 0x10(%rdi), %rcx
movq %rax, %rdx
subq %rcx, %rdx
leaq (%rcx,%rcx), %rsi
cmpq %r13, %rsi
cmovaq %rsi, %r13
cmpq %rdx, %rcx
cmovaq %rax, %r13
movq %r14, %rbp
subq (%rdi), %rbp
movq %r13, %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %rdi
callq 0xe17d4
movq %rax, %r15
movq %rax, %rsi
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rax,%rbp)
movups %xmm1, 0x10(%rax,%rbp)
movups %xmm0, (%rax,%rbp)
movq (%rbx), %rdi
movq 0x8(%rbx), %r12
leaq (%r12,%r12,2), %rax
shlq $0x4, %rax
addq %rdi, %rax
subq %r14, %rax
je 0x1187c0
cmpq %r14, %rdi
je 0x118779
movq %rsi, %rcx
movq %rdi, %rdx
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups 0x20(%rdx), %xmm2
movups %xmm2, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
addq $0x30, %rdx
addq $0x30, %rcx
cmpq %r14, %rdx
jne 0x118756
movq %rdi, 0x8(%rsp)
leaq (%r15,%rbp), %rdi
addq $0x30, %rdi
addq $-0x30, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq $0x5, %rdx
leaq (%rdx,%rdx,2), %rdx
shlq $0x4, %rdx
addq $0x30, %rdx
movq %rsi, 0x10(%rsp)
movq %r14, %rsi
callq 0x374b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
jmp 0x1187ee
testq %r12, %r12
je 0x1187ee
movq %rsi, %rax
movq %rdi, %rcx
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
addq $0x30, %rcx
addq $0x30, %rax
cmpq %r14, %rcx
jne 0x1187cb
addq %rbp, %r15
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x118809
movq %rsi, %r14
callq 0xe17c0
movq %r14, %rsi
movq 0x8(%rbx), %r12
incq %r12
movq %r12, 0x8(%rbx)
movq %r13, 0x10(%rbx)
movq %rsi, (%rbx)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xdf8d1
|
/MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h
|
void slang::SmallVectorBase<slang::ast::NetAlias>::append<std::move_iterator<slang::ast::NetAlias*>>(std::move_iterator<slang::ast::NetAlias*>, std::move_iterator<slang::ast::NetAlias*>)
|
void append(TIter first, TIter last) {
auto numElems = static_cast<size_type>(std::ranges::distance(first, last));
auto newSize = len + numElems;
reserve(newSize);
std::ranges::uninitialized_copy(first, last, end(), end() + numElems);
len = newSize;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %r12
subq %rsi, %r12
sarq $0x5, %r12
addq 0x8(%rdi), %r12
movq %r12, %rsi
callq 0x118b90
movq %rbx, %rax
subq %r15, %rax
je 0x118b80
movq 0x8(%r14), %rcx
shlq $0x5, %rcx
addq (%r14), %rcx
addq $0x20, %r15
addq $-0x20, %rax
xorl %edx, %edx
movups -0x20(%r15), %xmm0
movups -0x10(%r15), %xmm1
movups %xmm1, 0x10(%rcx,%rdx)
movups %xmm0, (%rcx,%rdx)
cmpq %rbx, %r15
je 0x118b80
addq $0x20, %r15
leaq 0x20(%rdx), %rsi
cmpq %rdx, %rax
movq %rsi, %rdx
jne 0x118b58
movq %r12, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h
|
slang::ast::ParameterBuilder::createDecls(slang::ast::Scope const&, slang::syntax::ParameterDeclarationBaseSyntax const&, bool, bool, std::span<slang::syntax::AttributeInstanceSyntax const* const, 18446744073709551615ul>, slang::SmallVectorBase<slang::ast::DefinitionSymbol::ParameterDecl>&)
|
void ParameterBuilder::createDecls(const Scope& scope, const ParameterDeclarationBaseSyntax& syntax,
bool isLocal, bool isPort,
std::span<const AttributeInstanceSyntax* const> attributes,
SmallVectorBase<Decl>& results) {
if (syntax.kind == SyntaxKind::ParameterDeclaration) {
auto& paramSyntax = syntax.as<ParameterDeclarationSyntax>();
for (auto decl : paramSyntax.declarators)
results.emplace_back(scope, paramSyntax, *decl, isLocal, isPort, attributes);
}
else {
auto& paramSyntax = syntax.as<TypeParameterDeclarationSyntax>();
for (auto decl : paramSyntax.declarators)
results.emplace_back(scope, paramSyntax, *decl, isLocal, isPort, attributes);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %r8, 0x18(%rsp)
movq %r9, 0x20(%rsp)
movb %dl, 0x17(%rsp)
movb %cl, 0x16(%rsp)
cmpl $0x15e, (%rsi) # imm = 0x15E
jne 0x1199e4
movq 0x60(%rbx), %rbp
incq %rbp
cmpq $0x2, %rbp
jb 0x119a38
shrq %rbp
xorl %r15d, %r15d
leaq 0x17(%rsp), %r12
leaq 0x16(%rsp), %r13
movq 0x58(%rbx), %rdi
addq %r15, %rdi
callq 0xa1cb9
movq (%rax), %rcx
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x60(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %r8
movq %r13, %r9
callq 0x119c1a
addq $0x30, %r15
decq %rbp
jne 0x1199ab
jmp 0x119a38
movq 0x70(%rbx), %rbp
incq %rbp
cmpq $0x2, %rbp
jb 0x119a38
shrq %rbp
xorl %r15d, %r15d
leaq 0x17(%rsp), %r12
leaq 0x16(%rsp), %r13
movq 0x68(%rbx), %rdi
addq %r15, %rdi
callq 0xa1cb9
movq (%rax), %rcx
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x60(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %r8
movq %r13, %r9
callq 0x119ca0
addq $0x30, %r15
decq %rbp
jne 0x119a01
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/MikePopoloski[P]slang/source/ast/symbols/ParameterBuilder.cpp
|
slang::ast::TypeParameterSymbol* slang::BumpAllocator::emplace<slang::ast::TypeParameterSymbol, slang::ast::Scope&, std::basic_string_view<char, std::char_traits<char>> const&, slang::SourceLocation const&, bool const&, bool const&, slang::ast::ForwardTypeRestriction&>(slang::ast::Scope&, std::basic_string_view<char, std::char_traits<char>> const&, slang::SourceLocation const&, bool const&, bool const&, slang::ast::ForwardTypeRestriction&)
|
T* emplace(Args&&... args) {
static_assert(std::is_trivially_destructible_v<T>);
return new (allocate(sizeof(T), alignof(T))) T(std::forward<Args>(args)...);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq 0x40(%rsp), %rsi
movq (%rdi), %rax
movq 0x8(%rax), %rbx
addq $0x7, %rbx
andq $-0x8, %rbx
leaq 0xa8(%rbx), %rcx
cmpq 0x8(%rdi), %rcx
jbe 0x119b1d
movq %rsi, %rbx
movl $0xa8, %esi
movl $0x8, %edx
callq 0xd7432
movq %rbx, %rsi
movq %rax, %rbx
jmp 0x119b21
movq %rcx, 0x8(%rax)
movq (%rbp), %rdx
movq 0x8(%rbp), %rcx
movq (%r13), %r8
movzbl (%r12), %r9d
movzbl (%r15), %eax
movl (%rsi), %r10d
movq %rbx, %rdi
movq %r14, %rsi
pushq %r10
pushq %rax
callq 0x11b7ce
addq $0x10, %rsp
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/MikePopoloski[P]slang/source/../include/slang/util/BumpAllocator.h
|
boost::unordered::detail::foa::table_arrays<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::ExpressionSyntax const*, bool>>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::pow2_size_policy, slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::ExpressionSyntax const*, bool>>, 256ul, 16ul>>::new_(slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::ExpressionSyntax const*, bool>>, 256ul, 16ul>, unsigned long)
|
static table_arrays new_(allocator_type al, std::size_t n) {
auto groups_size_index = size_index_for<group_type, size_policy>(n);
auto groups_size = size_policy::size(groups_size_index);
table_arrays arrays{groups_size_index, groups_size - 1, nullptr, nullptr};
set_arrays(arrays, al, n);
return arrays;
}
|
pushq %rbx
movq %rdx, %r8
movq %rdi, %rbx
movabsq $-0x7777777777777777, %rcx # imm = 0x8888888888888889
movq %rdx, %rax
mulq %rcx
shrq $0x3, %rdx
je 0x119d9d
bsrq %rdx, %rax
xorq $0x3f, %rax
jmp 0x119da2
movl $0x40, %eax
cmpq $0x1e, %r8
movl $0x3f, %ecx
cmovaeq %rax, %rcx
movq %rcx, (%rbx)
negb %cl
movq $-0x1, %rax
shlq %cl, %rax
notq %rax
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
testq %r8, %r8
je 0x119dde
movq %rbx, %rdi
movq %r8, %rdx
callq 0x119df4
jmp 0x119def
movq %rbx, %rax
addq $0x10, %rax
leaq 0x256d44(%rip), %rcx # 0x370b30
movq %rcx, (%rax)
movq %rbx, %rax
popq %rbx
retq
|
/MikePopoloski[P]slang/source/../external/boost_unordered.hpp
|
boost::unordered::detail::foa::table_arrays<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::ExpressionSyntax const*, bool>>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::pow2_size_policy, slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::ExpressionSyntax const*, bool>>, 256ul, 16ul>>::set_arrays(boost::unordered::detail::foa::table_arrays<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::ExpressionSyntax const*, bool>>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::pow2_size_policy, slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::ExpressionSyntax const*, bool>>, 256ul, 16ul>>&, slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::ExpressionSyntax const*, bool>>, 256ul, 16ul>, unsigned long, std::integral_constant<bool, false>)
|
static void set_arrays(table_arrays& arrays, allocator_type al, std::size_t,
std::false_type /* always allocate */) {
using storage_traits = std::allocator_traits<allocator_type>;
auto groups_size_index = arrays.groups_size_index;
auto groups_size = size_policy::size(groups_size_index);
auto sal = allocator_type(al);
arrays.elements_ = storage_traits::allocate(sal, buffer_size(groups_size));
/* Align arrays.groups to sizeof(group_type). table_iterator critically
* depends on such alignment for its increment operation.
*/
auto p = reinterpret_cast<unsigned char*>(arrays.elements() + groups_size * N - 1);
p += (uintptr_t(sizeof(group_type)) - reinterpret_cast<uintptr_t>(p)) % sizeof(group_type);
arrays.groups_ = group_type_pointer_traits::pointer_to(*reinterpret_cast<group_type*>(p));
initialize_groups(arrays.groups(), groups_size,
is_trivially_default_constructible<group_type>{});
arrays.groups()[groups_size - 1].set_sentinel();
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rcx
movl $0x40, %r14d
subq %rcx, %r14
negq %rcx
movl $0x1f0, %edi # imm = 0x1F0
shlq %cl, %rdi
andq $-0x20, %rdi
movq 0x100(%rsi), %rax
addq $0x100, %rsi # imm = 0x100
movq %rsi, %rcx
subq %rax, %rcx
cmpq %rdi, %rcx
jae 0x119e37
callq 0xe17d4
jmp 0x119e3d
addq %rax, %rdi
movq %rdi, (%rsi)
movl $0x1, %r15d
movl %r14d, %ecx
shlq %cl, %r15
movl $0x1e0, %edx # imm = 0x1E0
shlq %cl, %rdx
movq %rax, 0x18(%rbx)
leaq (%rax,%rdx), %rcx
addq %rdx, %rax
addq $-0x20, %rax
negl %eax
andl $0xf, %eax
leaq (%rax,%rcx), %rdi
addq $-0x20, %rdi
movq %rdi, 0x10(%rbx)
movl $0x10, %edx
movl %r14d, %ecx
shlq %cl, %rdx
xorl %esi, %esi
callq 0x37300
movq 0x10(%rbx), %rax
shlq $0x4, %r15
movb $0x1, -0x2(%rax,%r15)
popq %rbx
popq %r14
popq %r15
retq
nop
|
/MikePopoloski[P]slang/source/../external/boost_unordered.hpp
|
boost::unordered::detail::foa::table_locator<boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>>> boost::unordered::detail::foa::table_core<boost::unordered::detail::foa::flat_map_types<std::basic_string_view<char, std::char_traits<char>>, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>>, 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<std::basic_string_view<char, std::char_traits<char>>, void>, std::equal_to<std::basic_string_view<char, std::char_traits<char>>>, slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>>, 256ul, 16ul>>::unchecked_emplace_with_rehash<boost::unordered::detail::foa::try_emplace_args_t, std::basic_string_view<char, std::char_traits<char>>&, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>>(unsigned long, boost::unordered::detail::foa::try_emplace_args_t&&, std::basic_string_view<char, std::char_traits<char>>&, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>&&)
|
BOOST_NOINLINE locator unchecked_emplace_with_rehash(std::size_t hash, Args&&... args) {
auto new_arrays_ = new_arrays_for_growth();
locator it;
BOOST_TRY {
/* strong exception guarantee -> try insertion before rehash */
it = nosize_unchecked_emplace_at(new_arrays_, position_for(hash, new_arrays_), hash,
std::forward<Args>(args)...);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, (%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r15
movq 0x30(%rsi), %rcx
movabsq $0xc9714fbcda3ac11, %rdx # imm = 0xC9714FBCDA3AC11
movq %rcx, %rax
mulq %rdx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x5, %rax
addq %rcx, %rax
incq %rax
testq %rax, %rax
js 0x11a22e
cvtsi2ss %rax, %xmm0
jmp 0x11a243
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
divss 0x256395(%rip), %xmm0 # 0x3705e0
callq 0x37330
cvttss2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subss 0x256380(%rip), %xmm0 # 0x3705e4
cvttss2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x119f68
xorl %eax, %eax
movq %rax, (%r14)
movl $0x0, 0x8(%r14)
movq %rax, 0x10(%r14)
movb (%r12), %cl
movq %rbp, %rax
shrq %cl, %rax
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %rax, %rcx
movq %rbp, %r8
movq %r13, %r9
pushq (%rsp)
pushq 0x10(%rsp)
callq 0x11a326
addq $0x10, %rsp
movq 0x20(%rsp), %rax
movq %rax, 0x10(%r14)
movups 0x10(%rsp), %xmm0
movups %xmm0, (%r14)
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x11a406
incq 0x30(%rbx)
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x37240
movq (%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x119d26
callq 0x378a0
movq %rax, %rbx
callq 0x379f0
movq %rbx, %rdi
callq 0x37b10
movq %rax, %rdi
callq 0x692cb
nop
|
/MikePopoloski[P]slang/source/../external/boost_unordered.hpp
|
decltype(fp0(nullptr, 0, nullptr), (void)()) boost::unordered::detail::foa::table_core<boost::unordered::detail::foa::flat_map_types<std::basic_string_view<char, std::char_traits<char>>, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>>, 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<std::basic_string_view<char, std::char_traits<char>>, void>, std::equal_to<std::basic_string_view<char, std::char_traits<char>>>, slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>>, 256ul, 16ul>>::for_all_elements_while<boost::unordered::detail::foa::table_core<boost::unordered::detail::foa::flat_map_types<std::basic_string_view<char, std::char_traits<char>>, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>>, 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<std::basic_string_view<char, std::char_traits<char>>, void>, std::equal_to<std::basic_string_view<char, std::char_traits<char>>>, slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>>, 256ul, 16ul>>::unchecked_rehash(boost::unordered::detail::foa::table_arrays<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::pow2_size_policy, slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>>, 256ul, 16ul>>&)::'lambda'(boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>*, unsigned int, std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>>*)>(boost::unordered::detail::foa::table_arrays<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::pow2_size_policy, slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>>, 256ul, 16ul>> const&, boost::unordered::detail::foa::table_core<boost::unordered::detail::foa::flat_map_types<std::basic_string_view<char, std::char_traits<char>>, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>>, 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<std::basic_string_view<char, std::char_traits<char>>, void>, std::equal_to<std::basic_string_view<char, std::char_traits<char>>>, slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>>, 256ul, 16ul>>::unchecked_rehash(boost::unordered::detail::foa::table_arrays<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::pow2_size_policy, slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>>, 256ul, 16ul>>&)::'lambda'(boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>*, unsigned int, std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::pair<slang::syntax::NamedParamAssignmentSyntax const*, bool>>*))
|
static auto for_all_elements_while(const arrays_type& arrays_, F f)
-> decltype(f(nullptr, 0, nullptr), bool()) {
auto p = arrays_.elements();
if (p) {
for (auto pg = arrays_.groups(), last = pg + arrays_.groups_size_mask + 1; pg != last;
++pg, p += N) {
auto mask = match_really_occupied(pg, last);
while (mask) {
auto n = unchecked_countr_zero(mask);
if (!f(pg, n, p + n))
return false;
mask &= mask - 1;
}
}
}
return true;
}
|
movb $0x1, %al
cmpq $0x0, 0x18(%rdi)
je 0x11a789
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdi
shlq $0x4, %rcx
leaq (%rdi,%rcx), %r8
addq $0x10, %r8
cmpq %r8, %rdi
je 0x11a789
pushq %rbx
addq %rdi, %rcx
pxor %xmm0, %xmm0
leaq 0x256437(%rip), %r8 # 0x370b20
movaps 0x255ee0(%rip), %xmm1 # 0x3705d0
movdqa (%rdi), %xmm2
pcmpeqb %xmm0, %xmm2
pmovmskb %xmm2, %r9d
notl %r9d
xorl %r10d, %r10d
cmpq %rdi, %rcx
setne %r10b
shll $0xe, %r10d
orl $0x3fff, %r10d # imm = 0x3FFF
andl %r9d, %r10d
movzwl %r10w, %r9d
testl %r9d, %r9d
je 0x11a774
bsfl %r9d, %r10d
leaq (%rdi,%r10), %r11
movzbl (%rdi,%r10), %ebx
orq $0xf, %r11
andl $0x7, %ebx
movb (%rbx,%r8), %bl
andb (%r11), %bl
negb %bl
movl $0x0, %r11d
sbbq %r11, %r11
movq %r11, %xmm2
shufps $0xe4, %xmm1, %xmm2 # xmm2 = xmm2[0,1],xmm1[2,3]
movb $0x0, (%rdi,%r10)
movdqu 0x28(%rsi), %xmm3
paddq %xmm2, %xmm3
movdqu %xmm3, 0x28(%rsi)
leal -0x1(%r9), %r10d
andl %r9d, %r10d
decq (%rdx)
movl %r10d, %r9d
jne 0x11a71c
jmp 0x11a786
leaq 0x10(%rdi), %r9
cmpq %rdi, %rcx
movq %r9, %rdi
jne 0x11a6f0
jmp 0x11a788
xorl %eax, %eax
popq %rbx
retq
|
/MikePopoloski[P]slang/source/../external/boost_unordered.hpp
|
slang::ast::DefinitionSymbol::ParameterDecl* slang::SmallVectorBase<slang::ast::DefinitionSymbol::ParameterDecl>::emplaceRealloc<slang::ast::Scope const&, slang::syntax::TypeParameterDeclarationSyntax const&, slang::syntax::TypeAssignmentSyntax const&, bool&, bool&, std::span<slang::syntax::AttributeInstanceSyntax const* const, 18446744073709551615ul>&>(slang::ast::DefinitionSymbol::ParameterDecl*, slang::ast::Scope const&, slang::syntax::TypeParameterDeclarationSyntax const&, slang::syntax::TypeAssignmentSyntax const&, bool&, bool&, std::span<slang::syntax::AttributeInstanceSyntax const* const, 18446744073709551615ul>&)
|
typename SmallVectorBase<T>::pointer SmallVectorBase<T>::emplaceRealloc(const pointer pos,
Args&&... args) {
if (len == max_size())
detail::throwLengthError();
auto newCap = calculateGrowth(len + 1);
auto offset = static_cast<size_type>(pos - begin());
auto newData = (pointer)::operator new(newCap * sizeof(T));
// First construct the new element in the new memory,
// so that we don't corrupt the new element if it relied on
// existing elements we're about to move around.
auto newPos = newData + offset;
new (newPos) T(std::forward<Args>(args)...);
// Now move elements to the new memory.
if (pos == end()) {
std::uninitialized_move(begin(), end(), newData);
}
else {
std::uninitialized_move(begin(), pos, newData);
std::uninitialized_move(pos, end(), newPos + 1);
}
cleanup();
len++;
cap = newCap;
data_ = newData;
return newPos;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movabsq $0x1ffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFF
movq 0x8(%rdi), %rbp
cmpq %rax, %rbp
je 0x11b058
movq %r9, %r13
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
incq %rbp
movq 0x10(%rdi), %rcx
movq %rax, %rdx
subq %rcx, %rdx
leaq (%rcx,%rcx), %rsi
cmpq %rbp, %rsi
cmovaq %rsi, %rbp
cmpq %rdx, %rcx
cmovaq %rax, %rbp
movq %r14, %r15
subq (%rdi), %r15
movq %rbp, %rdi
shlq $0x6, %rdi
callq 0xe17d4
movq %rax, 0x18(%rsp)
leaq (%rax,%r15), %rdi
movzbl (%r13), %r8d
movq 0x70(%rsp), %rax
movzbl (%rax), %r9d
movq 0x78(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, (%rsp)
movq %rdi, 0x20(%rsp)
movq %r12, %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
callq 0x34244c
movq (%rbx), %r13
movq 0x8(%rbx), %r12
movq %r12, %rdx
shlq $0x6, %rdx
addq %r13, %rdx
subq %r14, %rdx
je 0x11afe6
cmpq %r14, %r13
je 0x11afc0
movq 0x18(%rsp), %rax
movq %r13, %rcx
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
addq $0x40, %rcx
addq $0x40, %rax
cmpq %r14, %rcx
jne 0x11af95
movq 0x18(%rsp), %rax
leaq (%r15,%rax), %rdi
addq $0x40, %rdi
movq %rax, %r15
addq $-0x40, %rdx
andq $-0x40, %rdx
addq $0x40, %rdx
movq %r14, %rsi
callq 0x374b0
jmp 0x11b021
testq %r12, %r12
movq 0x18(%rsp), %r15
je 0x11b021
movq %r15, %rax
movq %r13, %rcx
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
addq $0x40, %rcx
addq $0x40, %rax
cmpq %r14, %rcx
jne 0x11aff6
leaq 0x18(%rbx), %rax
cmpq %rax, %r13
je 0x11b036
movq %r13, %rdi
callq 0xe17c0
movq 0x8(%rbx), %r12
incq %r12
movq %r12, 0x8(%rbx)
movq %rbp, 0x10(%rbx)
movq %r15, (%rbx)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xdf8d1
nopl (%rax)
|
/MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h
|
slang::ast::TypeParameterSymbol::serializeTo(slang::ast::ASTSerializer&) const
|
void TypeParameterSymbol::serializeTo(ASTSerializer& serializer) const {
serializer.write("type", targetType.getType());
serializer.write("isLocal", isLocalParam());
serializer.write("isPort", isPortParam());
serializer.write("isBody", isBodyParam());
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x58, %rdi
callq 0x15ac12
leaq 0x289c10(%rip), %rdx # 0x3a559c
movl $0x4, %esi
movq %rbx, %rdi
movq %rax, %rcx
callq 0x1619b2
movzbl 0x50(%r14), %ecx
leaq 0x25f4a0(%rip), %rdx # 0x37ae48
movl $0x7, %esi
movq %rbx, %rdi
callq 0x161964
movzbl 0x51(%r14), %ecx
leaq 0x25f48f(%rip), %rdx # 0x37ae50
movl $0x6, %esi
movq %rbx, %rdi
callq 0x161964
movzbl 0x51(%r14), %ecx
xorl $0x1, %ecx
leaq 0x25f47a(%rip), %rdx # 0x37ae57
movl $0x6, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x161964
nop
|
/MikePopoloski[P]slang/source/ast/symbols/ParameterSymbols.cpp
|
slang::ast::SpecparamSymbol::serializeTo(slang::ast::ASTSerializer&) const
|
void SpecparamSymbol::serializeTo(ASTSerializer& serializer) const {
serializer.write("isPathPulse", isPathPulse);
if (isPathPulse) {
serializer.write("rejectLimit", getPulseRejectLimit());
serializer.write("errorLimit", getPulseErrorLimit());
if (auto symbol = getPathSource())
serializer.writeLink("pathSource", *symbol);
if (auto symbol = getPathDest())
serializer.writeLink("pathDest", *symbol);
}
else {
serializer.write("value", getValue());
}
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzbl 0x150(%rdi), %ecx
leaq 0x25e828(%rip), %rdx # 0x37ae5e
movl $0xb, %esi
movq %rbx, %rdi
callq 0x161964
movb 0x150(%r14), %bpl
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x11c326
cmpb $0x1, %bpl
jne 0x11c70a
movq 0x158(%r14), %rcx
leaq 0x25e7fc(%rip), %rdx # 0x37ae6a
movl $0xb, %esi
movq %rbx, %rdi
callq 0x1619e0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x11c326
movq 0x160(%r14), %rcx
leaq 0x25e7e1(%rip), %rdx # 0x37ae76
movl $0xa, %esi
movq %rbx, %rdi
callq 0x1619e0
cmpb $0x0, 0x179(%r14)
jne 0x11c6b4
movq %r14, %rdi
callq 0x11c72a
movq 0x168(%r14), %rcx
testq %rcx, %rcx
je 0x11c6d4
leaq 0x25e7ba(%rip), %rdx # 0x37ae81
movl $0xa, %esi
movq %rbx, %rdi
callq 0x161b80
cmpb $0x0, 0x179(%r14)
jne 0x11c6e6
movq %r14, %rdi
callq 0x11c72a
movq 0x170(%r14), %rcx
testq %rcx, %rcx
je 0x11c725
leaq 0x25e793(%rip), %rdx # 0x37ae8c
movl $0x8, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x161b80
leaq 0x27376a(%rip), %rdx # 0x38fe7b
movl $0x5, %esi
movq %rbx, %rdi
movq %rax, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x1619e0
popq %rbx
popq %r14
popq %rbp
retq
|
/MikePopoloski[P]slang/source/ast/symbols/ParameterSymbols.cpp
|
slang::ast::ParameterSymbolBase::checkDefaultExpression() const::Visitor::handle(slang::syntax::NameSyntax const&)
|
void handle(const NameSyntax& syntax) {
LookupResult result;
Lookup::name(syntax, context, LookupFlags::ForceHierarchical, result);
result.reportDiags(context);
if (result.found)
context.getCompilation().noteReference(*result.found);
for (auto& selector : result.selectors) {
if (auto elemSel = std::get_if<0>(&selector))
(*elemSel)->visit(*this);
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x240, %rsp # imm = 0x240
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%r14)
xorl %ecx, %ecx
movq %rcx, -0x23(%r14)
movq %r14, -0x18(%r14)
movq %rcx, -0x10(%r14)
movq $0x4, -0x8(%r14)
leaq 0x108(%rsp), %r15
movq %r15, -0x18(%r15)
movq %rcx, -0x10(%r15)
movl $0x2, %edx
movq %rdx, -0x8(%r15)
leaq 0x160(%rsp), %rsi
movq %rsi, -0x18(%rsi)
movq %rcx, -0x10(%rsi)
movq %rdx, -0x8(%rsi)
movq (%rdi), %rsi
movq %rsp, %rcx
movq %rax, %rdi
movl $0x12, %edx
callq 0x1e1bc0
movq (%rbx), %rsi
movq %rsp, %rdi
callq 0x1e1b60
movq (%rsp), %rsi
testq %rsi, %rsi
je 0x11e035
movq (%rbx), %rax
movq (%rax), %rax
movq (%rax), %rdi
xorl %edx, %edx
callq 0x19bd3a
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x11e06f
movq 0x18(%rsp), %r12
shlq $0x4, %rax
leaq (%rax,%rax,2), %r13
testq %r12, %r12
je 0x11e065
cmpb $0x0, 0x28(%r12)
jne 0x11e065
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x11c9a9
addq $0x30, %r12
addq $-0x30, %r13
jne 0x11e04c
leaq 0x148(%rsp), %rbx
movq %rbx, %rdi
callq 0x6aac8
movq -0x58(%rbx), %rdi
cmpq %r15, %rdi
je 0x11e08d
callq 0xe17c0
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x11e09c
callq 0xe17c0
addq $0x240, %rsp # imm = 0x240
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x11e0af
movq %rax, %rbx
movq %rsp, %rdi
callq 0xfcde6
movq %rbx, %rdi
callq 0x37b10
|
/MikePopoloski[P]slang/source/ast/symbols/ParameterSymbols.cpp
|
void slang::syntax::SyntaxVisitor<slang::ast::ParameterSymbolBase::checkDefaultExpression() const::Visitor>::visitDefault<slang::syntax::AssertionItemPortListSyntax const&>(slang::syntax::AssertionItemPortListSyntax 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 0x11e2be
movl $0x1, %ebp
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc9464
testq %rax, %rax
je 0x11e2a1
movq %rax, %rdi
movq %r14, %rsi
callq 0x11c9a9
jmp 0x11e2ac
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc94d0
movl %ebp, %r15d
movq %rbx, %rdi
callq 0x203670
incl %ebp
cmpq %r15, %rax
ja 0x11e284
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::ast::ParameterSymbolBase::checkDefaultExpression() const::Visitor>::visitDefault<slang::syntax::BinaryPropertyExprSyntax&>(slang::syntax::BinaryPropertyExprSyntax&)
|
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 0x11f720
movl $0x1, %ebp
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc949a
testq %rax, %rax
je 0x11f703
movq %rax, %rdi
movq %r14, %rsi
callq 0x11e331
jmp 0x11f70e
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc94d0
movl %ebp, %r15d
movq %rbx, %rdi
callq 0x203670
incl %ebp
cmpq %r15, %rax
ja 0x11f6e6
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::ast::ParameterSymbolBase::checkDefaultExpression() const::Visitor>::visitDefault<slang::syntax::AnonymousProgramSyntax&>(slang::syntax::AnonymousProgramSyntax&)
|
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 0x11f7f0
movl $0x1, %ebp
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc949a
testq %rax, %rax
je 0x11f7d3
movq %rax, %rdi
movq %r14, %rsi
callq 0x11e331
jmp 0x11f7de
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc94d0
movl %ebp, %r15d
movq %rbx, %rdi
callq 0x203670
incl %ebp
cmpq %r15, %rax
ja 0x11f7b6
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::ast::ParameterSymbolBase::checkDefaultExpression() const::Visitor>::visitDefault<slang::syntax::AnsiPortListSyntax&>(slang::syntax::AnsiPortListSyntax&)
|
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 0x11f858
movl $0x1, %ebp
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc949a
testq %rax, %rax
je 0x11f83b
movq %rax, %rdi
movq %r14, %rsi
callq 0x11e331
jmp 0x11f846
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc94d0
movl %ebp, %r15d
movq %rbx, %rdi
callq 0x203670
incl %ebp
cmpq %r15, %rax
ja 0x11f81e
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::ast::ParameterSymbolBase::checkDefaultExpression() const::Visitor>::visitDefault<slang::syntax::ConcurrentAssertionStatementSyntax&>(slang::syntax::ConcurrentAssertionStatementSyntax&)
|
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 0x11fa60
movl $0x1, %ebp
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc949a
testq %rax, %rax
je 0x11fa43
movq %rax, %rdi
movq %r14, %rsi
callq 0x11e331
jmp 0x11fa4e
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc94d0
movl %ebp, %r15d
movq %rbx, %rdi
callq 0x203670
incl %ebp
cmpq %r15, %rax
ja 0x11fa26
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::ast::ParameterSymbolBase::checkDefaultExpression() const::Visitor>::visitDefault<slang::syntax::AssertionItemPortSyntax&>(slang::syntax::AssertionItemPortSyntax&)
|
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 0x11fac8
movl $0x1, %ebp
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc949a
testq %rax, %rax
je 0x11faab
movq %rax, %rdi
movq %r14, %rsi
callq 0x11e331
jmp 0x11fab6
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc94d0
movl %ebp, %r15d
movq %rbx, %rdi
callq 0x203670
incl %ebp
cmpq %r15, %rax
ja 0x11fa8e
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::ast::ParameterSymbolBase::checkDefaultExpression() const::Visitor>::visitDefault<slang::syntax::AssignmentPatternExpressionSyntax&>(slang::syntax::AssignmentPatternExpressionSyntax&)
|
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 0x11fb98
movl $0x1, %ebp
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc949a
testq %rax, %rax
je 0x11fb7b
movq %rax, %rdi
movq %r14, %rsi
callq 0x11e331
jmp 0x11fb86
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc94d0
movl %ebp, %r15d
movq %rbx, %rdi
callq 0x203670
incl %ebp
cmpq %r15, %rax
ja 0x11fb5e
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::ast::ParameterSymbolBase::checkDefaultExpression() const::Visitor>::visitDefault<slang::syntax::BeginKeywordsDirectiveSyntax&>(slang::syntax::BeginKeywordsDirectiveSyntax&)
|
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 0x11fd38
movl $0x1, %ebp
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc949a
testq %rax, %rax
je 0x11fd1b
movq %rax, %rdi
movq %r14, %rsi
callq 0x11e331
jmp 0x11fd26
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc94d0
movl %ebp, %r15d
movq %rbx, %rdi
callq 0x203670
incl %ebp
cmpq %r15, %rax
ja 0x11fcfe
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::ast::ParameterSymbolBase::checkDefaultExpression() const::Visitor>::visitDefault<slang::syntax::BinaryBlockEventExpressionSyntax&>(slang::syntax::BinaryBlockEventExpressionSyntax&)
|
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 0x11fe70
movl $0x1, %ebp
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc949a
testq %rax, %rax
je 0x11fe53
movq %rax, %rdi
movq %r14, %rsi
callq 0x11e331
jmp 0x11fe5e
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc94d0
movl %ebp, %r15d
movq %rbx, %rdi
callq 0x203670
incl %ebp
cmpq %r15, %rax
ja 0x11fe36
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/MikePopoloski[P]slang/source/../include/slang/syntax/SyntaxVisitor.h
|
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.