name string | code string | asm string | file string |
|---|---|---|---|
SVGChart::PlotDataContainer::CalculateXRange(float&, float&) const | bool PlotDataContainer::CalculateXRange (float &outXMin, float &outXMax) const {
bool theFirst = true;
outXMin = 0;
outXMax = 0;
for (PlotDataList::const_iterator theI=mXDataList.begin();theI!=mXDataList.end ();theI++) {
PlotDataBase *theXDataBase = *theI;
if (!theXDataBase) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %ecx, %ecx
movl %ecx, (%rsi)
movl %ecx, (%rdx)
movq (%rdi), %r12
cmpq 0x8(%rdi), %r12
je 0x4b77
movq %rdx, %r14
movq %rdi, %r15
movb $0x1, %r13b
movq (%r12), %rbp
testq %rbp, %rbp
je 0x4b89
movq %rbp, %rdi
callq 0x355a
tes... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::PlotDataContainer::CalculateYRangePlot(float, float, SVGChart::PlotDataBase const&, SVGChart::PlotDataBase const&, float&, float&) const | bool PlotDataContainer::CalculateYRangePlot (float inXMin, float inXMax, const PlotDataBase &inXData, const PlotDataBase &inYData, float &outYMin, float &outYMax) const {
outYMin = 0;
outYMax = 0;
// bool theEnteredXRange = false;
bool initialized = false;
if (inXData.Ge... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movss %xmm1, 0xc(%rsp)
movss %xmm0, 0x10(%rsp)
xorl %eax, %eax
movl %eax, (%rcx)
movl %eax, (%r8)
movq %rsi, %rdi
callq 0x355a
movq %rax, %r13
movq %r15, %rdi
callq 0x355a
mo... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::LogTrafo::Transform(float) const | float LogTrafo::Transform (float inValue) const{
if (inValue<kLogMinClipValue) {
inValue = kLogMinClipValue;
}
return SafeLog (inValue, mBase, mFactor)*mSlope+mOffset;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movss 0x823a(%rip), %xmm1 # 0xd004
maxss %xmm0, %xmm1
movss 0x10(%rdi), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x14(%rdi), %xmm0
movss %xmm0, 0x8(%rsp)
movaps %xmm1, %xmm0
callq 0x31a0
mulss 0x8(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x31a0
movss 0x8... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::LinTickIterator::Init() | bool LinTickIterator::Init () {
if (!mAxisSetup) {
return false;
}
float theMin = mAxisSetup->mMin;
float theMajorTickSpan = mAxisSetup->mTickInfo.mMajorTickSpan;
int theDiv = mAxisSetup->mTickInfo.mTickDivision;
mDelta = theMajorTickSpan/theDiv;
mCount = ceil (theMin/... | pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x4ec8
movq %rdi, %rbx
movss (%r14), %xmm0
cvtsi2ssl 0xcc(%r14), %xmm1
movss 0xd0(%r14), %xmm2
divss %xmm1, %xmm2
movss %xmm2, 0x4(%rsp)
movss %xmm2, 0x20(%rdi)
divss %xmm2, %xmm0
callq 0x3100
cvttss2si %xmm0, %rax
movq %rax, 0x18(%rbx)
xorps %xm... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::LinTickIterator::GetNextTick(float&, bool&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool LinTickIterator::GetNextTick (float &outTick, bool &outIsMajorTick, string &outFormatString) {
if (!mAxisSetup) {
return false;
}
if (mCurrentTick>mAxisSetup->mMax*kLittleIncrease) {
return false;
}
outTick = mCurrentTick;
outIsMajorTick = (mCount%mAxisSetup->mTi... | movq %rdx, %r8
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x4f01
pushq %rbx
movq %rdi, %rbx
movss 0x10(%rdi), %xmm0
movss 0x4(%rdx), %xmm1
mulss 0x812c(%rip), %xmm1 # 0xd024
ucomiss %xmm1, %xmm0
jbe 0x4f04
xorl %eax, %eax
jmp 0x4f40
xorl %eax, %eax
retq
movss %xmm0, (%rsi)
movq 0x18(%rbx), %rax
movslq 0xcc(%rdx), %rs... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::LinTickIterator::InitFromRanges(float, float, float, SVGChart::TickInfo&) const | bool LinTickIterator::InitFromRanges (float inParRange, float inOrthoScreenRange, float inDivGuess, TickInfo &ioTickInfo) const {
if (inDivGuess <= kFloatSmall) {
return false;
}
float thePreferredSpan = TickInfo::RoundSpan (inParRange/inDivGuess);
if (thePreferredSpan < 0) {
ret... | pushq %rbp
pushq %rbx
subq $0x28, %rsp
movss 0x80d8(%rip), %xmm3 # 0xd028
ucomiss %xmm2, %xmm3
jae 0x501f
movq %rsi, %rbx
movss %xmm1, 0xc(%rsp)
movaps %xmm0, 0x10(%rsp)
divss %xmm2, %xmm0
callq 0x39a6
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
ja 0x501f
movaps 0x10(%rsp), %xmm2
movaps %xmm2, %xmm1
divss %xmm0, %xmm1
... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::LogTickIterator::GetNextTick(float&, bool&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool LogTickIterator::GetNextTick (float &outTick, bool &outIsMajorTick, string &outFormatString) {
if (!mAxisSetup) {
return false;
}
if (mCurrentTick>mAxisSetup->mMax*kLittleIncrease) {
return false;
}
outTick = mCurrentTick;
outIsMajorTick = (mCount%mAxisSetup->mTi... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r14
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x529a
movq %rdi, %rbx
movss 0x10(%rdi), %xmm0
movss 0x4(%rcx), %xmm1
mulss 0x7d8f(%rip), %xmm1 # 0xd024
ucomiss %xmm1, %xmm0
jbe 0x52a1
xorl %eax, %eax
jmp 0x53c8
movq %rdx, %r15
movss %xmm0, (%rsi... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::LogTickIterator::AdjustRange(float&, float&) const | bool LogTickIterator::AdjustRange (float &ioMin, float &ioMax) const {
float theBase = mAxisSetup->mLogBase;
long theLogFac = 1;//mAxisSetup->mLogFactor;
if (mAxisSetup->mMaxDecades > 0) {
ioMin = ioMax/SafeExp (mAxisSetup->mMaxDecades, theBase, theLogFac);
}
if (ioMin == 0 && ioM... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rax
movss 0x20(%rax), %xmm0
movq 0x10(%rax), %rax
testq %rax, %rax
movss %xmm0, 0xc(%rsp)
jle 0x5432
cvtsi2ss %rax, %xmm2
movss (%r14), %xmm1
movaps %xmm1, 0x10(%rsp)
movss 0x7bee(%rip), %xmm1 ... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::LogTickIterator::RoundDown(float) const | float LogTickIterator::RoundDown (float inFloat) const {
float theBase = mAxisSetup->mLogBase;
long theLogFac = 1;//mAxisSetup->mLogFactor;
int thePow = (int)floor(SafeLog(inFloat,theBase, theLogFac));
return pow (theBase, thePow);
} | pushq %rax
movq 0x8(%rdi), %rax
movss 0x20(%rax), %xmm1
movss %xmm1, (%rsp)
movss 0x7ad1(%rip), %xmm1 # 0xd004
maxss %xmm0, %xmm1
movaps %xmm1, %xmm0
callq 0x31a0
movss %xmm0, 0x4(%rsp)
movss (%rsp), %xmm0
callq 0x31a0
movss 0x4(%rsp), %xmm1
divss %xmm0, %xmm1
movaps %xmm1, %xmm0
callq 0x3090
cvtss2sd (%rsp), %xmm2... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::LogTickIterator::RoundUp(float) const | float LogTickIterator::RoundUp (float inFloat) const {
float theBase = mAxisSetup->mLogBase;
float theLogFac = 1;//mAxisSetup->mLogFactor;
int thePow = (int)ceil(SafeLog(inFloat, theBase, theLogFac));
return pow (theBase, thePow);
} | pushq %rax
movq 0x8(%rdi), %rax
movss 0x20(%rax), %xmm1
movss %xmm1, (%rsp)
movss 0x7a71(%rip), %xmm1 # 0xd004
maxss %xmm0, %xmm1
movaps %xmm1, %xmm0
callq 0x31a0
movss %xmm0, 0x4(%rsp)
movss (%rsp), %xmm0
callq 0x31a0
movss 0x4(%rsp), %xmm1
divss %xmm0, %xmm1
movaps %xmm1, %xmm0
callq 0x3100
cvtss2sd (%rsp), %xmm2... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::PainterTester::Draw(SVGChart::Painter&) | bool PainterTester::Draw (Painter &inPainter) {
const char * theString = "The quick brown fox...";
int theWidth = inPainter.CalculateTextDrawSize (theString);
int theOffset = theWidth/10;
// a horizontal lines
int theHAscent_x = theOffset+2*inPainter.GetFontHeight ();
int theHAscen... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rax
leaq 0x7cc1(%rip), %r14 # 0xd32d
movq %rsi, %rdi
movq %r14, %rsi
callq *0x40(%rax)
movslq %eax, %r15
imulq $0x66666667, %r15, %r12 # imm = 0x66666667
movq %r12, %rax
shrq $0x3f, %rax
sarq $0x22, %r12
addl... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::PPlot::~PPlot() | PPlot::~PPlot () {
if (mOwnsPPlotDrawer) {
delete mPPlotDrawer;
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xcd08(%rip), %rax # 0x12790
movq %rax, (%rdi)
cmpb $0x1, 0x670(%rdi)
jne 0x5aa6
movq 0x668(%rbx), %rdi
testq %rdi, %rdi
je 0x5aa6
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xd01b(%rip), %rax # 0x12ac8
movq %rax, 0x608(%rbx)
leaq 0x650(%rbx), %rdi
callq 0xa2... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::PPlot::Draw(SVGChart::Painter&) | bool PPlot::Draw (Painter &inPainter) {
PRect theRect;
theRect.mX = mMargins.mLeft;
theRect.mY = mMargins.mTop;
theRect.mW = inPainter.GetWidth () - mMargins.mLeft - mMargins.mRight;
theRect.mH = inPainter.GetHeight () - mMargins.mTop - mMargins.mBottom;
if (mPPlotDrawer) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x388(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x398(%rdi), %rax
movq %rax, 0x10(%rsp)
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x20(%rax)
movq 0x388(%r14), %rcx
addq 0x390(%r14), %rcx
subq %rcx, %rax
mo... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::PPlot::DrawPlotBackground(SVGChart::PRect const&, SVGChart::Painter&) const | bool PPlot::DrawPlotBackground (const PRect &inRect, Painter &inPainter) const {
inPainter.SetStyle (mPlotBackground.mStyle);
if (!mPlotBackground.mTransparent) {
PColor theC = mPlotBackground.mPlotRegionBackColor;
inPainter.SetFillColor (theC.mR, theC.mG, theC.mB);
inPainter.FillRe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x3d0(%rdi), %rsi
movq (%rdx), %rax
movq %rdx, %rdi
callq *0x60(%rax)
cmpb $0x0, 0x3a8(%r14)
jne 0x60d8
movzbl 0x3a9(%r14), %esi
movzbl 0x3aa(%r14), %edx
movzbl 0x3ab(%r14), %ecx
movq ... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::PPlot::DrawGridYAxis(SVGChart::PRect const&, SVGChart::Painter&) const | bool PPlot::DrawGridYAxis (const PRect &inRect, Painter &inPainter) const {
inPainter.SetStyle (mYAxisSetup.mStyle);
// ticks
inPainter.SetStyle (mYAxisSetup.mTickInfo.mStyle);
if (!mYTickIterator->Init ()) {
return false;
}
float theY;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x248(%rdi), %rsi
movq (%rdx), %rax
movq %rdx, %rdi
callq *0x60(%rax)
leaq 0x300(%r12), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x60(%rax)
movq 0x4c0(%r12), %rdi
movq (%rdi), %ra... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::PPlot::DrawXAxis(SVGChart::PRect const&, SVGChart::Painter&) const | bool PPlot::DrawXAxis (const PRect &inRect, Painter &inPainter) const {
inPainter.SetStyle (mXAxisSetup.mStyle);
float theX1 = inRect.mX;
float theY1;
float theTargetY = 0;
if (!mXAxisSetup.mCrossOrigin) {
if (mYAxisSetup.mAscending) {
theTargetY = mYAxisSetup.mMax;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
leaq 0xc8(%rdi), %r15
movq (%rdx), %rax
movq %rdx, %rdi
movq %r15, %rsi
callq *0x60(%rax)
cvtsi2ssq (%r13), %xmm0
movss %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cmpb $0x0, 0x8c(%r14)
jne 0x6552... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::PPlot::DrawYAxis(SVGChart::PRect const&, SVGChart::Painter&) const | bool PPlot::DrawYAxis (const PRect &inRect, Painter &inPainter) const {
inPainter.SetStyle (mYAxisSetup.mStyle);
float theX1;
PRect theRect = inRect;
float theTargetX = 0;
if (!mYAxisSetup.mCrossOrigin) {
if (mXAxisSetup.mAscending) {
theTargetX = mXAxisSetup.mMin;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x248(%rdi), %rsi
movq (%rdx), %rax
movq %rdx, %rdi
movq %rsi, 0x68(%rsp)
callq *0x60(%rax)
movq 0x18(%r14), %rbp
xorps %xmm0, %xmm0
cmpb $0x0, 0x20c(%r12)
jne 0x6920
cmpb $0x1, 0x8a(%... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::PPlot::DrawYTick(float, int, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, SVGChart::Painter&, SVGChart::PRect&) const | bool PPlot::DrawYTick (float inY, int inScreenX, bool inMajor, const string &inFormatString, Painter &inPainter, PRect &outRect) const {
char theBuf[128];
int theTickSize;
float theScreenY = mYTrafo->Transform(inY);
outRect.mX = inScreenX;
outRect.mY = theScreenY;
outRect.mW = 0;// n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %r13d
movl %esi, %ebp
movq %rdi, %r12
movq 0x4d0(%rdi), %rdi
movq (%rdi), %rax
movss %xmm0, 0xc(%rsp)
callq *0x10(%rax)
movaps %xmm0, %xmm1
movslq %ebp, %rax
movq %rax, (%r14)
cvtt... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::GetMaxFromRange(SVGChart::PlotDataBase const&, long, long) | float GetMaxFromRange (const PlotDataBase &inData, long inStartIndex, long inEndIndex) {
float max = 0;
float fabsMax = 0;
for (long theI = inStartIndex; theI <= inEndIndex; theI++) {
if (theI == inStartIndex) {
max = inData.GetValue (theI);
fabsMax = ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
cmpq %rdx, %rsi
jg 0x6eed
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
subq %rsi, %rbx
incq %rbx
movaps %xmm0, (%rsp)
xorl %r12d, %r12d
xorps %xmm2, %xmm2
testq %r12, %r12
je 0x6ecc
leaq (%r14,%r12), %rsi
movq %r15, ... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::LineDataDrawer::Clone() const | DataDrawerBase* LineDataDrawer::Clone () const {
return new LineDataDrawer (*this);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movl $0xa8, %edi
callq 0x31b0
movq %rax, %rbx
movups 0x8(%r15), %xmm0
movups 0x14(%r15), %xmm1
movups %xmm0, 0x8(%rax)
movups %xmm1, 0x14(%rax)
leaq 0xb590(%rip), %rax # 0x12888
movq %rax, (%rbx)
movzwl 0x24(%r15), %eax
mo... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::BarDataDrawer::DrawData(SVGChart::PlotDataBase const&, SVGChart::PlotDataBase const&, SVGChart::PlotDataSelection const&, SVGChart::AxisSetup const&, SVGChart::PRect const&, SVGChart::Painter&) const | bool BarDataDrawer::DrawData (const PlotDataBase &inXData, const PlotDataBase &inYData, const PlotDataSelection &inPlotDataSelection, const AxisSetup &inXAxisSetup, const PRect &inRect, Painter &inPainter) const {
if (!mXTrafo || !mYTrafo) {
return false;
}
if (inXData.GetSize ()>inYData.GetSi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0x8(%rdi)
je 0x74f4
movq %rdi, %r15
cmpq $0x0, 0x10(%rdi)
je 0x74f4
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %r8, 0x8(%rsp)
movq %r9, 0x10(%rsp)
movq 0x60(%rsp), %r12
movq %rsi, %rdi
callq 0x355a
movq %rax, %rbp
mo... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::BarDataDrawer::DrawOnlyLastPoint(SVGChart::PlotDataBase const&, SVGChart::PlotDataBase const&, SVGChart::PlotDataSelection const&, SVGChart::AxisSetup const&, SVGChart::PRect const&, SVGChart::Painter&) const | bool BarDataDrawer::DrawOnlyLastPoint (const PlotDataBase &inXData, const PlotDataBase &inYData, [[maybe_unused]] const PlotDataSelection &inPlotDataSelection, [[maybe_unused]] const AxisSetup &inXAxisSetup, const PRect &inRect, Painter &inPainter) const {
PRect theRect = inRect;
theRect.mW = inRect.mW / m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, %r15
movq (%r9), %rbx
movq 0x10(%r9), %r13
movslq 0x1c(%rdi), %rbp
movl 0x20(%rdi), %r14d
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
xorps %xmm0, %xmm0
callq *0x10(%rax)
movss %xmm0, 0xc(%rsp... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::MakeExamplePlot6(SVGChart::PPlot&) | void MakeExamplePlot6 (PPlot &ioPPlot) {
int theI;
ioPPlot.mPlotBackground.mTitle = "line styles";
PlotData *theX1 = new PlotData ();
PlotData *theY1 = new PlotData ();
float theFac = 100.0f/(100*100*100);
for (theI=0;theI<=10;theI++) {
theX1->push_back (0.0001+theI*0.001);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rax
addq $0x3b0, %rdi # imm = 0x3B0
movq %rax, 0x18(%rsp)
movq 0x3b8(%rax), %rdx
leaq 0x45b8(%rip), %rcx # 0xd46c
xorl %ebx, %ebx
movl $0xb, %r8d
xorl %esi, %esi
callq 0x3250
movl $0x20, %edi
callq 0x31b0
movq... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::MakeExamplePlot7(SVGChart::PPlot&) | void MakeExamplePlot7 (PPlot &ioPPlot) {
PlotData *theX1 = new PlotData ();
PlotData *theY1 = new PlotData ();
float theFac = 100.0f/(100*100*100);
for (int theI=0;theI<=100;theI++) {
theX1->push_back (0.0001+theI*0.001);
theY1->push_back (0.01+theFac*theI*theI*theI);
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x20, %edi
callq 0x31b0
movq %rax, %r14
leaq 0x8(%rax), %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
leaq 0x996b(%rip), %rbx # 0x12bf0
movq %rbx, (%rax)
movl $0x20, %edi
callq 0x3... | /davecom[P]SVGChart/PPlot.cpp |
SVGChart::LinTickIterator::~LinTickIterator() | LinTickIterator ():mCurrentTick (0), mDelta (0){} | movq %rdi, %rax
leaq 0x8c5a(%rip), %rcx # 0x12a18
movq %rcx, (%rdi)
movq 0x28(%rdi), %rdi
addq $0x38, %rax
cmpq %rax, %rdi
je 0x9dd9
movq (%rax), %rsi
incq %rsi
jmp 0x31c0
retq
| /davecom[P]SVGChart/PPlot.h |
SVGChart::PStyle::~PStyle() | PStyle (): mFontSize(10), mPenWidth (1){} | pushq %rbx
movq %rdi, %rbx
addq $0x50, %rdi
callq 0xa12c
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0xa111
movq (%rax), %rsi
incq %rsi
callq 0x31c0
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0xa12a
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x31c0
popq %rbx
retq
| /davecom[P]SVGChart/PPlot.h |
SVGChart::SVGPainter::DrawLine(float, float, float, float) | void SVGPainter::DrawLine (float inX1, float inY1, float inX2, float inY2) {
svgContent << "<line x1=\"" << inX1 << "\" y1=\"" << inY1;
svgContent << "\" x2=\"" << inX2 << "\" y2=\"" << inY2;
svgContent << "\" stroke=\"" << "rgb(" << lineRed << ",";
svgContent << lineGreen << "," << line... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movss %xmm3, 0xc(%rsp)
movss %xmm2, 0x8(%rsp)
movss %xmm1, 0x4(%rsp)
movss %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
leaq 0x1b5a(%rip), %rsi # 0xd6d8
movl $0xa, %edx
movq %r14, %rdi
callq 0x3200
xorps %xmm0, %xmm0
cvtss2sd (%rsp), %xmm0
movq %r14, %rdi
ca... | /davecom[P]SVGChart/SVGPainter.cpp |
SVGChart::SVGPainter::DrawRotatedText(int, int, float, char const*) | void SVGPainter::DrawRotatedText (int inX, int inY, float inDegrees, const char *inString) {
svgContent << "<text x=\"" << inX << "\" y=\"" << inY << "\" transform=";
svgContent << "\"rotate(" << inDegrees;
svgContent << "," << inX << "," << inY << ")\">";
svgContent << inString << "</te... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movss %xmm0, 0xc(%rsp)
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
addq $0x38, %rbx
leaq 0x1576(%rip), %rsi # 0xd748
movl $0x9, %edx
movq %rbx, %rdi
callq 0x3200
movq %rbx, %rdi
movl %r15d, %esi
callq 0x32d0
movq %rax, %r1... | /davecom[P]SVGChart/SVGPainter.cpp |
bsplib::Spmd::close() | void Spmd :: close() {
// wait for inactive & active processes to synchronize
MPI_Barrier( MPI_COMM_WORLD );
m_closed = true;
MPI_Comm_free( &m_comm );
m_comm = MPI_COMM_NULL;
MPI_Finalize();
} | pushq %rbx
movq %rdi, %rbx
movq 0xeabd(%rip), %rdi # 0x16f90
callq 0x5200
movb $0x1, 0x8(%rbx)
movq %rbx, %rdi
callq 0x5450
movq 0xeacd(%rip), %rax # 0x16fb8
movq %rax, (%rbx)
popq %rbx
jmp 0x5220
| /wijnand-suijlen[P]bsponmpi/src/spmd.cc |
util::is_valid_player_name(char const*, unsigned long, bool) | bool is_valid_player_name(const char* str, size_t len, bool allow_empty/* = true*/)
{
constexpr size_t max_name_len = 64;
if (len > max_name_len)
return false;
if (!allow_empty && (str == nullptr || *str == '0'))
return false;
for (size_t i = 0; i < len; ++i)
if (str[i] == ' ' || !isprint(str[i]))
return... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x40, %rsi
jbe 0x50bb
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rbx
movq %rdi, %r14
testb %dl, %dl
jne 0x50d0
testq %r14, %r14
je 0x50ac
cmpb $0x30, (%r14)
je 0x50ac
xorl %r15d, %r15d
cmpq %r15, %... | /Xanewok[P]netacka-clone/util.cc |
event::as_stream() const | std::vector<std::uint8_t> event::as_stream() const
{
std::vector<std::uint8_t> stream;
append_bytes(stream, as_bytes(htonl(calculate_len())));
append_bytes(stream, as_bytes(event_type));
append_bytes(stream, as_bytes(htonl(event_no)));
const auto& aux_data = aux_as_stream();
stream.insert(stream.end(), aux_data... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
bswapl %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x5468
leaq 0xc(%r14), %rsi
movq %rbx, %rdi
callq 0x5478
movl ... | /Xanewok[P]netacka-clone/protocol.cc |
HModel::computePrimal() | void HModel::computePrimal() {
buffer.clear();
for (int i = 0; i < numTot; i++)
if (nonbasicFlag[i] && workValue[i] != 0)
matrix.collect_aj(buffer, i, workValue[i]);
factor.ftran(buffer, 1);
#ifdef JAJH_dev
int n_rp = 0;
double rp_tl = 0.0;
int mx_n_rp = 10;
double norm_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xeb8(%rdi), %r14
movq %r14, %rdi
callq 0x19d40
leaq 0x8d0(%rbx), %r15
xorl %r12d, %r12d
movslq 0x614(%rbx), %rax
cmpq %rax, %r12
jge 0x32234
movq 0x768(%rbx), %rax
cmpl $0x0, (%rax,%r12,4)
je 0x3222f
movq 0x828(%rbx), %rax
movsd (%rax,%r12,8),... | /mattmilten[P]h2gmp/src/HModel.cpp |
HinOut::setData(HModel&) | void HinOut::setData(HModel & ptr_model) {
ptr_model.numCol = numCol;
ptr_model.numRow = numRow;
ptr_model.numTot = numCol + numRow;
ptr_model.Astart = Astart;
ptr_model.Aindex = Aindex;
ptr_model.Avalue = Avalue;
ptr_model.colCost = colCost;
ptr_model.colLower = colLower;
ptr_model.col... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
movl %eax, 0x60c(%rsi)
movl 0x4(%rdi), %ecx
movl %ecx, 0x610(%rsi)
addl %eax, %ecx
movl %ecx, 0x614(%rsi)
leaq 0x18(%rdi), %rsi
leaq 0x648(%r14), %rdi
callq 0x19da0
leaq 0x30(%rbx), %rsi
leaq 0x660(%r14), %rdi
callq 0x19da0
leaq 0x48(%rb... | /mattmilten[P]h2gmp/src/HinOut.cpp |
HinOut::writeDataColumnWise() | void HinOut::writeDataColumnWise() {
ofstream f;
int i;
f.open (fileOut, ios::out );
//counts
f << onumCol << endl;
f << onumRow << endl;
f << oAcountX << endl;
//matrix
for (i=0; i<onumCol+1; i++)
f << oAstart[i]<<" ";
f<<endl;
for (i=0; i<oAcountX; i++)
f << oAindex[i]<<" ";
f<<endl;
f<<setpre... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1aaa0
leaq 0x7d0(%rbx), %rsi
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x18ad0
movl 0x7f0(%rbx), %esi
leaq 0x8(%rsp), %rdi
callq 0x1ab40
movq %rax, %rdi
callq 0x18b10
mov... | /mattmilten[P]h2gmp/src/HinOut.cpp |
HinOut::clearData() | void HinOut::clearData() {
numRow = 0;
numCol = 0;
numTot = 0;
Astart.clear();
Aindex.clear();
Avalue.clear();
colCost.clear();
colLower.clear();
colUpper.clear();
rowLower.clear();
rowUpper.clear();
AcountX = 0;
} | andq $0x0, (%rdi)
andl $0x0, 0x10(%rdi)
movq 0x18(%rdi), %rax
cmpq %rax, 0x20(%rdi)
je 0x4cdb2
movq %rax, 0x20(%rdi)
movq 0x30(%rdi), %rax
cmpq %rax, 0x38(%rdi)
je 0x4cdc0
movq %rax, 0x38(%rdi)
movq 0x48(%rdi), %rax
cmpq %rax, 0x50(%rdi)
je 0x4cdce
movq %rax, 0x50(%rdi)
movq 0x60(%rdi), %rax
cmpq %rax, 0x68(%rdi)
je 0x... | /mattmilten[P]h2gmp/src/HinOut.cpp |
HinOut::readDataPostsolve(HModel&) | void HinOut::readDataPostsolve(HModel & ptr_model) {
numCol = ptr_model.numCol;
numRow = ptr_model.numRow;
numTot = ptr_model.numCol + ptr_model.numRow;
Astart = ptr_model.Astart;
Aindex = ptr_model.Aindex;
Avalue = ptr_model.Avalue;
colCost = ptr_model.colCost;
colLower = ptr_model.colLowe... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x60c(%rsi), %eax
movl %eax, (%rdi)
movl 0x610(%rsi), %ecx
movl %ecx, 0x4(%rdi)
addl %eax, %ecx
movl %ecx, 0x10(%rdi)
addq $0x648, %rsi # imm = 0x648
addq $0x18, %rdi
callq 0x19da0
leaq 0x660(%r14), %rsi
leaq 0x30(%rbx), %rdi
callq 0x19da0... | /mattmilten[P]h2gmp/src/HinOut.cpp |
rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>::Malloc(unsigned long) | void* Malloc(size_t size) {
if (!size)
return NULL;
size = RAPIDJSON_ALIGN(size);
if (chunkHead_ == 0 || chunkHead_->size + size > chunkHead_->capacity)
if (!AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size))
return NULL;
void *buffer = r... | testq %rsi, %rsi
je 0x32eb
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x7, %rbx
andq $-0x8, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x32bf
movq 0x8(%rax), %rcx
addq %rbx, %rcx
cmpq (%rax), %rcx
jbe 0x32d6
movq 0x8(%r14), %rsi
cmpq %rbx, %rsi
cmovbeq %rbx, %rsi
movq %r14, %rdi
callq 0x32f8... | /satoshigeyuki[P]Centaurus/rapidjson/include/rapidjson/allocators.h |
set_xterm256_foreground[abi:cxx11](int, int, int) | static std::string set_xterm256_foreground(int r, int g, int b) {
int x = rgb2xterm256(r, g, b);
std::ostringstream oss;
oss << "\033[38;5;" << x << "m";
return oss.str();
} | subq $0x1c8, %rsp # imm = 0x1C8
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x1c0(%rsp)
movl %esi, 0x1bc(%rsp)
movl %edx, 0x1b8(%rsp)
movl %ecx, 0x1b4(%rsp)
movl 0x1bc(%rsp), %edi
movl 0x1b8(%rsp), %esi
movl 0x1b4(%rsp), %edx
callq 0x150f0
movl %eax, 0x1b0(%rsp)
leaq 0x38(%rsp), %rd... | /ggerganov[P]ggml/examples/common.h |
gpt2_model_load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, gpt2_model&, gpt_vocab&) | bool gpt2_model_load(const std::string & fname, gpt2_model & model, gpt_vocab & vocab) {
printf("%s: loading model from '%s'\n", __func__, fname.c_str());
auto fin = std::ifstream(fname, std::ios::binary);
if (!fin) {
fprintf(stderr, "%s: failed to open '%s'\n", __func__, fname.c_str());
re... | subq $0xda8, %rsp # imm = 0xDA8
movq %rdi, 0xd98(%rsp)
movq %rsi, 0xd90(%rsp)
movq %rdx, 0xd88(%rsp)
movq 0xd98(%rsp), %rdi
callq 0xf210
movq %rax, %rdx
leaq 0x47e42(%rip), %rdi # 0x58088
leaq 0x47e58(%rip), %rsi # 0x580a5
xorl %eax, %eax
callq 0xf080
movq 0xd98(%rsp), %rsi
leaq 0xb80(%rsp), %rdi
mov... | /ggerganov[P]ggml/examples/gpt-2/main-ctx.cpp |
gpt2_eval(gpt2_model const&, int, int, std::vector<int, std::allocator<int>> const&, std::vector<float, std::allocator<float>>&, unsigned long&) | bool gpt2_eval(
const gpt2_model & model,
const int n_threads,
const int n_past,
const std::vector<gpt_vocab::id> & embd_inp,
std::vector<float> & embd_w,
size_t & mem_per_token) {
const int N = embd_inp.size();
const auto ... | subq $0x348, %rsp # imm = 0x348
movq %rdi, 0x338(%rsp)
movl %esi, 0x334(%rsp)
movl %edx, 0x330(%rsp)
movq %rcx, 0x328(%rsp)
movq %r8, 0x320(%rsp)
movq %r9, 0x318(%rsp)
movq 0x328(%rsp), %rdi
callq 0x15e40
movl %eax, 0x314(%rsp)
movq 0x338(%rsp), %rax
movq %rax, 0x308(%rsp)
movq 0x308(%rsp), %rax
movl 0x8(%ra... | /ggerganov[P]ggml/examples/gpt-2/main-ctx.cpp |
secp256k1_scalar_set_b32 | static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned char *b32, int *overflow) {
int over;
r->d[0] = secp256k1_read_be64(&b32[24]);
r->d[1] = secp256k1_read_be64(&b32[16]);
r->d[2] = secp256k1_read_be64(&b32[8]);
r->d[3] = secp256k1_read_be64(&b32[0]);
over = secp256k1_scalar... | pushq %rbp
pushq %rbx
movq 0x18(%rsi), %rax
bswapq %rax
movq %rax, (%rdi)
movq 0x10(%rsi), %rcx
bswapq %rcx
movq %rcx, 0x8(%rdi)
movq 0x8(%rsi), %r8
bswapq %r8
movq %r8, 0x10(%rdi)
movq (%rsi), %rsi
bswapq %rsi
cmpq $-0x1, %rsi
sete %r9b
cmpq $-0x2, %r8
setae %r10b
cmpq $-0x1, %r8
sete %r11b
andb %r9b, %r11b
movabsq $-... | /fanquake[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_ecdsa_signature_normalize | int secp256k1_ecdsa_signature_normalize(const secp256k1_context* ctx, secp256k1_ecdsa_signature *sigout, const secp256k1_ecdsa_signature *sigin) {
secp256k1_scalar r, s;
int ret = 0;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(sigin != NULL);
secp256k1_ecdsa_signature_load(ctx, &r, &s, sigin);
ret = ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
testq %rdx, %rdx
je 0x152aa
movq %rdx, %r14
movq %rsi, %rbx
movups 0x20(%rdx), %xmm0
movups 0x30(%rdx), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq 0x18(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
cmpq %rcx, %rax... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_scalar_negate | static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1_scalar *a) {
uint64_t nonzero = 0xFFFFFFFFFFFFFFFFULL * (secp256k1_scalar_is_zero(a) == 0);
secp256k1_uint128 t;
SECP256K1_SCALAR_VERIFY(a);
secp256k1_u128_from_u64(&t, ~a->d[0]);
secp256k1_u128_accum_u64(&t, SECP256K1_N_0 + 1... | pushq %rbx
movq 0x8(%rsi), %rax
orq 0x10(%rsi), %rax
orq 0x18(%rsi), %rax
movq (%rsi), %rcx
movq %rcx, %r8
notq %r8
movabsq $-0x402da1732fc9bebe, %r9 # imm = 0xBFD25E8CD0364142
leaq (%r8,%r9), %r10
xorl %edx, %edx
movq %rax, %r11
orq %rcx, %r11
cmoveq %rdx, %r10
addq %r9, %r8
movq %r10, (%rdi)
movq 0x8(%rsi), %r8
notq ... | /fanquake[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_keypair_xonly_tweak_add | int secp256k1_keypair_xonly_tweak_add(const secp256k1_context* ctx, secp256k1_keypair *keypair, const unsigned char *tweak32) {
secp256k1_ge pk;
secp256k1_scalar sk;
int y_parity;
int ret;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(keypair != NULL);
ARG_CHECK(tweak32 != NULL);
ret = secp256k... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r14
testq %rsi, %rsi
je 0x1ed82
movq %rdx, %r15
testq %rdx, %rdx
je 0x1ed8c
movq %rsi, %rbx
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %r12
movq %r14, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1eb1e
movl %eax, 0xc(%rsp)
pxor %xmm0, %xmm0
movdqu %xm... | /fanquake[P]bitcoin/src/secp256k1/src/modules/extrakeys/main_impl.h |
ellswift_xdh_hash_function_prefix | static int ellswift_xdh_hash_function_prefix(unsigned char *output, const unsigned char *x32, const unsigned char *ell_a64, const unsigned char *ell_b64, void *data) {
secp256k1_sha256 sha;
secp256k1_sha256_initialize(&sha);
secp256k1_sha256_write(&sha, data, 64);
secp256k1_sha256_write(&sha, ell_a64, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movaps 0x5045b(%rip), %xmm0 # 0x71010
movq %rsp, %rbx
movaps %xmm0, (%rbx)
movaps 0x5045e(%rip), %xmm0 # 0x71020
movaps %xmm0, 0x10(%rbx)
xorl %ebp, %ebp
movq %rbp, 0x... | /fanquake[P]bitcoin/src/secp256k1/src/modules/ellswift/main_impl.h |
ellswift_xdh_hash_function_bip324 | static int ellswift_xdh_hash_function_bip324(unsigned char* output, const unsigned char *x32, const unsigned char *ell_a64, const unsigned char *ell_b64, void *data) {
secp256k1_sha256 sha;
(void)data;
secp256k1_ellswift_sha256_init_bip324(&sha);
secp256k1_sha256_write(&sha, ell_a64, 64);
secp256k... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r15
movq %rdx, %rax
movq %rsi, %r12
movq %rdi, %r14
movaps 0x504b9(%rip), %xmm0 # 0x71120
movq %rsp, %rbx
movaps %xmm0, (%rbx)
movaps 0x504bc(%rip), %xmm0 # 0x71130
movaps %xmm0, 0x10(%rbx)
movq $0x40, 0x60(%rbx)
movl $0x40, %edx
movq %rbx, ... | /fanquake[P]bitcoin/src/secp256k1/src/modules/ellswift/main_impl.h |
ec_privkey_import_der | int ec_privkey_import_der(const secp256k1_context* ctx, unsigned char *out32, const unsigned char *privkey, size_t privkeylen) {
const unsigned char *end = privkey + privkeylen;
int lenb = 0;
int len = 0;
memset(out32, 0, 32);
/* sequence header */
if (end < privkey+1 || *privkey != 0x30) {
... | xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsi)
movups %xmm0, (%rsi)
xorl %eax, %eax
testq %rcx, %rcx
jle 0x262e0
cmpb $0x30, (%rdx)
jne 0x262e0
cmpq $0x1, %rcx
je 0x262e0
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movzbl 0x1(%rdx), %esi
testb %sil, %sil
jns 0x262d9
movq %rdi, %r14
andl $0x7f, %esi
leal -0x3(%rsi), %... | /fanquake[P]bitcoin/src/secp256k1/src/../contrib/lax_der_privatekey_parsing.c |
ec_privkey_export_der | int ec_privkey_export_der(const secp256k1_context *ctx, unsigned char *privkey, size_t *privkeylen, const unsigned char *key32, int compressed) {
secp256k1_pubkey pubkey;
size_t pubkeylen = 0;
if (!secp256k1_ec_pubkey_create(ctx, &pubkey, key32)) {
*privkeylen = 0;
return 0;
}
if (co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, (%rsp)
leaq 0x8(%rsp), %rsi
movq %rcx, %rdx
callq 0x15c31
testl %eax, %eax
je 0x2637c
testl %ebp, %ebp
je 0x26383
movabsq $0x2004010102d38130, %ra... | /fanquake[P]bitcoin/src/secp256k1/src/../contrib/lax_der_privatekey_parsing.c |
run_ellswift_tests | void run_ellswift_tests(void) {
int i = 0;
/* Test vectors. */
for (i = 0; (unsigned)i < sizeof(ellswift_xswiftec_inv_tests) / sizeof(ellswift_xswiftec_inv_tests[0]); ++i) {
const struct ellswift_xswiftec_inv_test *testcase = &ellswift_xswiftec_inv_tests[i];
int c;
for (c = 0; c < 8;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb78, %rsp # imm = 0xB78
leaq 0x59a39(%rip), %r13 # 0x7fe58
xorl %ebx, %ebx
imulq $0x198, %rbx, %rax # imm = 0x198
leaq 0x599d1(%rip), %rcx # 0x7fe00
leaq (%rcx,%rax), %r15
leaq (%rax,%rcx), %rdx
addq $0x30, %rdx
movq %rdx,... | /fanquake[P]bitcoin/src/secp256k1/src/modules/ellswift/tests_impl.h |
fe_equal | static int fe_equal(const secp256k1_fe *a, const secp256k1_fe *b) {
secp256k1_fe an = *a;
secp256k1_fe bn = *b;
secp256k1_fe_normalize_weak(&an);
return secp256k1_fe_equal(&an, &bn);
} | subq $0x28, %rsp
movq 0x20(%rdi), %r8
movq (%rsi), %rcx
movq 0x20(%rsi), %rax
movabsq $0xffffffffffff, %rdx # imm = 0xFFFFFFFFFFFF
andq %r8, %rdx
shrq $0x30, %r8
movabsq $0x1000003d1, %r9 # imm = 0x1000003D1
imulq %r8, %r9
addq (%rdi), %r9
movq %r9, %r8
shrq $0x34, %r8
addq 0x8(%rdi), %r8
movabsq $0xfffffffffff... | /fanquake[P]bitcoin/src/secp256k1/src/tests.c |
secp256k1_ellswift_xswiftec_var | static void secp256k1_ellswift_xswiftec_var(secp256k1_fe *x, const secp256k1_fe *u, const secp256k1_fe *t) {
secp256k1_fe xn, xd;
secp256k1_ellswift_xswiftec_frac_var(&xn, &xd, u, t);
secp256k1_fe_inv_var(&xd, &xd);
secp256k1_fe_mul(x, &xn, &xd);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, 0x80(%rsp)
leaq 0xb0(%rsp), %rbx
leaq 0x88(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20ec5
movq %r14, %rdi
movq %r14, %rsi
callq 0x5e3b8
movq (%rbx), %rcx
movq 0x8(%rbx), %rbp
movq 0x1... | /fanquake[P]bitcoin/src/secp256k1/src/modules/ellswift/main_impl.h |
testutil_random_ge_test | static void testutil_random_ge_test(secp256k1_ge *ge) {
secp256k1_fe fe;
do {
testutil_random_fe_test(&fe);
if (secp256k1_ge_set_xo_var(ge, &fe, testrand_bits(1))) {
secp256k1_fe_normalize(&ge->y);
break;
}
} while(1);
ge->infinity = 0;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x60a87
movq 0x19a9e3(%rip), %rax # 0x1c2110
movq 0x19a9f4(%rip), %rcx # 0x1c2128
leaq (%rcx,%rax), %rdx
rolq $0x17, %rdx
addq %rax, %rdx
movq 0x19a9d2(%rip), %rsi # 0x1c2118
movq %rsi, %rdi
shlq $0x11, %rdi
movq 0x19a... | /fanquake[P]bitcoin/src/secp256k1/src/testutil.h |
testrand256 | static void testrand256(unsigned char *b32) {
int i;
for (i = 0; i < 4; ++i) {
uint64_t val = testrand64();
b32[0] = val;
b32[1] = val >> 8;
b32[2] = val >> 16;
b32[3] = val >> 24;
b32[4] = val >> 32;
b32[5] = val >> 40;
b32[6] = val >> 48;
... | movq 0x19a95b(%rip), %rax # 0x1c2110
movq 0x19a96c(%rip), %rcx # 0x1c2128
movq 0x19a955(%rip), %rdx # 0x1c2118
movq 0x19a956(%rip), %rsi # 0x1c2120
xorl %r8d, %r8d
leaq (%rcx,%rax), %r9
rolq $0x17, %r9
addq %rax, %r9
movq %rdx, %r10
shlq $0x11, %r10
xorq %rax, %rsi
xorq %rdx, %rcx
xorq %rsi, %rdx
xorq %rcx,... | /fanquake[P]bitcoin/src/secp256k1/src/testrand_impl.h |
secp256k1_ge_eq_var | static int secp256k1_ge_eq_var(const secp256k1_ge *a, const secp256k1_ge *b) {
secp256k1_fe tmp;
SECP256K1_GE_VERIFY(a);
SECP256K1_GE_VERIFY(b);
if (a->infinity != b->infinity) return 0;
if (a->infinity) return 1;
tmp = a->x;
secp256k1_fe_normalize_weak(&tmp);
if (!secp256k1_fe_equal(&... | movl 0x50(%rdi), %ecx
xorl %eax, %eax
cmpl 0x50(%rsi), %ecx
jne 0x2782f
movl $0x1, %eax
testl %ecx, %ecx
je 0x27830
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x3ffffffffffffc, %r15 # imm = 0x3FFFFFFFFFFFFC
movabsq $0x3ffffbfffff0bc, ... | /fanquake[P]bitcoin/src/secp256k1/src/group_impl.h |
test_sha256_eq | static void test_sha256_eq(const secp256k1_sha256 *sha1, const secp256k1_sha256 *sha2) {
/* Is buffer fully consumed? */
CHECK((sha1->bytes & 0x3F) == 0);
CHECK(sha1->bytes == sha2->bytes);
CHECK(secp256k1_memcmp_var(sha1->s, sha2->s, sizeof(sha1->s)) == 0);
} | pushq %rax
movq 0x60(%rdi), %rax
testb $0x3f, %al
jne 0x27ba2
cmpq 0x60(%rsi), %rax
jne 0x27ba7
xorl %ecx, %ecx
movl %eax, %edx
movzbl (%rdi,%rcx), %r8d
movzbl (%rsi,%rcx), %r9d
movl %r8d, %eax
subl %r9d, %eax
cmpb %r9b, %r8b
cmovel %edx, %eax
jne 0x27b9c
incq %rcx
cmpq $0x20, %rcx
jne 0x27b77
xorl %eax, %eax
testl %ea... | /fanquake[P]bitcoin/src/secp256k1/src/tests.c |
run_static_context_tests | static void run_static_context_tests(int use_prealloc) {
/* Check that deprecated secp256k1_context_no_precomp is an alias to secp256k1_context_static. */
CHECK(secp256k1_context_no_precomp == secp256k1_context_static);
{
unsigned char seed[32] = {0x17};
/* Randomizing secp256k1_context_st... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x187f08(%rip), %rcx # 0x1c20d0
cmpq %rcx, 0x187f09(%rip) # 0x1c20d8
jne 0x3a4d6
movl %edi, %ebx
movaps 0x63022(%rip), %xmm0 # 0x9d200
movaps %xmm0, 0x30(%rsp)
movaps 0x63006(%rip), %xmm0 # 0x9d1f0
movaps %xmm0, 0x20(%rsp)
movl $0x0, 0xc(%rsp... | /fanquake[P]bitcoin/src/secp256k1/src/tests.c |
run_schnorrsig_tests | static void run_schnorrsig_tests(void) {
int i;
run_nonce_function_bip340_tests();
test_schnorrsig_api();
test_schnorrsig_sha256_tagged();
test_schnorrsig_bip_vectors();
for (i = 0; i < COUNT; i++) {
test_schnorrsig_sign();
test_schnorrsig_sign_verify();
}
test_schnorrsi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3d8, %rsp # imm = 0x3D8
movabsq $0x65636e6f6e2f3034, %rax # imm = 0x65636E6F6E2F3034
leaq 0x50(%rsp), %r13
movq %rax, 0x5(%r13)
movabsq $0x2f30343330504942, %rax # imm = 0x2F30343330504942
movq %rax, (%r13)
leaq 0x56944(%rip), %rsi ... | /fanquake[P]bitcoin/src/secp256k1/src/modules/schnorrsig/tests_impl.h |
secp256k1_fe_impl_mul | SECP256K1_INLINE static void secp256k1_fe_impl_mul(secp256k1_fe *r, const secp256k1_fe *a, const secp256k1_fe * SECP256K1_RESTRICT b) {
secp256k1_fe_mul_inner(r->n, a->n, b->n);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rcx
movq (%rsi), %r8
movq 0x8(%rsi), %rbp
movq 0x10(%rsi), %r15
movq %r15, -0x48(%rsp)
movq 0x18(%rsi), %r14
movq 0x18(%rdx), %rax
movq %rax, -0x58(%rsp)
mulq %r8
movq %r8, %r13
movq %rax, %r8
movq %rdx, %r9
movq 0x10(%rcx), %rax
movq %rax, -... | /fanquake[P]bitcoin/src/secp256k1/src/field_5x52_impl.h |
secp256k1_ge_to_storage | static void secp256k1_ge_to_storage(secp256k1_ge_storage *r, const secp256k1_ge *a) {
secp256k1_fe x, y;
SECP256K1_GE_VERIFY(a);
VERIFY_CHECK(!a->infinity);
x = a->x;
secp256k1_fe_normalize(&x);
y = a->y;
secp256k1_fe_normalize(&y);
secp256k1_fe_to_storage(&r->x, &x);
secp256k1_fe_t... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movaps %xmm1, 0x10(%r15)
movq 0x20(%rsi), %rax
movq %rax, 0x20(%r15)
movq %r15, %rdi
callq 0x25dea
movq 0x48(%r12), %rax
movq %rsp, %r14
m... | /fanquake[P]bitcoin/src/secp256k1/src/group_impl.h |
secp256k1_ge_from_storage | static void secp256k1_ge_from_storage(secp256k1_ge *r, const secp256k1_ge_storage *a) {
secp256k1_fe_from_storage(&r->x, &a->x);
secp256k1_fe_from_storage(&r->y, &a->y);
r->infinity = 0;
SECP256K1_GE_VERIFY(r);
} | movabsq $0xfffffff000000, %rcx # imm = 0xFFFFFFF000000
leaq 0xffffff(%rcx), %rax
movq (%rsi), %rdx
andq %rax, %rdx
movq %rdx, (%rdi)
movq (%rsi), %rdx
movq 0x8(%rsi), %r8
shrq $0x34, %rdx
shlq $0xc, %r8
orq $0xfff000, %rcx # imm = 0xFFF000
andq %rcx, %r8
orq %rdx, %r8
movq %r8, 0x8(%rdi)
movq 0x8(%rsi), %rdx
m... | /fanquake[P]bitcoin/src/secp256k1/src/group_impl.h |
secp256k1_der_read_len | static int secp256k1_der_read_len(size_t *len, const unsigned char **sigp, const unsigned char *sigend) {
size_t lenleft;
unsigned char b1;
VERIFY_CHECK(len != NULL);
*len = 0;
if (*sigp >= sigend) {
return 0;
}
b1 = *((*sigp)++);
if (b1 == 0xFF) {
/* X.690-0207 8.1.3.5.c... | movq $0x0, (%rdi)
movq (%rsi), %rcx
xorl %eax, %eax
cmpq %rdx, %rcx
jae 0x49ba6
leaq 0x1(%rcx), %r8
movq %r8, (%rsi)
movzbl (%rcx), %ecx
cmpq $0xff, %rcx
je 0x49ba6
testb %cl, %cl
js 0x49b90
movq %rcx, (%rdi)
movl $0x1, %eax
retq
cmpl $0x80, %ecx
je 0x49ba6
andl $0x7f, %ecx
movq %rdx, %r9
subq %r8, %r9
cmpq %rcx, %r9
j... | /fanquake[P]bitcoin/src/secp256k1/src/ecdsa_impl.h |
secp256k1_der_parse_integer | static int secp256k1_der_parse_integer(secp256k1_scalar *r, const unsigned char **sig, const unsigned char *sigend) {
int overflow = 0;
unsigned char ra[32] = {0};
size_t rlen;
if (*sig == sigend || **sig != 0x02) {
/* Not a primitive integer (X.690-0207 8.3.1). */
return 0;
}
(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl $0x0, 0x4(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq (%rsi), %rax
xorl %ebp, %ebp
cmpq %rdx, %rax
je 0x49d22
cmpb $0x2, (%rax)
jne 0x49d22
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
incq %rax
movq %rax, (%rsi)
le... | /fanquake[P]bitcoin/src/secp256k1/src/ecdsa_impl.h |
secp256k1_scalar_inverse_var | static void secp256k1_scalar_inverse_var(secp256k1_scalar *r, const secp256k1_scalar *x) {
secp256k1_modinv64_signed62 s;
#ifdef VERIFY
int zero_in = secp256k1_scalar_is_zero(x);
#endif
SECP256K1_SCALAR_VERIFY(x);
secp256k1_scalar_to_signed62(&s, x);
secp256k1_modinv64_var(&s, &secp256k1_const_modi... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rsi
movq %rsi, %rdi
shldq $0x6, %rdx, %rdi
shldq $0x4, %rcx, %rdx
shldq $0x2, %rax, %rcx
movabsq $0x3fffffffffffffff, %r8 # imm = 0x3FFFFFFFFFFFFFFF
andq %r8, %rax
movq %rsp, %r14
movq %... | /fanquake[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_scalar_mul | static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b) {
uint64_t l[8];
SECP256K1_SCALAR_VERIFY(a);
SECP256K1_SCALAR_VERIFY(b);
secp256k1_scalar_mul_512(l, a, b);
secp256k1_scalar_reduce_512(r, l);
SECP256K1_SCALAR_VERIFY(r);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rax
movq %rdi, %rbp
leaq 0x50(%rsp), %rsi
movq %rax, %rdi
movq (%rdi), %r15
movq 0x8(%rdi), %rbx
movq 0x10(%rdi), %rcx
movq (%rdx), %r11
movq 0x8(%rdx), %r12
movq 0x10(%rdx), %r13
movq 0x18(%rdx), %r14
movq %r15, %rax
mulq %r... | /fanquake[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_gej_eq_x_var | static int secp256k1_gej_eq_x_var(const secp256k1_fe *x, const secp256k1_gej *a) {
secp256k1_fe r;
SECP256K1_FE_VERIFY(x);
SECP256K1_GEJ_VERIFY(a);
VERIFY_CHECK(!a->infinity);
secp256k1_fe_sqr(&r, &a->z); secp256k1_fe_mul(&r, &r, x);
return secp256k1_fe_equal(&r, &a->x);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq 0x50(%rsi), %rcx
movq 0x58(%rsi), %r10
movq %r10, 0x18(%rsp)
movq 0x68(%rsi), %r15
movq %rsi, %r9
leaq (%rcx,%rcx), %rdx
movq %rdx, 0x40(%rsp)
movq %r15, %rax
movq %r15, 0x8(%rsp)
mulq %rdx
movq %rax, %rsi
movq %rdx, %r8
movq 0x60(%... | /fanquake[P]bitcoin/src/secp256k1/src/group_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
movq %rsi, %r14
xorps %xmm0, %xmm0
leaq 0x90(%rsp), %rcx
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, (%rcx)
xorl %eax, %eax
movq %rax, 0x20(%rcx)
leaq 0xc0(%rsp), %rcx
movaps %xmm0, (%rcx)
movq %rax, 0x20(%rcx)
movaps %xmm0, 0x10(%rcx)
movq $... | /fanquake[P]bitcoin/src/secp256k1/src/modinv64_impl.h |
secp256k1_modinv64_update_de_62 | static void secp256k1_modinv64_update_de_62(secp256k1_modinv64_signed62 *d, secp256k1_modinv64_signed62 *e, const secp256k1_modinv64_trans2x2 *t, const secp256k1_modinv64_modinfo* modinfo) {
const uint64_t M62 = UINT64_MAX >> 2;
const int64_t d0 = d->v[0], d1 = d->v[1], d2 = d->v[2], d3 = d->v[3], d4 = d->v[4];... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, -0x48(%rsp)
movq %rdi, -0x40(%rsp)
movq (%rdi), %r8
movq 0x20(%rdi), %rax
movq 0x20(%rsi), %r14
movq %rsi, -0x30(%rsp)
movq (%rdx), %r13
movq 0x8(%rdx), %r10
movq 0x10(%rdx), %r15
movq 0x18(%rdx), %rdx
movq %rax, -0x10(%rsp)
sarq $0x3f, %rax
m... | /fanquake[P]bitcoin/src/secp256k1/src/modinv64_impl.h |
secp256k1_modinv64_update_fg_62_var | static void secp256k1_modinv64_update_fg_62_var(int len, secp256k1_modinv64_signed62 *f, secp256k1_modinv64_signed62 *g, const secp256k1_modinv64_trans2x2 *t) {
const uint64_t M62 = UINT64_MAX >> 2;
const int64_t u = t->u, v = t->v, q = t->q, r = t->r;
int64_t fi, gi;
secp256k1_int128 cf, cg;
int i;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq (%rcx), %rbp
movq 0x8(%rcx), %r14
movq 0x10(%rcx), %r12
movq 0x18(%rcx), %r13
movq (%rsi), %rcx
movq (%rdx), %r10
movq %rcx, %rax
imulq %rbp
movq %rdx, %r11
movq %rax, %rbx
movq %r10, %rax
imulq %r14
movq %rdx, %r8
movq %rax, %r9
add... | /fanquake[P]bitcoin/src/secp256k1/src/modinv64_impl.h |
secp256k1_modinv64_normalize_62 | static void secp256k1_modinv64_normalize_62(secp256k1_modinv64_signed62 *r, int64_t sign, const secp256k1_modinv64_modinfo *modinfo) {
const int64_t M62 = (int64_t)(UINT64_MAX >> 2);
int64_t r0 = r->v[0], r1 = r->v[1], r2 = r->v[2], r3 = r->v[3], r4 = r->v[4];
volatile int64_t cond_add, cond_negate;
#ifdef... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %r8
movq 0x10(%rdi), %r9
movq 0x18(%rdi), %r14
movq 0x20(%rdi), %r12
movq %r12, %rax
sarq $0x3f, %rax
movq %rax, -0x10(%rsp)
movq (%rdx), %rax
movq -0x10(%rsp), %r10
andq %rax, %r10
addq %rcx, %r10
movq 0x8(%rdx), %rcx
movq -0x10(%rsp), %r15
... | /fanquake[P]bitcoin/src/secp256k1/src/modinv64_impl.h |
secp256k1_rfc6979_hmac_sha256_initialize | static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_hmac_sha256 *rng, const unsigned char *key, size_t keylen) {
secp256k1_hmac_sha256 hmac;
static const unsigned char zero[1] = {0x00};
static const unsigned char one[1] = {0x01};
memset(rng->v, 0x01, 32); /* RFC6979 3.2.b. */
mem... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movaps 0x25d78(%rip), %xmm0 # 0x71160
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x20(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movq %rsp, %r14
movl $... | /fanquake[P]bitcoin/src/secp256k1/src/hash_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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x40(%rdi)
je 0x4b596
leaq 0x20(%rbx), %r12
leaq 0x8(%rsp), %r15
movl $0x20, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x4b5ed
movl $0x20, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1ab0f
leaq 0x37c66(%rip), %rsi ... | /fanquake[P]bitcoin/src/secp256k1/src/hash_impl.h |
secp256k1_hmac_sha256_initialize | static void secp256k1_hmac_sha256_initialize(secp256k1_hmac_sha256 *hash, const unsigned char *key, size_t keylen) {
size_t n;
unsigned char rkey[64];
if (keylen <= sizeof(rkey)) {
memcpy(rkey, key, keylen);
memset(rkey + keylen, 0, sizeof(rkey) - keylen);
} else {
secp256k1_sha2... | pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpq $0x40, %rdx
ja 0x4b625
movq %rsp, %rdi
movq %r14, %rdx
callq 0x1110
leaq (%rsp,%r14), %rdi
movl $0x40, %edx
subq %r14, %rdx
xorl %esi, %esi
callq 0x10d0
jmp 0x4b66f
movaps 0x259e4(%rip), %xmm0 # 0x71010
leaq 0x40(%rsp), %r15
movap... | /fanquake[P]bitcoin/src/secp256k1/src/hash_impl.h |
secp256k1_ecdsa_sig_sign | static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context *ctx, secp256k1_scalar *sigr, secp256k1_scalar *sigs, const secp256k1_scalar *seckey, const secp256k1_scalar *message, const secp256k1_scalar *nonce, int *recid) {
unsigned char b[32];
secp256k1_gej rp;
secp256k1_ge r;
secp256k1_scal... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %r9, %r15
movq %r8, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
leaq 0xc(%rsp), %rbp
movl $0x0, (%rbp)
leaq 0xc0(%rsp), %r12
movq %r12, %rsi
movq %r9, %rdx
callq 0x4b983
leaq 0x20(%rsp)... | /fanquake[P]bitcoin/src/secp256k1/src/ecdsa_impl.h |
secp256k1_ecmult_gen | static void secp256k1_ecmult_gen(const secp256k1_ecmult_gen_context *ctx, secp256k1_gej *r, const secp256k1_scalar *gn) {
uint32_t comb_off;
secp256k1_ge add;
secp256k1_fe neg;
secp256k1_ge_storage adds;
secp256k1_scalar d;
/* Array of uint32_t values large enough to store COMB_BITS bits. Only t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0xb0(%rsp)
movaps %xmm0, 0xa0(%rsp)
movl $0x0, 0xc0(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %... | /fanquake[P]bitcoin/src/secp256k1/src/ecmult_gen_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 %r14
pushq %rbx
movq (%rdx), %rcx
addq (%rsi), %rcx
movq %rcx, (%rdi)
movq 0x8(%rsi), %r8
adcq $0x0, %r8
setb %al
movzbl %al, %r9d
addq 0x8(%rdx), %r8
movq %r8, 0x8(%rdi)
adcq 0x10(%rsi), %r9
setb %al
movzbl %al, %r10d
addq 0x10(%rdx), %r9
movq %r9, 0x10(%rdi)
adcq 0x18(%rsi), %r10
setb %al
movq 0x18(%... | /fanquake[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_scalar_inverse | static void secp256k1_scalar_inverse(secp256k1_scalar *r, const secp256k1_scalar *x) {
secp256k1_modinv64_signed62 s;
#ifdef VERIFY
int zero_in = secp256k1_scalar_is_zero(x);
#endif
SECP256K1_SCALAR_VERIFY(x);
secp256k1_scalar_to_signed62(&s, x);
secp256k1_modinv64(&s, &secp256k1_const_modinfo_scal... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rsi
movq %rsi, %rdi
shldq $0x6, %rdx, %rdi
shldq $0x4, %rcx, %rdx
shldq $0x2, %rax, %rcx
movabsq $0x3fffffffffffffff, %r8 # imm = 0x3FFFFFFFFFFFFFFF
andq %r8, %rax
movq %rsp, %r14
movq %... | /fanquake[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_scalar_cond_negate | static int secp256k1_scalar_cond_negate(secp256k1_scalar *r, int flag) {
/* If we are flag = 0, mask = 00...00 and this is a no-op;
* if we are flag = 1, mask = 11...11 and this is identical to secp256k1_scalar_negate */
volatile int vflag = flag;
uint64_t mask = -vflag;
uint64_t nonzero = (secp256... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, -0x4(%rsp)
movslq -0x4(%rsp), %rbx
movq (%rdi), %r10
movq 0x8(%rdi), %r9
movq %r9, %rsi
orq %r10, %rsi
movq 0x10(%rdi), %r11
orq %r11, %rsi
movq 0x18(%rdi), %r8
xorl %edx, %edx
movq %rbx, %rcx
negq %rcx
movl $0x0, %eax
sbbl %eax, %eax
xorq %rcx, %r10
movabsq $-0x40... | /fanquake[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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq (%rsi), %rcx
movq 0x8(%rsi), %r10
movq %r10, 0x20(%rsp)
movq 0x18(%rsi), %r14
movq %rsi, %r8
leaq (%rcx,%rcx), %rdx
movq %rdx, 0x60(%rsp)
movq %r14, %rax
movq %r14, 0x38(%rsp)
mulq %rdx
movq %rax, %r9
movq %rdx, %rsi
movq 0x10(%r8),... | /fanquake[P]bitcoin/src/secp256k1/src/group_impl.h |
secp256k1_modinv64 | static void secp256k1_modinv64(secp256k1_modinv64_signed62 *x, const secp256k1_modinv64_modinfo *modinfo) {
/* Start with d=0, e=1, f=modulus, g=x, zeta=-1. */
secp256k1_modinv64_signed62 d = {{0, 0, 0, 0, 0}};
secp256k1_modinv64_signed62 e = {{1, 0, 0, 0, 0}};
secp256k1_modinv64_signed62 f = modinfo->m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rax
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
leaq 0xd0(%rsp), %rax
movaps %xmm0, (%rax)
movq %rcx, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movq $0x1, (%rax)
movq... | /fanquake[P]bitcoin/src/secp256k1/src/modinv64_impl.h |
secp256k1_fe_impl_normalize_weak | static void secp256k1_fe_impl_normalize_weak(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];
/* Reduce t4 at the start so there will be at most a single carry from the first pass */
uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
/* The first pass ens... | movq 0x20(%rdi), %rcx
movabsq $0xffffffffffff, %rax # imm = 0xFFFFFFFFFFFF
andq %rcx, %rax
movq %rcx, %rdx
shrq $0x30, %rdx
movabsq $0x1000003d1, %rcx # imm = 0x1000003D1
imulq %rdx, %rcx
addq (%rdi), %rcx
movq %rcx, %rdx
shrq $0x34, %rdx
addq 0x8(%rdi), %rdx
movabsq $0xfffffffffffff, %rsi # imm = 0xFFFFFFFFFFF... | /fanquake[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... | /fanquake[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_fe_impl_inv | static void secp256k1_fe_impl_inv(secp256k1_fe *r, const secp256k1_fe *x) {
secp256k1_fe tmp = *x;
secp256k1_modinv64_signed62 s;
secp256k1_fe_normalize(&tmp);
secp256k1_fe_to_signed62(&s, &tmp);
secp256k1_modinv64(&s, &secp256k1_const_modinfo_fe);
secp256k1_fe_from_signed62(r, &s);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq %rsp, %r14
movq %rax, 0x20(%r14)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm1, 0x10(%r14)
movaps %xmm0, (%r14)
movq %r14, %rdi
callq 0x25dea
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq 0x18(%r14), %... | /fanquake[P]bitcoin/src/secp256k1/src/field_5x52_impl.h |
secp256k1_ecmult_strauss_wnaf | static void secp256k1_ecmult_strauss_wnaf(const struct secp256k1_strauss_state *state, secp256k1_gej *r, size_t num, const secp256k1_gej *a, const secp256k1_scalar *na, const secp256k1_scalar *ng) {
secp256k1_ge tmpa;
secp256k1_fe Z;
/* Split G factors. */
secp256k1_scalar ng_1, ng_128;
int wnaf_ng_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x568, %rsp # imm = 0x568
movq %rsi, 0x30(%rsp)
movq %rdi, %r14
movq $0x1, 0xe0(%rsp)
pxor %xmm2, %xmm2
movdqu %xmm2, 0xe8(%rsp)
movdqu %xmm2, 0xf8(%rsp)
testq %rdx, %rdx
movq %r9, 0x20(%rsp)
je 0x54376
movq %r8, %r12
movq %rcx, %r13
mov... | /fanquake[P]bitcoin/src/secp256k1/src/ecmult_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 %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
testl %esi, %esi
jle 0x55171
movl %ebp, %edx
shlq $0x2, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x10d0
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rs... | /fanquake[P]bitcoin/src/secp256k1/src/ecmult_impl.h |
secp256k1_ecmult_odd_multiples_table | static void secp256k1_ecmult_odd_multiples_table(int n, secp256k1_ge *pre_a, secp256k1_fe *zr, secp256k1_fe *z, const secp256k1_gej *a) {
secp256k1_gej d, ai;
secp256k1_ge d_ge;
int i;
VERIFY_CHECK(!a->infinity);
secp256k1_gej_double_var(&d, a, NULL);
/*
* Perform the additions using an ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %r8, %r12
movq %rcx, 0x78(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
cmpl $0x0, 0x78(%r8)
je 0x552d3
movl $0x1, 0x178(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x100(%rsp)
movaps %xmm0, 0x110(%rsp)
... | /fanquake[P]bitcoin/src/secp256k1/src/ecmult_impl.h |
secp256k1_gej_add_ge_var | static void secp256k1_gej_add_ge_var(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_ge *b, secp256k1_fe *rzr) {
/* Operations: 8 mul, 3 sqr, 11 add/negate/normalizes_to_zero (ignoring special cases) */
secp256k1_fe z12, u1, u2, s1, s2, h, i, h2, h3, t;
SECP256K1_GEJ_VERIFY(a);
SECP256K1_GE_VE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r14
cmpl $0x0, 0x78(%rsi)
movl 0x50(%rdx), %eax
je 0x56cdb
movl %eax, 0x78(%rdi)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm0, (%rdi)
movups %xmm1, 0x10(%rdi)
movq 0x20(%r14), %rax
movq... | /fanquake[P]bitcoin/src/secp256k1/src/group_impl.h |
secp256k1_scalar_cadd_bit | static void secp256k1_scalar_cadd_bit(secp256k1_scalar *r, unsigned int bit, int flag) {
secp256k1_uint128 t;
volatile int vflag = flag;
SECP256K1_SCALAR_VERIFY(r);
VERIFY_CHECK(bit < 256);
bit += ((uint32_t) vflag - 1) & 0x100; /* forcing (bit >> 6) > 3 makes this a noop */
secp256k1_u128_fro... | movl %esi, %ecx
movl %edx, -0x4(%rsp)
movl -0x4(%rsp), %esi
decl %esi
andl $0x100, %esi # imm = 0x100
addl %ecx, %esi
movl %esi, %edx
shrl $0x6, %edx
xorl %eax, %eax
cmpl $0x40, %esi
setb %al
shlq %cl, %rax
xorl %esi, %esi
cmpl $0x1, %edx
sete %sil
shlq %cl, %rsi
xorl %r8d, %r8d
cmpl $0x2, %edx
sete %r8b
shl... | /fanquake[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_fe_impl_normalizes_to_zero_var | static int secp256k1_fe_impl_normalizes_to_zero_var(const secp256k1_fe *r) {
uint64_t t0, t1, t2, t3, t4;
uint64_t z0, z1;
uint64_t x;
t0 = r->n[0];
t4 = r->n[4];
/* Reduce t4 at the start so there will be at most a single carry from the first pass */
x = t4 >> 48;
/* The first pass e... | movabsq $0xfffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFF
movabsq $0x1000003d0, %r8 # imm = 0x1000003D0
movq 0x20(%rdi), %rsi
movq %rsi, %rax
shrq $0x30, %rax
leaq 0x1(%r8), %rdx
imulq %rax, %rdx
addq (%rdi), %rdx
movq %rdx, %r9
andq %rcx, %r9
movabsq $0xffffefffffc2f, %rax # imm = 0xFFFFEFFFFFC2F
cmpq %rax, %r9
j... | /fanquake[P]bitcoin/src/secp256k1/src/field_5x52_impl.h |
secp256k1_ellswift_prng | static void secp256k1_ellswift_prng(unsigned char* out32, const secp256k1_sha256 *hasher, uint32_t cnt) {
secp256k1_sha256 hash = *hasher;
unsigned char buf4[4];
#ifdef VERIFY
size_t blocks = hash.bytes >> 6;
#endif
buf4[0] = cnt;
buf4[1] = cnt >> 8;
buf4[2] = cnt >> 16;
buf4[3] = cnt >> 24;... | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movl $0xd, %ecx
movq %r14, %rdi
rep movsq (%rsi), %es:(%rdi)
leaq 0xc(%rsp), %rsi
movl %edx, (%rsi)
movl $0x4, %edx
movq %r14, %rdi
callq 0x1ab0f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d52a
addq $0x78, %rsp
popq %rbx
popq %r14
retq
| /fanquake[P]bitcoin/src/secp256k1/src/modules/ellswift/main_impl.h |
secp256k1_ecmult_const | static void secp256k1_ecmult_const(secp256k1_gej *r, const secp256k1_ge *a, const secp256k1_scalar *q) {
/* The approach below combines the signed-digit logic from Mike Hamburg's
* "Fast and compact elliptic-curve cryptography" (https://eprint.iacr.org/2012/309)
* Section 3.3, with the GLV endomorphism.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc68, %rsp # imm = 0xC68
movq %rdi, %rbx
cmpl $0x0, 0x50(%rsi)
je 0x5f8e2
movl $0x1, 0x78(%rbx)
pxor %xmm0, %xmm0
movdqu %xmm0, (%rbx)
movdqu %xmm0, 0x10(%rbx)
movdqu %xmm0, 0x20(%rbx)
movdqu %xmm0, 0x30(%rbx)
movdqu %xmm0, 0x40(%rbx)
m... | /fanquake[P]bitcoin/src/secp256k1/src/ecmult_const_impl.h |
testutil_random_fe_test | static void testutil_random_fe_test(secp256k1_fe *x) {
unsigned char bin[32];
do {
testrand256_test(bin);
if (secp256k1_fe_set_b32_limit(x, bin)) {
return;
}
} while(1);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movabsq $0xffffefffffc2f, %r15 # imm = 0xFFFFEFFFFFC2F
movabsq $0xffffffffffff, %r12 # imm = 0xFFFFFFFFFFFF
movabsq $0xfffffffffffff, %r13 # imm = 0xFFFFFFFFFFFFF
movl $0x20, %esi
movq %r14, %rdi
callq 0x60afa
mo... | /fanquake[P]bitcoin/src/secp256k1/src/testutil.h |
context_eq | static int context_eq(const secp256k1_context *a, const secp256k1_context *b) {
return a->declassify == b->declassify
&& ecmult_gen_context_eq(&a->ecmult_gen_ctx, &b->ecmult_gen_ctx)
&& a->illegal_callback.fn == b->illegal_callback.fn
&& a->illegal_callback.data == b->illegal_cal... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl 0xc8(%rdi), %eax
xorl %ebx, %ebx
cmpl 0xc8(%rsi), %eax
jne 0x60e86
movq %rsi, %r14
movq %rdi, %r15
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x60e86
movq 0x8(%r15), %rax
cmpq 0x8(%r14), %rax
jne 0x60e86
movq 0x10(%r14), %rax
cmpq %rax, 0x10(%r15)
jne 0x60e86
movq 0x1... | /fanquake[P]bitcoin/src/secp256k1/src/tests.c |
secp256k1_scratch_max_allocation | static size_t secp256k1_scratch_max_allocation(const secp256k1_callback* error_callback, const secp256k1_scratch* scratch, size_t objects) {
if (secp256k1_memcmp_var(scratch->magic, "scratch", 8) != 0) {
secp256k1_callback_call(error_callback, "invalid scratch space");
return 0;
}
/* Ensure ... | movq %rdi, %rax
xorl %ecx, %ecx
leaq 0x11dd0(%rip), %r8 # 0x72c82
movl %edi, %r9d
movzbl (%rsi,%rcx), %r10d
movzbl (%rcx,%r8), %r11d
movl %r10d, %edi
subl %r11d, %edi
cmpb %r11b, %r10b
cmovel %r9d, %edi
jne 0x60ed9
incq %rcx
cmpq $0x8, %rcx
jne 0x60eb2
xorl %edi, %edi
testl %edi, %edi
je 0x60ef1
pushq %rax
movq 0x... | /fanquake[P]bitcoin/src/secp256k1/src/scratch_impl.h |
secp256k1_scratch_destroy | static void secp256k1_scratch_destroy(const secp256k1_callback* error_callback, secp256k1_scratch* scratch) {
if (scratch != NULL) {
if (secp256k1_memcmp_var(scratch->magic, "scratch", 8) != 0) {
secp256k1_callback_call(error_callback, "invalid scratch space");
return;
}
... | testq %rsi, %rsi
je 0x610b0
xorl %eax, %eax
leaq 0x11c0d(%rip), %rdx # 0x72c82
movl %ecx, %r8d
movzbl (%rsi,%rax), %r9d
movzbl (%rax,%rdx), %r10d
movl %r9d, %ecx
subl %r10d, %ecx
cmpb %r10b, %r9b
cmovel %r8d, %ecx
jne 0x6109c
incq %rax
cmpq $0x8, %rax
jne 0x61075
xorl %ecx, %ecx
testl %ecx, %ecx
je 0x610b1
movq (%r... | /fanquake[P]bitcoin/src/secp256k1/src/scratch_impl.h |
mulmod256 | static void mulmod256(uint16_t* out, const uint16_t* a, const uint16_t* b, const uint16_t* m) {
uint16_t mul[32];
uint64_t c = 0;
int i, j;
int m_bitlen = 0;
int mul_bitlen = 0;
if (b != NULL) {
/* Compute the product of a and b, and put it in mul. */
for (i = 0; i < 32; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rcx, %rax
testq %rdx, %rdx
je 0x61204
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r10d, %r10d
leal -0xf(%r8), %r9d
cmpq $0x10, %r8
cmovbl %ecx, %r9d
cmpl $0xf, %r9d
jg 0x611bc
movslq %r9d, %r9
cmpq $0xf, %r8
movl $0xf, %r11d
cmovlq %r8, %r11
leaq -0x1(%r9), %... | /fanquake[P]bitcoin/src/secp256k1/src/tests.c |
test_modinv32_uint16 | static void test_modinv32_uint16(uint16_t* out, const uint16_t* in, const uint16_t* mod) {
uint16_t tmp[16];
secp256k1_modinv32_signed30 x;
secp256k1_modinv32_modinfo m;
int i, vartime, nonzero;
uint16_to_signed30(&x, in);
nonzero = (x.v[0] | x.v[1] | x.v[2] | x.v[3] | x.v[4] | x.v[5] | x.v[6] ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movl $0x0, 0x20(%rsp)
xorl %eax, %eax
movl $0x88888889, %edx # imm = 0x88888889
movl %eax, %esi
imulq %rdx, %rsi
shrq ... | /fanquake[P]bitcoin/src/secp256k1/src/tests.c |
modinv2p64 | static uint64_t modinv2p64(uint64_t x) {
/* If w = 1/x mod 2^(2^L), then w*(2 - w*x) = 1/x mod 2^(2^(L+1)). See
* Hacker's Delight second edition, Henry S. Warren, Jr., pages 245-247 for
* why. Start with L=0, for which it is true for every odd x that
* 1/x=1 mod 2. Iterating 6 times gives us 1/x mod... | testb $0x1, %dil
je 0x61e2b
movl $0x1, %eax
movl $0x6, %ecx
movq %rax, %rdx
movq %rax, %rsi
imulq %rdi, %rsi
movl $0x2, %eax
subq %rsi, %rax
imulq %rdx, %rax
decl %ecx
jne 0x61e10
retq
pushq %rax
callq 0x119ef
| /fanquake[P]bitcoin/src/secp256k1/src/tests.c |
secp256k1_modinv32_var | static void secp256k1_modinv32_var(secp256k1_modinv32_signed30 *x, const secp256k1_modinv32_modinfo *modinfo) {
/* Start with d=0, e=1, f=modulus, g=x, eta=-1. */
secp256k1_modinv32_signed30 d = {{0, 0, 0, 0, 0, 0, 0, 0, 0}};
secp256k1_modinv32_signed30 e = {{1, 0, 0, 0, 0, 0, 0, 0, 0}};
secp256k1_modin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
xorl %eax, %eax
leaq 0x90(%rsp), %rcx
movl %eax, 0x20(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, (%rcx)
leaq 0xc0(%rsp), %rcx
movaps %xmm0, (%rcx)
movl %eax, 0x20(%rcx)
movaps %xmm0, 0x10(%rcx)
movl $0x1, (%rcx)
movl... | /fanquake[P]bitcoin/src/secp256k1/src/modinv32_impl.h |
secp256k1_modinv32_update_fg_30_var | static void secp256k1_modinv32_update_fg_30_var(int len, secp256k1_modinv32_signed30 *f, secp256k1_modinv32_signed30 *g, const secp256k1_modinv32_trans2x2 *t) {
const int32_t M30 = (int32_t)(UINT32_MAX >> 2);
const int32_t u = t->u, v = t->v, q = t->q, r = t->r;
int32_t fi, gi;
int64_t cf, cg;
int i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq (%rcx), %r8
movslq 0x4(%rcx), %r9
movslq 0x8(%rcx), %r10
movslq 0xc(%rcx), %rcx
movslq (%rsi), %r11
movslq (%rdx), %rbx
movq %r11, %r14
imulq %r8, %r14
movq %rbx, %rax
imulq %r9, %rax
addq %r14, %rax
imulq %r10, %r11
imulq %rcx, %rbx
addq %r11, %r... | /fanquake[P]bitcoin/src/secp256k1/src/modinv32_impl.h |
secp256k1_modinv32_normalize_30 | static void secp256k1_modinv32_normalize_30(secp256k1_modinv32_signed30 *r, int32_t sign, const secp256k1_modinv32_modinfo *modinfo) {
const int32_t M30 = (int32_t)(UINT32_MAX >> 2);
int32_t r0 = r->v[0], r1 = r->v[1], r2 = r->v[2], r3 = r->v[3], r4 = r->v[4],
r5 = r->v[5], r6 = r->v[6], r7 = r->v[7... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %r10d
movq %rdi, %r11
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
movl 0x8(%rdi), %esi
movl 0xc(%rdi), %edi
movl 0x10(%r11), %r8d
movl 0x14(%r11), %r15d
movl 0x18(%r11), %ebp
movl 0x1c(%r11), %r12d
movl 0x20(%r11), %r14d
movl %r14d, %r9d
sarl $0x1f... | /fanquake[P]bitcoin/src/secp256k1/src/modinv32_impl.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.