name string | code string | asm string | file string |
|---|---|---|---|
miniscript::Node<XOnlyPubKey>::Node(miniscript::internal::NoDupCheck, miniscript::MiniscriptContext, miniscript::Fragment, unsigned int) | Node(internal::NoDupCheck, MiniscriptContext script_ctx, Fragment nt, uint32_t val = 0)
: fragment(nt), k(val), m_script_ctx{script_ctx}, ops(CalcOps()), ss(CalcStackSize()), ws(CalcWitnessSize()), typ(CalcType()), scriptlen(CalcScriptLen()) {} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movl %edx, (%rdi)
movl %ecx, 0x4(%rdi)
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
andq $0x0, 0x48(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movl ... | /brunoerg[P]bitcoin/src/script/miniscript.h |
miniscript::Node<XOnlyPubKey>::CalcScriptLen() const | size_t CalcScriptLen() const {
size_t subsize = 0;
for (const auto& sub : subs) {
subsize += sub->ScriptSize();
}
static constexpr auto NONE_MST{""_mst};
Type sub0type = subs.size() > 0 ? subs[0]->GetType() : NONE_MST;
return internal::ComputeScriptLen(fragmen... | endbr64
subq $0x18, %rsp
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %r8
xorl %edx, %edx
movq %rax, %rcx
cmpq %r8, %rcx
je 0x8d448
movq (%rcx), %rsi
addq 0x98(%rsi), %rdx
addq $0x10, %rcx
jmp 0x8d433
subq %rax, %r8
je 0x8d458
movq (%rax), %rax
movl 0x90(%rax), %esi
jmp 0x8d45a
xorl ... | /brunoerg[P]bitcoin/src/script/miniscript.h |
miniscript::Node<XOnlyPubKey>::Node(miniscript::internal::NoDupCheck, miniscript::MiniscriptContext, miniscript::Fragment, std::vector<std::shared_ptr<miniscript::Node<XOnlyPubKey> const>, std::allocator<std::shared_ptr<miniscript::Node<XOnlyPubKey> const>>>, unsigned int) | Node(internal::NoDupCheck, MiniscriptContext script_ctx, Fragment nt, std::vector<NodeRef<Key>> sub, uint32_t val = 0)
: fragment(nt), k(val), subs(std::move(sub)), m_script_ctx{script_ctx}, ops(CalcOps()), ss(CalcStackSize()), ws(CalcWitnessSize()), typ(CalcType()), scriptlen(CalcScriptLen()) {} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, (%rsp)
movl %edx, (%rdi)
movl %r8d, 0x4(%rdi)
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups (%rcx), %xmm1
movups %xmm1, 0x38(%rdi)
movq... | /brunoerg[P]bitcoin/src/script/miniscript.h |
std::optional<TapSatisfier> miniscript::Node<XOnlyPubKey>::TreeEvalMaybe<std::optional<std::set<XOnlyPubKey, void miniscript::Node<XOnlyPubKey>::DuplicateKeyCheck<TapSatisfier>(TapSatisfier const&) const::Comp, std::allocator<XOnlyPubKey>>>, TapSatisfier miniscript::Node<XOnlyPubKey>::TreeEval<std::optional<std::set<XO... | std::optional<Result> TreeEvalMaybe(State root_state, DownFn downfn, UpFn upfn) const
{
/** Entries of the explicit stack tracked in this algorithm. */
struct StackElem
{
const Node& node; //!< The node being evaluated.
size_t expanded; //!< How many children of this ... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, (%rsp)
movq %fs:0x28, %rax
movq %rax, 0xa0(%rsp)
movq %rdx, 0x50(%rsp)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x60(%rsp),... | /brunoerg[P]bitcoin/src/script/miniscript.h |
TapSatisfier miniscript::Node<XOnlyPubKey>::TreeEval<miniscript::internal::InputResult, miniscript::internal::InputResult miniscript::Node<XOnlyPubKey>::ProduceInput<TapSatisfier>(TapSatisfier const&) const::'lambda0'(miniscript::Node<XOnlyPubKey> const&, Span<miniscript::internal::InputResult>)>(miniscript::internal::... | Result TreeEval(UpFn upfn) const
{
struct DummyState {};
return std::move(*TreeEvalMaybe<Result>(DummyState{},
[](DummyState, const Node&, size_t) { return DummyState{}; },
[&upfn](DummyState, const Node& node, Span<Result> subs) {
Result res{upfn(node, subs)}... | endbr64
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x60(%rsp)
movq %rsp, %rax
movq %rdx, (%rax)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0x9091e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x90b7e
movq %r14, %rdi
callq 0x96a18
movq %fs:0x28, %rax
cmpq 0x60(%rsp), %... | /brunoerg[P]bitcoin/src/script/miniscript.h |
miniscript::internal::InputResult::InputResult<miniscript::internal::InputStack, miniscript::internal::InputStack>(miniscript::internal::InputStack&&, miniscript::internal::InputStack&&) | InputResult(A&& in_nsat, B&& in_sat) : nsat(std::forward<A>(in_nsat)), sat(std::forward<B>(in_sat)) {} | endbr64
pushq %rax
movq %fs:0x28, %rax
movq %rax, (%rsp)
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movups 0x10(%rsi), %xmm0
movups %xmm0, 0x10(%rdi)
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsi)
andq $0x0, 0x20(%rsi)
movups (%rdx), %xmm1
movups %xmm1, 0x28(%rdi)
movups 0x10(%rd... | /brunoerg[P]bitcoin/src/script/miniscript.h |
void Serialize<SizeComputer, std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>(SizeComputer&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>... | void Serialize(Stream& os, const std::vector<T, A>& v)
{
if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
WriteCompactSize(os, v.size());
if (!v.empty()) os.write(MakeByteSpan(v));
} else if constexpr (std::is_same_v<T, bool>) {
// A special case for std... | endbr64
subq $0x18, %rsp
movq %rdi, %rax
movq %fs:0x28, %rcx
movq %rcx, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
movq %rsi, (%rdi)
movq %rax, %rsi
callq 0x96d72
movq %fs:0x28, %rax
cmpq 0x10(%rsp), %rax
jne 0x96d6d
addq $0x18, %rsp
retq
callq 0xd6f0
| /brunoerg[P]bitcoin/src/serialize.h |
void Serialize<SizeComputer, unsigned char, std::allocator<unsigned char>>(SizeComputer&, std::vector<unsigned char, std::allocator<unsigned char>> const&) | void Serialize(Stream& os, const std::vector<T, A>& v)
{
if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
WriteCompactSize(os, v.size());
if (!v.empty()) os.write(MakeByteSpan(v));
} else if constexpr (std::is_same_v<T, bool>) {
// A special case for std... | endbr64
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, (%rsp)
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
callq 0x2a324
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x96e60
subq %rax, %rcx
addq %rcx, (%rbx)
movq %fs:0x28, %rax
cmpq (%rsp), %rax
jne 0x96e77
addq $... | /brunoerg[P]bitcoin/src/serialize.h |
miniscript::Node<CPubKey>::CalcOps() const | internal::Ops CalcOps() const {
switch (fragment) {
case Fragment::JUST_1: return {0, 0, {}};
case Fragment::JUST_0: return {0, {}, 0};
case Fragment::PK_K: return {0, 0, 0};
case Fragment::PK_H: return {3, 0, 0};
case Fragment::OLDER:
case... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %fs:0x28, %rax
movq %rax, 0x70(%rsp)
movl (%rsi), %eax
cmpq $0x1a, %rax
ja 0x9b176
movq %rsi, %r13
movq %rdi, %r12
leaq 0x9c7f9(%rip), %rcx # 0x137490
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4, (%r1... | /brunoerg[P]bitcoin/src/script/miniscript.h |
miniscript::Node<CPubKey>::CalcStackSize() const | internal::StackSize CalcStackSize() const {
using namespace internal;
switch (fragment) {
case Fragment::JUST_0: return {{}, SatInfo::Push()};
case Fragment::JUST_1: return {SatInfo::Push(), {}};
case Fragment::OLDER:
case Fragment::AFTER: return {SatInfo:... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %fs:0x28, %rax
movq %rax, 0xf0(%rsp)
movl (%rsi), %eax
cmpq $0x1a, %rax
ja 0x9be66
movq %rsi, %r14
movq %rdi, %r15
leaq 0x9c2db(%rip), %rcx # 0x1374fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movabsq $-0xfff... | /brunoerg[P]bitcoin/src/script/miniscript.h |
miniscript::Node<CPubKey>::CalcType() const | Type CalcType() const {
using namespace internal;
// THRESH has a variable number of subexpressions
std::vector<Type> sub_types;
if (fragment == Fragment::THRESH) {
for (const auto& sub : subs) sub_types.push_back(sub->GetType());
}
// All other nodes than TH... | endbr64
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x28(%rsp)
andq $0x0, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
cmpl $0x18, (%rdi)
jne 0x9c51b
movq 0x38(%rbx), %r12
movq 0x40(%rbx), %r13
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r1... | /brunoerg[P]bitcoin/src/script/miniscript.h |
miniscript::Node<CPubKey>::~Node() | ~Node() {
while (!subs.empty()) {
auto node = std::move(subs.back());
subs.pop_back();
while (!node->subs.empty()) {
subs.push_back(std::move(node->subs.back()));
node->subs.pop_back();
}
}
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
leaq 0x38(%rdi), %r14
leaq 0x8(%rsp), %r15
movq 0x40(%rbx), %rax
cmpq %rax, 0x38(%rbx)
je 0x9c71d
andq $0x0, 0x8(%rsp)
movups -0x10(%rax), %xmm0
andq $0x0, -0x8(%rax)
movaps %xmm0, (%rsp)
andq $0x0, -0x10... | /brunoerg[P]bitcoin/src/script/miniscript.h |
miniscript::Node<CPubKey>::Node(miniscript::internal::NoDupCheck, miniscript::MiniscriptContext, miniscript::Fragment, std::vector<unsigned char, std::allocator<unsigned char>>, unsigned int) | Node(internal::NoDupCheck, MiniscriptContext script_ctx, Fragment nt, std::vector<unsigned char> arg, uint32_t val = 0)
: fragment(nt), k(val), data(std::move(arg)), m_script_ctx{script_ctx}, ops(CalcOps()), ss(CalcStackSize()), ws(CalcWitnessSize()), typ(CalcType()), scriptlen(CalcScriptLen()) {} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, (%rsp)
movl %edx, (%rdi)
movl %r8d, 0x4(%rdi)
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
leaq 0x20(%rdi), %r15
movups (%rcx), %xmm1
movups %xmm1, 0x20(%rdi)
movq 0x10(... | /brunoerg[P]bitcoin/src/script/miniscript.h |
miniscript::internal::InputResult miniscript::Node<CPubKey>::ProduceInput<WshSatisfier>(WshSatisfier const&) const | internal::InputResult ProduceInput(const Ctx& ctx) const {
using namespace internal;
// Internal function which is invoked for every tree node, constructing satisfaction/dissatisfactions
// given those of its subnodes.
auto helper = [&ctx](const Node& node, Span<InputResult> subres) -> ... | endbr64
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movq %rsp, %rax
movq %rdx, (%rax)
movq %rax, %rdx
callq 0x9fa28
movq %fs:0x28, %rax
cmpq 0x8(%rsp), %rax
jne 0x9fa23
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
callq 0xd6f0
| /brunoerg[P]bitcoin/src/script/miniscript.h |
std::optional<WshSatisfier> miniscript::Node<CPubKey>::TreeEvalMaybe<miniscript::internal::InputResult, WshSatisfier miniscript::Node<CPubKey>::TreeEval<miniscript::internal::InputResult, miniscript::internal::InputResult miniscript::Node<CPubKey>::ProduceInput<WshSatisfier>(WshSatisfier const&) const::'lambda0'(minisc... | std::optional<Result> TreeEvalMaybe(State root_state, DownFn downfn, UpFn upfn) const
{
/** Entries of the explicit stack tracked in this algorithm. */
struct StackElem
{
const Node& node; //!< The node being evaluated.
size_t expanded; //!< How many children of this ... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, (%rsp)
movq %fs:0x28, %rax
movq %rax, 0xb0(%rsp)
movq %rdx, 0x48(%rsp)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x58(%rsp),... | /brunoerg[P]bitcoin/src/script/miniscript.h |
FlatSigningProvider::GetTaprootSpendData(XOnlyPubKey const&, TaprootSpendData&) const | bool FlatSigningProvider::GetTaprootSpendData(const XOnlyPubKey& output_key, TaprootSpendData& spenddata) const
{
TaprootBuilder builder;
if (LookupHelper(tr_trees, output_key, builder)) {
spenddata = builder.GetSpendData();
return true;
}
return false;
} | endbr64
pushq %rbp
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdx, %r14
movq %fs:0x28, %rax
movq %rax, 0xd8(%rsp)
leaq 0x78(%rsp), %rbx
movb $0x1, -0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
andq $0x0, 0x50(%rbx... | /brunoerg[P]bitcoin/src/script/signingprovider.cpp |
FlatSigningProvider::Merge(FlatSigningProvider&&) | FlatSigningProvider& FlatSigningProvider::Merge(FlatSigningProvider&& b)
{
scripts.merge(b.scripts);
pubkeys.merge(b.pubkeys);
keys.merge(b.keys);
origins.merge(b.origins);
tr_trees.merge(b.tr_trees);
return *this;
} | endbr64
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, (%rsp)
addq $0x8, %rdi
addq $0x8, %rsi
callq 0xa8260
leaq 0x38(%rbx), %rdi
leaq 0x38(%r14), %rsi
callq 0xa8312
movl $0x98, %esi
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0xa83c4
leaq 0x68(%rbx), %rdi
leaq 0x68(%r1... | /brunoerg[P]bitcoin/src/script/signingprovider.cpp |
FillableSigningProvider::GetKey(CKeyID const&, CKey&) const | bool FillableSigningProvider::GetKey(const CKeyID &address, CKey &keyOut) const
{
LOCK(cs_KeyStore);
KeyMap::const_iterator mi = mapKeys.find(address);
if (mi != mapKeys.end()) {
keyOut = mi->second;
return true;
}
return false;
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
leaq 0x68(%rdi), %rsi
leaq 0x9387c(%rip), %rdx # 0x13898f
leaq 0x93881(%rip), %rcx # 0x13899b
leaq 0x8(%rsp), %rdi
movl $0x95, %r8d
xorl %r9d, %r9d
callq 0x302f8
le... | /brunoerg[P]bitcoin/src/script/signingprovider.cpp |
FillableSigningProvider::AddCScript(CScript const&) | bool FillableSigningProvider::AddCScript(const CScript& redeemScript)
{
if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE) {
LogError("FillableSigningProvider::AddCScript(): redeemScripts > %i bytes are invalid\n", MAX_SCRIPT_ELEMENT_SIZE);
return false;
}
LOCK(cs_KeyStore);
mapScripts[... | endbr64
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %fs:0x28, %rax
movq %rax, 0x28(%rsp)
movl 0x1c(%rsi), %ebp
cmpl $0x226, %ebp # imm = 0x226
jae 0xa522d
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x68(%rdi), %rsi
leaq 0x937ad(%rip), %rdx # 0x13898f
leaq 0x937b2(%rip), %rcx # 0x13899b
movq %rsp... | /brunoerg[P]bitcoin/src/script/signingprovider.cpp |
FillableSigningProvider::GetCScripts() const | std::set<CScriptID> FillableSigningProvider::GetCScripts() const
{
LOCK(cs_KeyStore);
std::set<CScriptID> set_script;
for (const auto& mi : mapScripts) {
set_script.insert(mi.first);
}
return set_script;
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
addq $0x68, %rsi
leaq 0x93603(%rip), %rdx # 0x13898f
leaq 0x93608(%rip), %rcx # 0x13899b
leaq 0x8(%rsp), %rdi
movl $0xb2, %r8d
xorl %r9d, %r9d
callq 0x302f8
leaq 0x8(%rbx), %rax
an... | /brunoerg[P]bitcoin/src/script/signingprovider.cpp |
FillableSigningProvider::GetCScript(CScriptID const&, CScript&) const | bool FillableSigningProvider::GetCScript(const CScriptID &hash, CScript& redeemScriptOut) const
{
LOCK(cs_KeyStore);
ScriptMap::const_iterator mi = mapScripts.find(hash);
if (mi != mapScripts.end())
{
redeemScriptOut = (*mi).second;
return true;
}
return false;
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
leaq 0x68(%rdi), %rsi
leaq 0x9351c(%rip), %rdx # 0x13898f
leaq 0x93521(%rip), %rcx # 0x13899b
leaq 0x8(%rsp), %rdi
movl $0xbc, %r8d
xorl %r9d, %r9d
callq 0x302f8
le... | /brunoerg[P]bitcoin/src/script/signingprovider.cpp |
MultiSigningProvider::GetCScript(CScriptID const&, CScript&) const | bool MultiSigningProvider::GetCScript(const CScriptID& scriptid, CScript& script) const
{
for (const auto& provider: m_providers) {
if (provider->GetCScript(scriptid, script)) return true;
}
return false;
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %fs:0x28, %rax
movq %rax, (%rsp)
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %r15
movq %rcx, %r12
cmpq %r15, %rcx
je 0xa57ea
movq (%r12), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%rax)
leaq 0x8(%r12),... | /brunoerg[P]bitcoin/src/script/signingprovider.cpp |
MultiSigningProvider::GetKeyOrigin(CKeyID const&, KeyOriginInfo&) const | bool MultiSigningProvider::GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const
{
for (const auto& provider: m_providers) {
if (provider->GetKeyOrigin(keyid, info)) return true;
}
return false;
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %fs:0x28, %rax
movq %rax, (%rsp)
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %r15
movq %rcx, %r12
cmpq %r15, %rcx
je 0xa58c6
movq (%r12), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x38(%rax)
leaq 0x8(%r12),... | /brunoerg[P]bitcoin/src/script/signingprovider.cpp |
MultiSigningProvider::GetTaprootSpendData(XOnlyPubKey const&, TaprootSpendData&) const | bool MultiSigningProvider::GetTaprootSpendData(const XOnlyPubKey& output_key, TaprootSpendData& spenddata) const
{
for (const auto& provider: m_providers) {
if (provider->GetTaprootSpendData(output_key, spenddata)) return true;
}
return false;
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %fs:0x28, %rax
movq %rax, (%rsp)
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %r15
movq %rcx, %r12
cmpq %r15, %rcx
je 0xa59a2
movq (%r12), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x40(%rax)
leaq 0x8(%r12),... | /brunoerg[P]bitcoin/src/script/signingprovider.cpp |
TaprootSpendData::Merge(TaprootSpendData) | void TaprootSpendData::Merge(TaprootSpendData other)
{
// TODO: figure out how to better deal with conflicting information
// being merged.
if (internal_key.IsNull() && !other.internal_key.IsNull()) {
internal_key = other.internal_key;
}
if (merkle_root.IsNull() && !other.merkle_root.IsNull(... | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, (%rsp)
callq 0x28934
testb %al, %al
je 0xa5b9c
movq %rbx, %rdi
callq 0x28934
testb %al, %al
jne 0xa5b9c
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14... | /brunoerg[P]bitcoin/src/script/signingprovider.cpp |
TaprootBuilder::Insert(TaprootBuilder::NodeInfo&&, int) | void TaprootBuilder::Insert(TaprootBuilder::NodeInfo&& node, int depth)
{
assert(depth >= 0 && (size_t)depth <= TAPROOT_CONTROL_MAX_NODE_COUNT);
/* We cannot insert a leaf at a lower depth while a deeper branch is unfinished. Doing
* so would mean the Add() invocations do not correspond to a DFS traversal ... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
cmpl $0x81, %edx
jae 0xa5d5a
movq %rdi, %r14
leal 0x1(%rdx), %eax
movq 0x10(%rdi), %rcx
subq 0x8(%rdi), %rcx
sarq $0x6, %rcx
cmpq %rax, %rcx
jbe 0xa5c76
movb $0x0, (%r14)
jmp 0xa5d3b
movq... | /brunoerg[P]bitcoin/src/script/signingprovider.cpp |
TaprootBuilder::ValidDepths(std::vector<int, std::allocator<int>> const&) | bool TaprootBuilder::ValidDepths(const std::vector<int>& depths)
{
std::vector<bool> branch;
for (int depth : depths) {
// This inner loop corresponds to effectively the same logic on branch
// as what Insert() performs on the m_branch variable. Instead of
// storing a NodeInfo object, j... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %fs:0x28, %rax
movq %rax, 0x28(%rsp)
movq %rsp, %rbx
andq $0x0, (%rbx)
andl $0x0, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
andl $0x0, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
movq (%rdi), %r15
movq 0x8(%rdi), %r12
pushq $0x3f
popq %rbp
cmpq %r12, %r15
... | /brunoerg[P]bitcoin/src/script/signingprovider.cpp |
InferTaprootTree(TaprootSpendData const&, XOnlyPubKey const&) | std::optional<std::vector<std::tuple<int, std::vector<unsigned char>, int>>> InferTaprootTree(const TaprootSpendData& spenddata, const XOnlyPubKey& output)
{
// Verify that the output matches the assumed Merkle root and internal key.
auto tweak = spenddata.internal_key.CreateTapTweak(spenddata.merkle_root.IsNul... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x130(%rsp)
leaq 0x20(%rsi), %r13
movq %r13, %rdi
callq 0x28934
xorl %edx, %edx
testb %al, %al
cmoveq %r13, %rdx
leaq 0x10e(... | /brunoerg[P]bitcoin/src/script/signingprovider.cpp |
bool LookupHelper<std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>, std::less<CKeyID>, std::allocator<std::pair<CKeyID const, std::pair<CPubKey, KeyOriginInfo>>>>, CKeyID, std::pair<CPubKey, KeyOriginInfo>>(std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>, std::less<CKeyID>, std::allocator<std::pair<CKeyID const, s... | bool LookupHelper(const M& map, const K& key, V& value)
{
auto it = map.find(key);
if (it != map.end()) {
value = it->second;
return true;
}
return false;
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
callq 0x87370
movq %rax, %r15
addq $0x8, %rbx
cmpq %rbx, %rax
je 0xa6e43
leaq 0x38(%r15), %rsi
movq %r14, %rdi
callq 0xa813a
cmpq %rbx, %r15
setne %al
movq %fs:0x28, %rcx
cmpq 0x8(%rsp), %r... | /brunoerg[P]bitcoin/src/script/signingprovider.cpp |
GetTxnOutputType[abi:cxx11](TxoutType) | std::string GetTxnOutputType(TxoutType t)
{
switch (t) {
case TxoutType::NONSTANDARD: return "nonstandard";
case TxoutType::PUBKEY: return "pubkey";
case TxoutType::PUBKEYHASH: return "pubkeyhash";
case TxoutType::SCRIPTHASH: return "scripthash";
case TxoutType::MULTISIG: return "multisig";
... | endbr64
pushq %rbx
subq $0x10, %rsp
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
cmpl $0xa, %esi
ja 0xab972
movq %rdi, %rbx
movl %esi, %eax
leaq 0x8d4bc(%rip), %rcx # 0x138d98
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8d4d7(%rip), %rsi # 0x138dc4
jmp 0xab947
leaq 0x8d513(%rip), %rsi # 0x138e0... | /brunoerg[P]bitcoin/src/script/solver.cpp |
ParseOutputType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::optional<OutputType> ParseOutputType(const std::string& type)
{
if (type == OUTPUT_TYPE_STRING_LEGACY) {
return OutputType::LEGACY;
} else if (type == OUTPUT_TYPE_STRING_P2SH_SEGWIT) {
return OutputType::P2SH_SEGWIT;
} else if (type == OUTPUT_TYPE_STRING_BECH32) {
return OutputT... | endbr64
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, (%rsp)
movabsq $0x100000000, %rbx # imm = 0x100000000
leaq 0x2135e7(%rip), %rsi # 0x2c2c78
callq 0x30370
testb %al, %al
je 0xaf69e
xorl %eax, %eax
jmp 0xaf6e6
leaq 0x2135f3(%rip), %rsi # 0x2c2c98
movq %r14, %rdi
callq 0x3... | /brunoerg[P]bitcoin/src/outputtype.cpp |
TryCreateDirectories(fs::path const&) | bool TryCreateDirectories(const fs::path& p)
{
try {
return fs::create_directories(p);
} catch (const fs::filesystem_error&) {
if (!fs::exists(p) || !fs::is_directory(p))
throw;
}
// create_directories didn't create the directory, it had to have existed already
return fa... | endbr64
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, (%rsp)
callq 0x326fb
testb %al, %al
je 0xb2027
movq %rbx, %rdi
callq 0x30880
testb %al, %al
je 0xb2027
xorl %eax, %eax
jmp 0xb202f
movq %rbx, %rdi
callq 0xd410
movq %fs:0x28, %rcx
cmpq (%rsp), %rcx
jne 0xb20b0
addq $0x8, %rsp
popq %... | /brunoerg[P]bitcoin/src/util/fs_helpers.cpp |
SplitHostPort(std::basic_string_view<char, std::char_traits<char>>, unsigned short&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool SplitHostPort(std::string_view in, uint16_t& portOut, std::string& hostOut)
{
bool valid = false;
size_t colon = in.find_last_of(':');
// if a : is found, and it either follows a [...], or no other : is in the string, treat it as port separator
bool fHaveColon = colon != in.npos;
bool fBrackete... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %fs:0x28, %rax
movq %rax, 0x28(%rsp)
leaq 0x18(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
pushq $0x3a
popq %rsi
pushq $-0x1
popq %rdx
movq %rax, %rdi
callq 0xb4fc4
movb $0x1, %bpl
cmpq $-0x1, %ra... | /brunoerg[P]bitcoin/src/util/strencodings.cpp |
EncodeBase64[abi:cxx11](Span<unsigned char const>) | std::string EncodeBase64(Span<const unsigned char> input)
{
static const char *pbase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
std::string str;
str.reserve(((input.size() + 2) / 3) * 4);
ConvertBits<8, 6, true>([&](int v) { str += pbase64[v]; }, input.begin(), input.end())... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x2(%rdx), %rax
pushq $0x3
popq %rcx
xorl %edx, %ed... | /brunoerg[P]bitcoin/src/util/strencodings.cpp |
FormatParagraph[abi:cxx11](std::basic_string_view<char, std::char_traits<char>>, unsigned long, unsigned long) | std::string FormatParagraph(std::string_view in, size_t width, size_t indent)
{
assert(width >= indent);
std::stringstream out;
size_t ptr = 0;
size_t indented = 0;
while (ptr < in.size())
{
size_t lineend = in.find_first_of('\n', ptr);
if (lineend == std::string::npos) {
... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, 0x8(%rsp)
movq %fs:0x28, %rax
movq %rax, 0x1d0(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %r8, 0x10(%rsp)
cmpq %r8, %rcx
jb 0xb4479
movq %rcx, %r12
movq %rsi, %r14
leaq 0x48(%rsp),... | /brunoerg[P]bitcoin/src/util/strencodings.cpp |
ToUpper[abi:cxx11](std::basic_string_view<char, std::char_traits<char>>) | std::string ToUpper(std::string_view str)
{
std::string r;
r.reserve(str.size());
for (auto ch : str) r += ToUpper(ch);
return r;
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, (%rsp)
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x186d0
xorl %r12d, %r12d
cmpq %r12, %r15
je 0xb494b
movzbl (%r14,%r12), %eax
leal... | /brunoerg[P]bitcoin/src/util/strencodings.cpp |
std::optional<unsigned char> ToIntegral<unsigned char>(std::basic_string_view<char, std::char_traits<char>>) | std::optional<T> ToIntegral(std::string_view str)
{
static_assert(std::is_integral<T>::value);
T result;
const auto [first_nonmatching, error_condition] = std::from_chars(str.data(), str.data() + str.size(), result);
if (first_nonmatching != str.data() + str.size() || error_condition != std::errc{}) {
... | endbr64
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
addq %rsi, %rbx
leaq 0xf(%rsp), %r14
pushq $0xa
popq %rcx
movq %rsi, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xb55d9
movzbl (%r14), %ecx
orl $0x100, %ecx # imm = 0x100
xorl %esi, %esi
testl %edx, %edx
... | /brunoerg[P]bitcoin/src/util/strencodings.h |
BCLog::Logger::LogPrintStr_(std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, int, BCLog::LogFlags, BCLog::Level) | void BCLog::Logger::LogPrintStr_(std::string_view str, std::string_view logging_function, std::string_view source_file, int source_line, BCLog::LogFlags category, BCLog::Level level)
{
std::string str_prefixed = LogEscapeMessage(str);
const bool starts_new_line = m_started_new_line;
m_started_new_line = !s... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movl %r9d, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x140(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x70(%rsp)
leaq 0x120(%rsp), %rdi
callq 0xc9d4e
movb 0x68(%rbx),... | /brunoerg[P]bitcoin/src/logging.cpp |
BCLog::Logger::DisconnectTestLogger() | void BCLog::Logger::DisconnectTestLogger()
{
StdLockGuard scoped_lock(m_cs);
m_buffering = true;
if (m_fileout != nullptr) fclose(m_fileout);
m_fileout = nullptr;
m_print_callbacks.clear();
m_max_buffer_memusage = DEFAULT_MAX_LOG_BUFFER;
m_cur_buffer_memusage = 0;
m_buffer_lines_discarde... | endbr64
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
callq 0x261a2
movb $0x1, 0x48(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xc946d
callq 0xd630
andq $0x0, 0x28(%rbx)
leaq 0xb8(%rbx), %rdi
callq 0xca624
movq $0xf4240, 0x50(%rbx) # imm = 0xF4240
leaq 0x30(%rbx), %rdi
xor... | /brunoerg[P]bitcoin/src/logging.cpp |
BCLog::Logger::WillLogCategoryLevel(BCLog::LogFlags, BCLog::Level) const | bool BCLog::Logger::WillLogCategoryLevel(BCLog::LogFlags category, BCLog::Level level) const
{
// Log messages at Info, Warning and Error level unconditionally, so that
// important troubleshooting information doesn't get lost.
if (level >= BCLog::Level::Info) return true;
if (!WillLogCategory(category... | endbr64
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movq %rsi, (%rsp)
movb $0x1, %r14b
cmpl $0x1, %edx
jg 0xc97ae
movq %rdi, %rbx
movq 0xb0(%rdi), %rax
testq %rsi, %rax
je 0xc9795
movl %edx, %ebp
movq %rbx, %rdi
callq 0x261a2
leaq 0x70(%rbx), %rdi
movq %rsp, %rsi
callq 0xc... | /brunoerg[P]bitcoin/src/logging.cpp |
BCLog::Logger::SetCategoryLogLevel(std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>) | bool BCLog::Logger::SetCategoryLogLevel(std::string_view category_str, std::string_view level_str)
{
BCLog::LogFlags flag;
if (!GetLogCategory(flag, category_str)) return false;
const auto level = GetLogLevel(level_str);
if (!level.has_value() || level.value() > MAX_USER_SETABLE_SEVERITY_LEVEL) return ... | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movq %rsp, %rdi
callq 0xc95d3
testb %al, %al
je 0xca457
movq %r15, %rdi
movq %r14, %rsi
callq 0xca328
movq %rax, %r14
btq $0x20, %rax
setae %al
cmpl $0x3, %r14d
setge %cl
orb... | /brunoerg[P]bitcoin/src/logging.cpp |
(anonymous namespace)::SeedStrengthen(CSHA512&, (anonymous namespace)::RNGState&, std::chrono::duration<long, std::ratio<1l, 1000000000l>>) | void SeedStrengthen(CSHA512& hasher, RNGState& rng, SteadyClock::duration dur) noexcept
{
// Generate 32 bytes of entropy from the RNG, and a copy of the entropy already in hasher.
// Never use the deterministic PRNG for this, as the result is only used internally.
unsigned char strengthen_seed[32];
rng... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x140(%rsp)
leaq 0x78(%rsp), %r12
movl $0xc8, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0xd530
leaq 0x10(%rsp), %rsi
pushq $0x20
po... | /brunoerg[P]bitcoin/src/random.cpp |
void LogPrintFormatInternal<unsigned long>(std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, int, BCLog::LogFlags, BCLog::Level, util::ConstevalFormatString<sizeof...(unsigned long)>, unsigned long const&) | inline void LogPrintFormatInternal(std::string_view logging_function, std::string_view source_file, const int source_line, const BCLog::LogFlags flag, const BCLog::Level level, util::ConstevalFormatString<sizeof...(Args)> fmt, const Args&... args)
{
if (LogInstance().Enabled()) {
std::string log_msg;
... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, %r15
movl %r8d, %ebx
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r12
movq %fs:0x28, %rax
movq %rax, 0xf0(%rsp)
callq 0xc8a44
movq %rax, %rdi
callq 0x26134
testb %al, %al
je 0xcee25
movl %ebx, 0x34(%rsp)
... | /brunoerg[P]bitcoin/src/logging.h |
PosixLockedPageAllocator::AllocateLocked(unsigned long, bool*) | void *PosixLockedPageAllocator::AllocateLocked(size_t len, bool *lockingSuccess)
{
void *addr;
len = align_up(len, page_size);
addr = mmap(nullptr, len, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
if (addr == MAP_FAILED) {
return nullptr;
}
if (addr) {
*lockingSucces... | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %fs:0x28, %rax
movq %rax, (%rsp)
movq 0x8(%rdi), %r14
leaq (%rsi,%r14), %rax
decq %rax
negq %r14
andq %rax, %r14
xorl %r12d, %r12d
pushq $0x3
popq %rdx
pushq $0x22
popq %rcx
pushq $-0x1
popq %r8
xorl %edi, %edi
movq %r14, %rsi
xorl %r9d... | /brunoerg[P]bitcoin/src/support/lockedpool.cpp |
FormatSubVersion(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | std::string FormatSubVersion(const std::string& name, int nClientVersion, const std::vector<std::string>& comments)
{
std::string comments_str;
if (!comments.empty()) comments_str = strprintf("(%s)", Join(comments, "; "));
return strprintf("/%s:%s%s/", name, FormatVersion(nClientVersion), comments_str);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x70(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
je 0xd2e2c
leaq 0x79835(%rip), %rdx ... | /brunoerg[P]bitcoin/src/clientversion.cpp |
CopyrightHolders(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string CopyrightHolders(const std::string& strPrefix)
{
const auto copyright_devs = strprintf(_(COPYRIGHT_HOLDERS).translated, COPYRIGHT_HOLDERS_SUBSTITUTION);
std::string strCopyrightHolders = strPrefix + copyright_devs;
// Make sure Bitcoin Core copyright is not removed by accident
if (copyright... | endbr64
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x80(%rsp)
leaq 0x796ea(%rip), %rsi # 0x14c627
leaq 0x20(%rsp), %rdi
callq 0x86a2f
leaq 0x40(%rsp), %rsi
leaq 0x511fe(%rip), %rdx # 0x124151
leaq 0x60(%rsp), %rdi
callq 0xd3728
leaq 0x20(%rsp), %rdi
cal... | /brunoerg[P]bitcoin/src/clientversion.cpp |
void tinyformat::formatValue<char [27]>(std::ostream&, char const*, char const*, int, char const (&) [27]) | inline void formatValue(std::ostream& out, const char* /*fmtBegin*/,
const char* fmtEnd, int ntrunc, const T& value)
{
#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
// Since we don't support printing of wchar_t using "%ls", make it fail at
// compile time in preference to printing as a void* at... | endbr64
pushq %rax
movq %fs:0x28, %rax
movq %rax, (%rsp)
cmpb $0x70, -0x1(%rdx)
jne 0xd3f1c
movq %fs:0x28, %rax
cmpq (%rsp), %rax
jne 0xd3f52
movq %r8, %rsi
popq %rax
jmp 0xd500
testl %ecx, %ecx
js 0xd3f3a
movq %fs:0x28, %rax
cmpq (%rsp), %rax
jne 0xd3f52
movq %r8, %rsi
movl %ecx, %edx
popq %rax
jmp 0x17a89
movq %fs:0x... | /brunoerg[P]bitcoin/src/tinyformat.h |
void tinyformat::format<char [8], char [38]>(std::ostream&, char const*, char const (&) [8], char const (&) [38]) | void format(std::ostream& out, const char* fmt, const Args&... args)
{
vformat(out, fmt, makeFormatList(args...));
} | endbr64
subq $0x48, %rsp
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movl $0x2, -0x8(%rax)
movq %rdx, (%rax)
leaq 0x4b(%rip), %rdx # 0xd408a
movq %rdx, 0x8(%rax)
leaq 0x6c(%rip), %rdx # 0xd40b6
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
leaq 0x1ad(%rip), %rcx ... | /brunoerg[P]bitcoin/src/tinyformat.h |
UniValue::setInt(unsigned long) | void UniValue::setInt(uint64_t val_)
{
std::ostringstream oss;
oss << val_;
return setNumStr(oss.str());
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x198(%rsp)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xd840
movq %r15, %rdi
movq %r14, %rsi
callq 0xd440
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0xd4c0
movq %rsp, %rs... | /brunoerg[P]bitcoin/src/univalue/lib/univalue.cpp |
UniValue::setInt(long) | void UniValue::setInt(int64_t val_)
{
std::ostringstream oss;
oss << val_;
return setNumStr(oss.str());
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x198(%rsp)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xd840
movq %r15, %rdi
movq %r14, %rsi
callq 0xd600
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0xd4c0
movq %rsp, %rs... | /brunoerg[P]bitcoin/src/univalue/lib/univalue.cpp |
UniValue::setFloat(double) | void UniValue::setFloat(double val_)
{
std::ostringstream oss;
oss << std::setprecision(16) << val_;
return setNumStr(oss.str());
} | endbr64
pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movsd %xmm0, (%rsp)
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x1a0(%rsp)
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xd840
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x10, 0x30(%rsp,%rax)
movq %r14, %rdi
movsd (%rsp), %xmm0
callq 0xda20... | /brunoerg[P]bitcoin/src/univalue/lib/univalue.cpp |
UniValue::checkType(UniValue::VType const&) const | void UniValue::checkType(const VType& expected) const
{
if (typ != expected) {
throw type_error{"JSON value of type " + std::string{uvTypeName(typ)} + " is not of expected type " +
std::string{uvTypeName(expected)}};
}
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %fs:0x28, %rax
movq %rax, 0xb0(%rsp)
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0xd4b49
movq %fs:0x28, %rax
cmpq 0xb0(%rsp), %rax
jne 0xd4cb0
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r14
movq %rdi, %r15
pushq $0x10
p... | /brunoerg[P]bitcoin/src/univalue/lib/univalue.cpp |
UniValue::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | const UniValue& UniValue::operator[](const std::string& key) const
{
if (typ != VOBJ)
return NullUniValue;
size_t index = 0;
if (!findKey(key, index))
return NullUniValue;
return values.at(index);
} | endbr64
pushq %rbx
subq $0x10, %rsp
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
cmpl $0x1, (%rdi)
jne 0xd51e1
movq %rdi, %rbx
movq %rsp, %rdx
andq $0x0, (%rdx)
callq 0xd4ea8
testb %al, %al
je 0xd51e1
addq $0x40, %rbx
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0xd53ce
jmp 0xd51e8
leaq 0x1ede20(%rip), %rax # 0x2c3008
movq %... | /brunoerg[P]bitcoin/src/univalue/lib/univalue.cpp |
uvTypeName(UniValue::VType) | const char *uvTypeName(UniValue::VType t)
{
switch (t) {
case UniValue::VNULL: return "null";
case UniValue::VBOOL: return "bool";
case UniValue::VOBJ: return "object";
case UniValue::VARR: return "array";
case UniValue::VSTR: return "string";
case UniValue::VNUM: return "number";
}
... | endbr64
pushq %rax
movq %fs:0x28, %rax
movq %rax, (%rsp)
cmpl $0x5, %edi
ja 0xd5293
movl %edi, %eax
leaq 0x775ce(%rip), %rcx # 0x14c858
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmp 0xd5295
xorl %eax, %eax
movq %fs:0x28, %rcx
cmpq (%rsp), %rcx
jne 0xd52a6
popq %rcx
retq
callq 0xd6f0
nop
| /brunoerg[P]bitcoin/src/univalue/lib/univalue.cpp |
UniValue::read(std::basic_string_view<char, std::char_traits<char>>) | bool UniValue::read(std::string_view str_in)
{
clear();
uint32_t expectMask = 0;
std::vector<UniValue*> stack;
std::string tokenVal;
unsigned int consumed;
enum jtokentype tok = JTOK_NONE;
enum jtokentype last_tok = JTOK_NONE;
const char* raw{str_in.data()};
const char* end{raw + s... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdx, %r14
movq %rsi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x120(%rsp)
movq %rdi, 0x8(%rsp)
callq 0xd44f0
leaq 0x30(%rsp), %rax
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
leaq 0x11... | /brunoerg[P]bitcoin/src/univalue/lib/univalue_read.cpp |
JSONUTF8StringFilter::push_back(unsigned char) | void push_back(unsigned char ch)
{
if (state == 0) {
if (ch < 0x80) // 7-bit ASCII, fast direct pass-through
str.push_back(ch);
else if (ch < 0xc0) // Mid-sequence character, invalid in this state
is_valid = false;
else if (ch < 0xe0) { // ... | endbr64
pushq %rax
movq %fs:0x28, %rax
movq %rax, (%rsp)
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0xd6663
movl %esi, %eax
andl $-0x40, %eax
cmpl $0x80, %eax
je 0xd6639
movb $0x0, 0x8(%rdi)
addl $-0x6, %ecx
movl %ecx, 0x10(%rdi)
andl $0x3f, %esi
shll %cl, %esi
orl 0xc(%rdi), %esi
movl %esi, 0xc(%rdi)
testl %ecx, %ecx
j... | /brunoerg[P]bitcoin/src/univalue/include/univalue_utffilter.h |
JSONUTF8StringFilter::append_codepoint(unsigned int) | void append_codepoint(unsigned int codepoint_)
{
if (codepoint_ <= 0x7f)
str.push_back((char)codepoint_);
else if (codepoint_ <= 0x7FF) {
str.push_back((char)(0xC0 | (codepoint_ >> 6)));
str.push_back((char)(0x80 | (codepoint_ & 0x3F)));
} else if (codepoi... | endbr64
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, (%rsp)
cmpl $0x7f, %esi
ja 0xd6830
movq (%r14), %rdi
movq %fs:0x28, %rax
cmpq (%rsp), %rax
je 0xd68b2
jmp 0xd68d8
cmpl $0x7ff, %ebx # imm = 0x7FF
ja 0xd6844
movq (%r14), %rdi
movl %ebx, %eax
shrl $0x6, %ea... | /brunoerg[P]bitcoin/src/univalue/include/univalue_utffilter.h |
BlockWitnessMerkleRoot(CBlock const&, bool*) | uint256 BlockWitnessMerkleRoot(const CBlock& block, bool* mutated)
{
std::vector<uint256> leaves;
leaves.resize(block.vtx.size());
leaves[0].SetNull(); // The witness hash of the coinbase is 0.
for (size_t s = 1; s < block.vtx.size(); s++) {
leaves[s] = block.vtx[s]->GetWitnessHash();
}
... | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x38(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x58(%rsi), %rsi
subq 0x50(%r15), %rsi
sarq $0x4, %rsi
callq 0xd7700
movq 0x20(%rsp... | /brunoerg[P]bitcoin/src/consensus/merkle.cpp |
void tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int, unsigned int, unsigned int, unsigned ... | void format(std::ostream& out, const char* fmt, const Args&... args)
{
vformat(out, fmt, makeFormatList(args...));
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq 0x118(%rsp), %rax
movq 0x110(%rsp), %r11
movq 0x108(%rsp), %rbx
movq 0x100(%rsp), %r14
movq %fs:0x28, %r10
movq %r10, 0xd8(%rsp)
leaq 0x18(%rsp), %r10
movq %r10, -0x10(%r10)
movl $0x8, -0x8(%r10)
movq %rdx, (%r10)
leaq -0xc0a28(%rip), %rdx # 0x17754
movq... | /brunoerg[P]bitcoin/src/tinyformat.h |
CTxIn::ToString[abi:cxx11]() const | std::string CTxIn::ToString() const
{
std::string str;
str += "CTxIn(";
str += prevout.ToString();
if (prevout.IsNull())
str += strprintf(", coinbase %s", HexStr(scriptSig));
else
str += strprintf(", scriptSig=%s", HexStr(scriptSig).substr(0, 24));
if (nSequence != SEQUENCE_FINAL... | endbr64
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x60(%rsp)
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x74655(%rip), %rsi # 0x14cafd
callq 0x17c60
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0xd8250
leaq 0x40(... | /brunoerg[P]bitcoin/src/primitives/transaction.cpp |
ecdsa_signature_parse_der_lax(secp256k1_ecdsa_signature*, unsigned char const*, unsigned long) | int ecdsa_signature_parse_der_lax(secp256k1_ecdsa_signature* sig, const unsigned char *input, size_t inputlen) {
size_t rpos, rlen, spos, slen;
size_t pos = 0;
size_t lenbyte;
unsigned char tmpsig[64] = {0};
int overflow = 0;
/* Hack to initialize sig with a correctly-parsed but invalid signatu... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, 0x30(%r15)
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
le... | /brunoerg[P]bitcoin/src/pubkey.cpp |
XOnlyPubKey::ComputeTapTweakHash(uint256 const*) const | uint256 XOnlyPubKey::ComputeTapTweakHash(const uint256* merkle_root) const
{
if (merkle_root == nullptr) {
// We have no scripts. The actual tweak does not matter, but follow BIP341 here to
// allow for reproducible tweaking.
return (HashWriter{HASHER_TAPTWEAK} << m_keydata).GetSHA256();
... | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %fs:0x28, %rcx
movq %rcx, 0x68(%rsp)
testq %rdx, %rdx
je 0xda7a8
movq %rdx, %r14
leaq 0x1e88f2(%rip), %rsi # 0x2c3070
pushq $0xd
popq %rcx
movq %rsp, %r15
movq %r15, %rdi
rep movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
movq ... | /brunoerg[P]bitcoin/src/pubkey.cpp |
CPubKey::RecoverCompact(uint256 const&, std::vector<unsigned char, std::allocator<unsigned char>> const&) | bool CPubKey::RecoverCompact(const uint256 &hash, const std::vector<unsigned char>& vchSig) {
if (vchSig.size() != COMPACT_SIGNATURE_SIZE)
return false;
int recid = (vchSig[0] - 27) & 3;
bool fComp = ((vchSig[0] - 27) & 4) != 0;
secp256k1_pubkey pubkey;
secp256k1_ecdsa_recoverable_signature ... | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %rax
movq %fs:0x28, %rcx
movq %rcx, 0xe0(%rsp)
movq (%rdx), %rdx
movq 0x8(%rax), %rax
subq %rdx, %rax
cmpq $0x41, %rax
jne 0xdabb0
movq %rsi, %r14
movq %rdi, %rbx
movb (%rdx), %r15b
leal 0x1(%r15), %eax
andb $0x3, %al
movzbl %al, %ecx
leaq ... | /brunoerg[P]bitcoin/src/pubkey.cpp |
CPubKey::IsFullyValid() const | bool CPubKey::IsFullyValid() const {
if (!IsValid())
return false;
secp256k1_pubkey pubkey;
return secp256k1_ec_pubkey_parse(secp256k1_context_static, &pubkey, vch, size());
} | endbr64
subq $0x48, %rsp
movq %rdi, %rdx
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
movzbl (%rdi), %ecx
movl %ecx, %eax
andb $-0x2, %al
cmpb $0x2, %al
jne 0xdac0c
leaq 0x1e78b3(%rip), %rax # 0x2c24b8
movq (%rax), %rdi
pushq $0x21
jmp 0xdac38
xorl %eax, %eax
cmpl $0x7, %ecx
ja 0xdac46
movl $0xd0, %esi
btl %ecx, %esi
j... | /brunoerg[P]bitcoin/src/pubkey.cpp |
CPubKey::Decompress() | bool CPubKey::Decompress() {
if (!IsValid())
return false;
secp256k1_pubkey pubkey;
if (!secp256k1_ec_pubkey_parse(secp256k1_context_static, &pubkey, vch, size())) {
return false;
}
unsigned char pub[SIZE];
size_t publen = SIZE;
secp256k1_ec_pubkey_serialize(secp256k1_context... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0xa0(%rsp)
movzbl (%rdi), %eax
movl %eax, %ecx
andb $-0x2, %cl
cmpb $0x2, %cl
jne 0xdaca4
leaq 0x1e781b(%rip), %rax # 0x2c24b8
movq (%rax), %rdi
pushq $0x21
jmp 0xdacd4
xorl %ebp, %ebp
cmpl $0x7, %eax
... | /brunoerg[P]bitcoin/src/pubkey.cpp |
EllSwiftPubKey::Decode() const | CPubKey EllSwiftPubKey::Decode() const
{
secp256k1_pubkey pubkey;
secp256k1_ellswift_decode(secp256k1_context_static, &pubkey, UCharCast(m_pubkey.data()));
size_t sz = CPubKey::COMPRESSED_SIZE;
std::array<uint8_t, CPubKey::COMPRESSED_SIZE> vch_bytes;
secp256k1_ec_pubkey_serialize(secp256k1_context... | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x70(%rsp)
leaq 0x1e7522(%rip), %r12 # 0x2c24b8
movq (%r12), %rdi
leaq 0x30(%rsp), %r14
movq %r14, %rsi
callq 0x11b380
movq %rsp, %r15
movq $0x21, (%r15)
movq (%r12), %rdi
leaq 0xf(%rsp... | /brunoerg[P]bitcoin/src/pubkey.cpp |
CExtPubKey::Encode(unsigned char*) const | void CExtPubKey::Encode(unsigned char code[BIP32_EXTKEY_SIZE]) const {
code[0] = nDepth;
memcpy(code+1, vchFingerprint, 4);
WriteBE32(code+5, nChild);
memcpy(code+9, chaincode.begin(), 32);
assert(pubkey.size() == CPubKey::COMPRESSED_SIZE);
memcpy(code+41, pubkey.begin(), CPubKey::COMPRESSED_SIZ... | endbr64
pushq %rax
movq %fs:0x28, %rax
movq %rax, (%rsp)
movb 0x4(%rdi), %al
movb %al, (%rsi)
movl 0x5(%rdi), %eax
movl %eax, 0x1(%rsi)
movl 0xc(%rdi), %eax
bswapl %eax
movl %eax, 0x5(%rsi)
movups 0x10(%rdi), %xmm0
movups 0x20(%rdi), %xmm1
movups %xmm1, 0x19(%rsi)
movups %xmm0, 0x9(%rsi)
movb 0x30(%rdi), %al
andb $-0x2... | /brunoerg[P]bitcoin/src/pubkey.cpp |
CExtPubKey::Derive(CExtPubKey&, unsigned int) const | bool CExtPubKey::Derive(CExtPubKey &out, unsigned int _nChild) const {
if (nDepth == std::numeric_limits<unsigned char>::max()) return false;
out.nDepth = nDepth + 1;
CKeyID id = pubkey.GetID();
memcpy(out.vchFingerprint, &id, 4);
out.nChild = _nChild;
return pubkey.Derive(out.pubkey, out.chainc... | endbr64
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
movb 0x4(%rdi), %al
cmpb $-0x1, %al
je 0xdb21b
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
incb %al
movb %al, 0x4(%rsi)
leaq 0x30(%rdi), %r12
leaq 0x4(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi... | /brunoerg[P]bitcoin/src/pubkey.cpp |
CheckSignatureEncoding(std::vector<unsigned char, std::allocator<unsigned char>> const&, unsigned int, ScriptError_t*) | bool CheckSignatureEncoding(const std::vector<unsigned char> &vchSig, unsigned int flags, ScriptError* serror) {
// Empty signature. Not strictly DER encoded, but allowed to provide a
// compact way to provide an invalid signature for use with CHECK(MULTI)SIG
if (vchSig.size() == 0) {
return true;
... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
movq (%rdi), %r12
movq 0x8(%rdi), %r13
movb $0x1, %bpl
subq %r12, %r13
je 0xdb59c
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
testb $0xe, %r15b
je 0xdb512
movq %r14, %rdi
callq 0xdb5... | /brunoerg[P]bitcoin/src/script/interpreter.cpp |
EvalChecksig(std::vector<unsigned char, std::allocator<unsigned char>> const&, std::vector<unsigned char, std::allocator<unsigned char>> const&, prevector<28u, unsigned char, unsigned int, int>::const_iterator, prevector<28u, unsigned char, unsigned int, int>::const_iterator, ScriptExecutionData&, unsigned int, BaseSig... | static bool EvalChecksig(const valtype& sig, const valtype& pubkey, CScript::const_iterator pbegincodehash, CScript::const_iterator pend, ScriptExecutionData& execdata, unsigned int flags, const BaseSignatureChecker& checker, SigVersion sigversion, ScriptError* serror, bool& success)
{
switch (sigversion) {
cas... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, %ebp
movq %rsi, %r12
movq %rdi, %r15
movq 0xa8(%rsp), %rbx
movq 0xa0(%rsp), %r11
movl 0x98(%rsp), %r13d
movq 0x90(%rsp), %rdi
movq %fs:0x28, %rsi
movq %rsi, 0x50(%rsp)
cmpl $0x2, %r13d
jae 0xddd50
movl %r13d, 0xc(%rsp)
leaq 0x... | /brunoerg[P]bitcoin/src/script/interpreter.cpp |
CheckPubKeyEncoding(std::vector<unsigned char, std::allocator<unsigned char>> const&, unsigned int, SigVersion const&, ScriptError_t*) | bool static CheckPubKeyEncoding(const valtype &vchPubKey, unsigned int flags, const SigVersion &sigversion, ScriptError* serror) {
if ((flags & SCRIPT_VERIFY_STRICTENC) != 0 && !IsCompressedOrUncompressedPubKey(vchPubKey)) {
return set_error(serror, SCRIPT_ERR_PUBKEYTYPE);
}
// Only compressed keys ... | pushq %rax
movq %fs:0x28, %rax
movq %rax, (%rsp)
testb $0x2, %sil
jne 0xddf5a
movb $0x1, %al
testw %si, %si
jns 0xddf76
cmpl $0x1, (%rdx)
jne 0xddf76
movq (%rdi), %rdx
movq 0x8(%rdi), %rsi
subq %rdx, %rsi
cmpq $0x21, %rsi
jne 0xddf51
movb (%rdx), %dl
andb $-0x2, %dl
cmpb $0x2, %dl
je 0xddf76
testq %rcx, %rcx
je 0xddf74... | /brunoerg[P]bitcoin/src/script/interpreter.cpp |
WitnessSigOps(int, std::vector<unsigned char, std::allocator<unsigned char>> const&, CScriptWitness const&) | size_t static WitnessSigOps(int witversion, const std::vector<unsigned char>& witprogram, const CScriptWitness& witness)
{
if (witversion == 0) {
if (witprogram.size() == WITNESS_V0_KEYHASH_SIZE)
return 1;
if (witprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE && witness.stack.size() > 0) ... | pushq %rbx
subq $0x30, %rsp
movq %fs:0x28, %rax
movq %rax, 0x28(%rsp)
testl %edi, %edi
je 0xdf766
xorl %ebx, %ebx
movq %fs:0x28, %rax
cmpq 0x28(%rsp), %rax
jne 0xdf7de
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
movq 0x8(%rsi), %rax
subq (%rsi), %rax
cmpq $0x14, %rax
je 0xdf7b0
cmpq $0x20, %rax
jne 0xdf747
movq 0x8... | /brunoerg[P]bitcoin/src/script/interpreter.cpp |
GetScriptOp(prevector<28u, unsigned char, unsigned int, int>::const_iterator&, prevector<28u, unsigned char, unsigned int, int>::const_iterator, opcodetype&, std::vector<unsigned char, std::allocator<unsigned char>>*) | bool GetScriptOp(CScriptBase::const_iterator& pc, CScriptBase::const_iterator end, opcodetype& opcodeRet, std::vector<unsigned char>* pvchRet)
{
opcodeRet = OP_INVALIDOPCODE;
if (pvchRet)
pvchRet->clear();
if (pc >= end)
return false;
// Read instruction
if (end - pc < 1)
re... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, (%rsp)
movl $0xff, (%rdx)
testq %rcx, %rcx
je 0xe3f8e
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0xe3f8e
movq %rax, 0x8(%rcx)
movq (%r14), %rax
cmpq %rsi, %rax
jae 0xe3feb
movl %esi, %edx
subl %e... | /brunoerg[P]bitcoin/src/script/script.cpp |
FSChaCha20::Crypt(Span<std::byte const>, Span<std::byte>) | void FSChaCha20::Crypt(Span<const std::byte> input, Span<std::byte> output) noexcept
{
assert(input.size() == output.size());
// Invoke internal stream cipher for actual encryption/decryption.
m_chacha20.Crypt(input, output);
// Rekey after m_rekey_interval encryptions/decryptions.
if (++m_chunk_c... | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %fs:0x28, %rax
movq %rax, 0x28(%rsp)
cmpq %r8, %rdx
jne 0xe4d5e
movq %rdi, %rbx
movq %rdx, %r8
callq 0xe4a60
movl 0x78(%rbx), %eax
incl %eax
movl %eax, 0x78(%rbx)
cmpl 0x74(%rbx), %eax
jne 0xe4d44
movq %rsp, %r14
pushq $0x20
popq %r15
movq %rbx, %rdi
movq %... | /brunoerg[P]bitcoin/src/crypto/chacha20.cpp |
void (anonymous namespace)::TransformD64Wrapper<&sha256_sse4::Transform(unsigned int*, unsigned char const*, unsigned long)>(unsigned char*, unsigned char const*) | void TransformD64Wrapper(unsigned char* out, const unsigned char* in)
{
uint32_t s[8];
static const unsigned char padding1[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
... | endbr64
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x68(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r13
movaps %xmm0, 0x10(%r13)
movaps %xmm0, 0x20(%r13)
movaps %xmm0, (%r13)
movaps %xmm0, -0x10(%r13)
movb $-0x80, 0x10(%r13)
movb $0x1, 0x2e(%r13... | /brunoerg[P]bitcoin/src/crypto/sha256.cpp |
(anonymous namespace)::sha256::Round(unsigned int, unsigned int, unsigned int, unsigned int&, unsigned int, unsigned int, unsigned int, unsigned int&, unsigned int) | void inline Round(uint32_t a, uint32_t b, uint32_t c, uint32_t& d, uint32_t e, uint32_t f, uint32_t g, uint32_t& h, uint32_t k)
{
uint32_t t1 = h + Sigma1(e) + Ch(e, f, g) + k;
uint32_t t2 = Sigma0(a) + Maj(a, b, c);
d += t1;
h = t1 + t2;
} | pushq %rbx
subq $0x10, %rsp
movl 0x20(%rsp), %r10d
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movl %r8d, %r11d
movl %r8d, %eax
xorl %r10d, %r9d
andl %r8d, %r9d
movl %r8d, %ebx
roll $0x1a, %ebx
roll $0x15, %r11d
movq 0x28(%rsp), %r8
xorl %ebx, %r11d
roll $0x7, %eax
xorl %r11d, %eax
xorl %r10d, %r9d
addl 0x30(%rsp), %eax
a... | /brunoerg[P]bitcoin/src/crypto/sha256.cpp |
(anonymous namespace)::sha512::Transform(unsigned long*, unsigned char const*) | void Transform(uint64_t* s, const unsigned char* chunk)
{
uint64_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4], f = s[5], g = s[6], h = s[7];
uint64_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
Round(a, b, c, d, e, f, g, h, 0x428a2f98d728ae22ull, w0 = ReadBE64(chunk + 0));
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %fs:0x28, %rax
movq %rax, 0x150(%rsp)
movq %rdi, 0xf8(%rsp)
movq (%rdi), %rbp
leaq 0x148(%rsp), %rcx
movq %rbp, (%rcx)
movq 0x8(%rdi), %r13
leaq 0x140(%rsp), %rdx
movq %r13, (%rdx)
movq 0x10(%rdi), %rax
lea... | /brunoerg[P]bitcoin/src/crypto/sha512.cpp |
secp256k1_ec_pubkey_create_helper | static int secp256k1_ec_pubkey_create_helper(const secp256k1_ecmult_gen_context *ecmult_gen_ctx, secp256k1_scalar *seckey_scalar, secp256k1_ge *p, const unsigned char *seckey) {
secp256k1_gej pj;
int ret;
ret = secp256k1_scalar_set_b32_seckey(seckey_scalar, seckey);
secp256k1_scalar_cmov(seckey_scalar,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x114f08
movl %eax, %ebp
movl %eax, %edx
xorl $0x1, %edx
leaq 0x3c674(%rip), %rsi # 0x151690
movq %r14, %rdi
callq 0x1150d9
movq %rsp, %r12
movq %r15, %rdi
mo... | /brunoerg[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_gej_add_ge | static void secp256k1_gej_add_ge(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_ge *b) {
/* Operations: 7 mul, 5 sqr, 21 add/cmov/half/mul_int/negate/normalizes_to_zero */
secp256k1_fe zz, u1, u2, s1, s2, t, tt, m, n, q, rr;
secp256k1_fe m_alt, rr_alt;
int degenerate;
SECP256K1_GEJ_VERIFY... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %rdx, %r14
movq %rdx, 0x50(%rsp)
movq %rsi, %rbx
movq %rdi, 0x48(%rsp)
leaq 0x50(%rsi), %rbp
leaq 0x250(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rsi
movq %rbp, 0x38(%rsp)
callq 0x11c3d4
movq 0x20(%rbx), %rax... | /brunoerg[P]bitcoin/src/secp256k1/src/group_impl.h |
secp256k1_ge_set_gej | static void secp256k1_ge_set_gej(secp256k1_ge *r, secp256k1_gej *a) {
secp256k1_fe z2, z3;
SECP256K1_GEJ_VERIFY(a);
r->infinity = a->infinity;
secp256k1_fe_inv(&a->z, &a->z);
secp256k1_fe_sqr(&z2, &a->z);
secp256k1_fe_mul(&z3, &a->z, &z2);
secp256k1_fe_mul(&a->x, &a->x, &z2);
secp256k1_... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x78(%rsi), %eax
movl %eax, 0x50(%rdi)
leaq 0x50(%rsi), %r15
movq %r15, %rdi
movq %r15, %rsi
callq 0x11edd8
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x11c3d4
movq %rsp, %r13
movq %r13, %rdi
mo... | /brunoerg[P]bitcoin/src/secp256k1/src/group_impl.h |
secp256k1_tagged_sha256 | int secp256k1_tagged_sha256(const secp256k1_context* ctx, unsigned char *hash32, const unsigned char *tag, size_t taglen, const unsigned char *msg, size_t msglen) {
secp256k1_sha256 sha;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(hash32 != NULL);
ARG_CHECK(tag != NULL);
ARG_CHECK(msg != NULL);
secp25... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rax
testq %rsi, %rsi
je 0x115fc1
testq %rdx, %rdx
je 0x115fd1
movq %r8, %r15
testq %r8, %r8
je 0x115fe1
movq %r9, %r14
movq %rsi, %rbx
movq %rsp, %r12
movq %r12, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x115ff9
movq %r12, %rdi
movq %r15, %rsi
m... | /brunoerg[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_ge_set_gej_var | static void secp256k1_ge_set_gej_var(secp256k1_ge *r, secp256k1_gej *a) {
secp256k1_fe z2, z3;
SECP256K1_GEJ_VERIFY(a);
if (secp256k1_gej_is_infinity(a)) {
secp256k1_ge_set_infinity(r);
return;
}
r->infinity = 0;
secp256k1_fe_inv_var(&a->z, &a->z);
secp256k1_fe_sqr(&z2, &a->... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x78(%rsi)
je 0x11a97a
movl $0x1, 0x50(%rbx)
movq %rbx, %rdi
callq 0x11c3a6
addq $0x28, %rbx
movq %rbx, %rdi
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x11c3a6
movq %rsi, %r14
andl $0x0, 0x50(... | /brunoerg[P]bitcoin/src/secp256k1/src/group_impl.h |
secp256k1_fe_impl_sqr | SECP256K1_INLINE static void secp256k1_fe_impl_sqr(secp256k1_fe *r, const secp256k1_fe *a) {
secp256k1_fe_sqr_inner(r->n, a->n);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rsi), %r11
movq 0x8(%rsi), %rcx
movq %rcx, -0x20(%rsp)
movq 0x18(%rsi), %r12
leaq (%r11,%r11), %rdx
movq %rdx, -0x18(%rsp)
movq %r12, %rax
movq %r12, -0x28(%rsp)
mulq %rdx
movq %rax, %r10
movq %rdx, %rbx
movq 0x10(%rsi), %r9
leaq (%rcx,%rcx), %r8
... | /brunoerg[P]bitcoin/src/secp256k1/src/field_5x52_impl.h |
secp256k1_fe_impl_cmp_var | static int secp256k1_fe_impl_cmp_var(const secp256k1_fe *a, const secp256k1_fe *b) {
int i;
for (i = 4; i >= 0; i--) {
if (a->n[i] > b->n[i]) {
return 1;
}
if (a->n[i] < b->n[i]) {
return -1;
}
}
return 0;
} | pushq $0x4
popq %rcx
leaq 0x342db(%rip), %rdx # 0x1516d0
pushq $0x1
popq %rax
pushq $-0x1
popq %rsi
testl %ecx, %ecx
js 0x11d419
movl %ecx, %r9d
movq (%rdi,%r9,8), %r8
movq (%rdx,%r9,8), %r9
cmpq %r9, %r8
ja 0x11d418
decl %ecx
cmpq %r9, %r8
jae 0x11d3fb
movl %esi, %eax
retq
xorl %eax, %eax
retq
| /brunoerg[P]bitcoin/src/secp256k1/src/field_5x52_impl.h |
secp256k1_modinv64_var | static void secp256k1_modinv64_var(secp256k1_modinv64_signed62 *x, const secp256k1_modinv64_modinfo *modinfo) {
/* Start with d=0, e=1, f=modulus, g=x, eta=-1. */
secp256k1_modinv64_signed62 d = {{0, 0, 0, 0, 0}};
secp256k1_modinv64_signed62 e = {{1, 0, 0, 0, 0}};
secp256k1_modinv64_signed62 f = modinfo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
xorps %xmm0, %xmm0
leaq 0x90(%rsp), %rax
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
andq $0x0, 0x20(%rax)
leaq 0xc0(%rsp), %rax
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq $0x1, (%rax)
movq 0x20(%rsi), %rax
leaq 0x60(%rsp), ... | /brunoerg[P]bitcoin/src/secp256k1/src/modinv64_impl.h |
secp256k1_rfc6979_hmac_sha256_generate | static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hmac_sha256 *rng, unsigned char *out, size_t outlen) {
/* RFC6979 3.2.h. */
static const unsigned char zero[1] = {0x00};
if (rng->retry) {
secp256k1_hmac_sha256 hmac;
secp256k1_hmac_sha256_initialize(&hmac, rng->k, 32);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x40(%rdi)
je 0x11dfbb
leaq 0x20(%rbx), %r12
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x11e02e
pushq $0x20
popq %r13
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x116... | /brunoerg[P]bitcoin/src/secp256k1/src/hash_impl.h |
secp256k1_scalar_add | static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
int overflow;
secp256k1_uint128 t;
SECP256K1_SCALAR_VERIFY(a);
SECP256K1_SCALAR_VERIFY(b);
secp256k1_u128_from_u64(&t, a->d[0]);
secp256k1_u128_accum_u64(&t, b->d[0]);
r->d[0] = secp... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdx), %rax
addq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
adcq $0x0, %rax
setb %cl
movzbl %cl, %ecx
addq 0x8(%rdx), %rax
movq %rax, 0x8(%rdi)
adcq 0x10(%rsi), %rcx
setb %al
movzbl %al, %r14d
addq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rd... | /brunoerg[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_gej_rescale | static void secp256k1_gej_rescale(secp256k1_gej *r, const secp256k1_fe *s) {
/* Operations: 4 mul, 1 sqr */
secp256k1_fe zz;
SECP256K1_GEJ_VERIFY(r);
SECP256K1_FE_VERIFY(s);
VERIFY_CHECK(!secp256k1_fe_normalizes_to_zero_var(s));
secp256k1_fe_sqr(&zz, s);
secp256k1_fe_mul(&r->x, &r->x, &zz);... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x11c3d4
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x11c68c
leaq 0x28(%r14), %r12
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x11c68c
movq %r12, %rdi
movq %r12, %rsi
... | /brunoerg[P]bitcoin/src/secp256k1/src/group_impl.h |
secp256k1_fe_impl_half | static SECP256K1_INLINE void secp256k1_fe_impl_half(secp256k1_fe *r) {
uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
uint64_t one = (uint64_t)1;
uint64_t mask = -(t0 & one) >> 12;
/* Bounds analysis (over the rationals).
*
* Let m = r->magnitude
* C =... | movdqu (%rdi), %xmm1
movdqu 0x10(%rdi), %xmm2
movq (%rdi), %rax
andl $0x1, %eax
negq %rax
movq %rax, %rcx
shrq $0xc, %rcx
movabsq $0xffffefffffc2f, %rdx # imm = 0xFFFFEFFFFFC2F
andq %rcx, %rdx
movq %rdx, %xmm0
movq %rcx, %xmm3
punpcklqdq %xmm3, %xmm0 # xmm0 = xmm0[0],xmm3[0]
paddq %xmm1, %xmm0
movq %rax, %xmm1
pshu... | /brunoerg[P]bitcoin/src/secp256k1/src/field_5x52_impl.h |
secp256k1_scalar_half | static void secp256k1_scalar_half(secp256k1_scalar *r, const secp256k1_scalar *a) {
/* Writing `/` for field division and `//` for integer division, we compute
*
* a/2 = (a - (a&1))/2 + (a&1)/2
* = (a >> 1) + (a&1 ? 1/2 : 0)
* = (a >> 1) + (a&1 ? n//2+1 : 0),
*
* where... | movq (%rsi), %rax
movq 0x8(%rsi), %rcx
shldq $0x3f, %rax, %rcx
movl %eax, %edx
andl $0x1, %edx
movq %rdx, %rax
negq %rax
movabsq $-0x2016d0b997e4df5f, %r8 # imm = 0xDFE92F46681B20A1
andq %rax, %r8
leaq (%rcx,%r8), %r9
movq %r9, (%rdi)
movq 0x8(%rsi), %r9
movq 0x10(%rsi), %r10
shldq $0x3f, %r9, %r10
movabsq $0x5d576e735... | /brunoerg[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_fe_to_signed62 | static void secp256k1_fe_to_signed62(secp256k1_modinv64_signed62 *r, const secp256k1_fe *a) {
const uint64_t M62 = UINT64_MAX >> 2;
const uint64_t a0 = a->n[0], a1 = a->n[1], a2 = a->n[2], a3 = a->n[3], a4 = a->n[4];
r->v[0] = (a0 | a1 << 52) & M62;
r->v[1] = (a1 >> 10 | a2 << 42) & M62;
r->v... | movq 0x8(%rsi), %r9
movq 0x10(%rsi), %r8
movq 0x18(%rsi), %rcx
movq 0x20(%rsi), %rax
movq %r9, %r10
shlq $0x34, %r10
orq (%rsi), %r10
movabsq $0x3fffffffffc00000, %rdx # imm = 0x3FFFFFFFFFC00000
leaq 0x3fffff(%rdx), %rsi
andq %r10, %rsi
movq %rsi, (%rdi)
shrq $0xa, %r9
movl %r8d, %esi
andl $0xfffff, %esi # imm... | /brunoerg[P]bitcoin/src/secp256k1/src/field_5x52_impl.h |
secp256k1_ecmult_wnaf | static int secp256k1_ecmult_wnaf(int *wnaf, int len, const secp256k1_scalar *a, int w) {
secp256k1_scalar s;
int last_set_bit = -1;
int bit = 0;
int sign = 1;
int carry = 0;
VERIFY_CHECK(wnaf != NULL);
VERIFY_CHECK(0 <= len && len <= 256);
VERIFY_CHECK(a != NULL);
VERIFY_CHECK(2 <= ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rsi, %r15
xorl %r14d, %r14d
movl $0x204, %edx # imm = 0x204
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
callq 0xd320
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp... | /brunoerg[P]bitcoin/src/secp256k1/src/ecmult_impl.h |
secp256k1_gej_double_var | static void secp256k1_gej_double_var(secp256k1_gej *r, const secp256k1_gej *a, secp256k1_fe *rzr) {
SECP256K1_GEJ_VERIFY(a);
/** For secp256k1, 2Q is infinity if and only if Q is infinity. This is because if 2Q = infinity,
* Q must equal -Q, or that Q.y == -(Q.y), or Q.y is 0. For a point on y^2 = x^3 + ... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x0, 0x78(%rsi)
je 0x11f721
movq %r14, %rdi
callq 0x1159da
testq %rbx, %rbx
je 0x11f71b
movq $0x1, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rsi, %r15
testq %rbx, %rbx
je 0x11... | /brunoerg[P]bitcoin/src/secp256k1/src/group_impl.h |
secp256k1_ecmult_table_get_ge_storage | SECP256K1_INLINE static void secp256k1_ecmult_table_get_ge_storage(secp256k1_ge *r, const secp256k1_ge_storage *pre, int n, int w) {
secp256k1_ecmult_table_verify(n,w);
if (n > 0) {
secp256k1_ge_from_storage(r, &pre[(n-1)/2]);
} else {
secp256k1_ge_from_storage(r, &pre[(-n-1)/2]);
se... | pushq %rbx
movq %rdi, %rbx
testl %edx, %edx
jle 0x11fb06
decl %edx
shrl %edx
shlq $0x6, %rdx
addq %rdx, %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x11cac4
notl %edx
shrl %edx
shlq $0x6, %rdx
addq %rdx, %rsi
movq %rbx, %rdi
callq 0x11cac4
addq $0x28, %rbx
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x11e... | /brunoerg[P]bitcoin/src/secp256k1/src/ecmult_impl.h |
QtMWidgets::AbstractScrollAreaPrivate::calcIndicator(Qt::Orientation, int, int, bool&, int&, QPoint&) | void
AbstractScrollAreaPrivate::calcIndicator( Qt::Orientation orient,
int minSize, int width, bool & needPaint,
int & indicatorSize, QPoint & indicatorPos )
{
int viewportSize = 0;
int scrolledSize = 0;
int x = 0;
int y = 0;
double posRatio = 0.0;
int totalIndicatorSize = 0;
double ratio = 0.0;
d... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::AbstractScrollAreaPrivate::animateHiddingBlurEffect() | void
AbstractScrollAreaPrivate::animateHiddingBlurEffect()
{
horBlurAnim->setStartValue( horBlur->pressure );
horBlurAnim->setEndValue( 0 );
vertBlurAnim->setStartValue( vertBlur->pressure );
vertBlurAnim->setEndValue( 0 );
if( horBlur->pressure != 0 )
horBlurAnim->start();
if( vertBlur->pressure !... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0xb0(%rbp)
movq 0x88(%rcx), %rax
movq 0x98(%rcx), %rcx
movq %rcx, -0xa8(%rbp)
movl 0x40(%rax), %esi
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x92eb0
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x92970
... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::AbstractScrollAreaPrivate::animateScrollIndicators() | void
AbstractScrollAreaPrivate::animateScrollIndicators()
{
animationTimer->stop();
horIndicator->alpha = horIndicator->color.alpha();
vertIndicator->alpha = vertIndicator->color.alpha();
animationTimer->start( animationTimeout );
if( horIndicator->needPaint )
{
horIndicator->animate = true;
horIn... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x68(%rax), %rdi
callq 0x92e30
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
addq $0x48, %rdi
callq 0x92460
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rcx
movl %edx, 0x5c(%rcx)
movq 0x60(%rax... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::AbstractScrollAreaPrivate::stopScrollIndicatorsAnimation() | void
AbstractScrollAreaPrivate::stopScrollIndicatorsAnimation()
{
animationTimer->stop();
horIndicator->needPaint = false;
vertIndicator->needPaint = false;
horIndicator->animate = false;
vertIndicator->animate = false;
horIndicator->update();
vertIndicator->update();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x68(%rax), %rdi
callq 0x92e30
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rcx
movb $0x0, 0x44(%rcx)
movq 0x60(%rax), %rcx
movb $0x0, 0x44(%rcx)
movq 0x58(%rax), %rcx
movb $0x0, 0x58(%rcx)
movq 0x60(%rax), %... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::AbstractScrollArea::setScrolledAreaSize(QSize const&) | void
AbstractScrollArea::setScrolledAreaSize( const QSize & s )
{
d->scrolledAreaSize = s;
d->normalizePosition();
d->calcIndicators();
update();
d->horIndicator->update();
d->vertIndicator->update();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x28, %rdi
callq 0xae5b0
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdi
movq (%rcx), %rcx
movq %rcx, 0x28(%rax)
addq $0x28, %rdi
callq ... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::AbstractScrollArea::mouseReleaseEvent(QMouseEvent*) | void
AbstractScrollArea::mouseReleaseEvent( QMouseEvent * e )
{
if( e->button() == Qt::LeftButton )
{
d->leftMouseButtonPressed = false;
if( ( d->horIndicator->needPaint || d->vertIndicator->needPaint ) &&
( d->horIndicator->policy == ScrollIndicatorAsNeeded ||
d->vertIndicator->policy == ScrollI... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa8f70
cmpl $0x1, %eax
jne 0xadd23
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0xae5b0
movq -0x18(%rbp), %rdi
movb $0x0, 0x48(%rax)
addq $0x28, %rdi
callq... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.