name string | code string | asm string | file string |
|---|---|---|---|
llvm::codeview::SymbolRecordMapping::visitKnownRecord(llvm::codeview::CVRecord<llvm::codeview::SymbolKind>&, llvm::codeview::FrameCookieSym&) | Error SymbolRecordMapping::visitKnownRecord(CVSymbol &CVR,
FrameCookieSym &FrameCookie) {
error(IO.mapInteger(FrameCookie.CodeOffset));
error(IO.mapInteger(FrameCookie.Register));
error(IO.mapEnum(FrameCookie.CookieKind));
error(IO.mapInteger(FrameCookie.Flags));
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x10, %r15
leaq 0x4(%rcx), %rdx
leaq 0x8(%rsp), %rcx
movw $0x101, 0x20(%rcx) # imm = 0x101
movq %r15, %rsi
callq 0x2eb82e
cmpq $0x0, (%rbx)
jne 0x2ed4a9
leaq 0x8(%r14), %rdx
leaq 0x8(%rsp), %rcx
movw $0x101, 0x2... | /DebugInfo/CodeView/SymbolRecordMapping.cpp |
llvm::codeview::SymbolRecordMapping::visitKnownRecord(llvm::codeview::CVRecord<llvm::codeview::SymbolKind>&, llvm::codeview::HeapAllocationSiteSym&) | Error SymbolRecordMapping::visitKnownRecord(
CVSymbol &CVR, HeapAllocationSiteSym &HeapAllocSite) {
error(IO.mapInteger(HeapAllocSite.CodeOffset));
error(IO.mapInteger(HeapAllocSite.Segment));
error(IO.mapInteger(HeapAllocSite.CallInstructionSize));
error(IO.mapInteger(HeapAllocSite.Type));
return Error... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x10, %r15
leaq 0x4(%rcx), %rdx
leaq 0x8(%rsp), %rcx
movw $0x101, 0x20(%rcx) # imm = 0x101
movq %r15, %rsi
callq 0x2eb82e
cmpq $0x0, (%rbx)
jne 0x2ed7f3
leaq 0x8(%r14), %rdx
leaq 0x8(%rsp), %rcx
movw $0x101, 0x2... | /DebugInfo/CodeView/SymbolRecordMapping.cpp |
llvm::codeview::TypeRecordMapping::visitTypeBegin(llvm::codeview::CVRecord<llvm::codeview::TypeLeafKind>&, llvm::codeview::TypeIndex) | Error TypeRecordMapping::visitTypeBegin(CVType &CVR, TypeIndex Index) {
if (IO.isStreaming())
IO.emitRawComment(" " + getLeafTypeName(CVR.kind()) + " (0x" +
utohexstr(Index.getIndex()) + ")");
return visitTypeBegin(CVR);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x48(%rsi)
je 0x2ef297
cmpq $0x0, 0x38(%r15)
jne 0x2ef297
cmpq $0x0, 0x40(%r15)
jne 0x2ef297
movl %ecx, %ebp
cmpq $0x4, 0x8(%r14)
jae 0x2ef0f6
xorl %eax, %eax
jmp 0x2ef0fd
movq (... | /DebugInfo/CodeView/TypeRecordMapping.cpp |
llvm::codeview::TypeRecordMapping::visitKnownRecord(llvm::codeview::CVRecord<llvm::codeview::TypeLeafKind>&, llvm::codeview::LabelRecord&) | Error TypeRecordMapping::visitKnownRecord(CVType &CVR, LabelRecord &Record) {
std::string ModeName = std::string(
getEnumName(IO, uint16_t(Record.Mode), ArrayRef(getLabelTypeEnum())));
error(IO.mapEnum(Record.Mode, "Mode: " + ModeName));
return Error::success();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %r14
movzwl 0x2(%rcx), %ebp
leaq 0x2(%rcx), %r15
callq 0x2f6b3f
movq %rdx, %rcx
movq %r14, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x2f166f
leaq 0x10(%rsp), %rbp
movq %rbp, -0x10(%rbp)
addq ... | /DebugInfo/CodeView/TypeRecordMapping.cpp |
llvm::codeview::CodeViewRecordIO::mapByteVectorTail(std::vector<unsigned char, std::allocator<unsigned char>>&, llvm::Twine const&) | Error CodeViewRecordIO::mapByteVectorTail(std::vector<uint8_t> &Bytes,
const Twine &Comment) {
ArrayRef<uint8_t> BytesRef(Bytes);
if (auto EC = mapByteVectorTail(BytesRef, Comment))
return EC;
if (!isWriting())
Bytes.assign(BytesRef.begin(), BytesRef.end());
re... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rax
movq %rsp, %rdx
movq %rax, (%rdx)
movq 0x8(%r14), %rsi
subq %rax, %rsi
movq %rsi, 0x8(%rdx)
movq %r15, %rsi
callq 0x2f5a8a
cmpq $0x0, (%rbx)
jne 0x2f5bda
cmpq $0x0, 0x30(%r15)
je 0x2f5bbf
cmpq $0x0, 0x38(... | /DebugInfo/CodeView/CodeViewRecordIO.cpp |
llvm::ELFAttributeParser::stringAttribute(unsigned int) | Error ELFAttributeParser::stringAttribute(unsigned tag) {
StringRef tagName =
ELFAttrs::attrTypeAsString(tag, tagToStringMap, /*hasTagPrefix=*/false);
StringRef desc = de.getCStrRef(cursor);
setAttributeString(tag, desc);
if (sw) {
DictScope scope(*sw, "Attribute");
sw->printNumber("Tag", tag);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rsi), %rsi
movq 0x98(%r14), %rdx
movl %ebp, %edi
xorl %ecx, %ecx
callq 0x31c8fb
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
leaq 0xa0(%r14), %rdi
leaq 0xb8(%r14), %rsi
leaq 0xc0(%r14)... | /Support/ELFAttributeParser.cpp |
llvm::yaml::Input::releaseHNodeBuffers() | void Input::releaseHNodeBuffers() {
EmptyHNodeAllocator.DestroyAll();
ScalarHNodeAllocator.DestroyAll();
SequenceHNodeAllocator.DestroyAll();
MapHNodeAllocator.DestroyAll();
} | pushq %rbx
movq %rdi, %rbx
addq $0xd0, %rdi
callq 0xb234a
leaq 0x130(%rbx), %rdi
callq 0xb234a
leaq 0x1f0(%rbx), %rdi
callq 0x3249e0
addq $0x190, %rbx # imm = 0x190
movq %rbx, %rdi
popq %rbx
jmp 0x324ad0
| /Support/YAMLTraits.cpp |
llvm::yaml::Input::endEnumScalar() | void Input::endEnumScalar() {
if (!ScalarMatchFound) {
setError(CurrentNode, "unknown enumerated scalar");
}
} | cmpb $0x0, 0x2a8(%rdi)
jne 0x32467a
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x2a0(%rdi), %rax
leaq 0xe9c2d(%rip), %rcx # 0x40e276
leaq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movw $0x103, 0x20(%rdx) # imm = 0x103
movq (%rax), %rsi
movq 0x50(%rdi), %rdi
xorl %ecx, %ecx
callq 0xafab8
callq 0x8b6a0
movl $0x16,... | /Support/YAMLTraits.cpp |
llvm::yaml::Input::beginBitSetScalar(bool&) | bool Input::beginBitSetScalar(bool &DoClear) {
BitValuesUsed.clear();
if (SequenceHNode *SQ = dyn_cast<SequenceHNode>(CurrentNode)) {
BitValuesUsed.resize(SQ->Entries.size());
} else {
setError(CurrentNode, "expected sequence of bit values");
}
DoClear = true;
return true;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movl %eax, 0x298(%rdi)
movl %eax, 0x260(%rdi)
movq 0x2a0(%rdi), %rax
movq (%rax), %rcx
cmpl $0x5, 0x20(%rcx)
jne 0x3246c6
addq $0x258, %r14 # imm = 0x258
movq 0x10(%rax), %rsi
subq 0x8(%rax), %rsi
shrq $0x3, %rsi
movq %r14... | /Support/YAMLTraits.cpp |
llvm::StringMap<std::pair<llvm::yaml::Input::HNode*, llvm::SMRange>, llvm::MallocAllocator>::count(llvm::StringRef) const | size_type count(StringRef Key) const { return contains(Key) ? 1 : 0; } | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xa75aa
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %eax, %ecx
callq 0xa77f8
cmpl $-0x1, %eax
setne %cl
movl 0x8(%r15), %edx
cltq
cmpq %rdx, %rax
setne %al
andb %cl, %al
movzbl %al, %eax
popq ... | /llvm/ADT/StringMap.h |
llvm::yaml::Input::setError(llvm::Twine const&) | void Input::setError(const Twine &Message) {
setError(CurrentNode, Message);
} | pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x2a0(%rdi), %rax
movq (%rax), %rsi
movq 0x50(%rdi), %rdi
xorl %ecx, %ecx
callq 0xafab8
callq 0x8b6a0
movl $0x16, 0x60(%rbx)
movq %rax, 0x68(%rbx)
popq %rbx
retq
| /Support/YAMLTraits.cpp |
llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseEncoding(bool) | Node *AbstractManglingParser<Derived, Alloc>::parseEncoding(bool ParseParams) {
// The template parameters of an encoding are unrelated to those of the
// enclosing context.
SaveTemplateParams SaveTemplateParamsScope(this);
if (look() == 'G' || look() == 'T')
return getDerived().parseSpecialName();
auto... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x70(%rsp), %rdi
movq %rbx, %rsi
callq 0x326e3a
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
je 0x325887
movzbl (%rax), %esi
cmpl $0x47, %esi
je 0x3... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::FunctionEncoding, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, llvm::ita... | Node *make(Args &&... args) {
return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq 0x40(%rsp), %rbp
addq $0x330, %rdi # imm = 0x330
movl $0x48, %esi
callq 0x327f92
movq (%r13), %rcx
movq (%r12), %rdx
movups (%r15), %xmm0
movq (%r14)... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseOperatorName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (ano... | Node *
AbstractManglingParser<Derived, Alloc>::parseOperatorName(NameState *State) {
if (const auto *Op = parseOperatorEncoding()) {
if (Op->getKind() == OperatorInfo::CCast) {
// ::= cv <type> # (cast)
ScopedOverride<bool> SaveTemplate(TryToParseTemplateArgs, false);
// If we're... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x32a262
movq %rax, %r14
testq %rax, %rax
je 0x32f720
movb 0x2(%r14), %al
cmpb $0x8, %al
jne 0x32f722
movb 0x308(%rbx), %bpl
movb 0x309(%rbx), %r13b
movb $0x0, 0x308(%rbx)
testq %r15, %r15
setne %al
orb %r... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::PostfixQualifiedType::printLeft(llvm::itanium_demangle::OutputBuffer&) const | void printLeft(OutputBuffer &OB) const override {
Ty->printLeft(OB);
OB += Postfix;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x18(%r15), %r14
testq %r14, %r14
je 0x3321fd
movq 0x20(%r15), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3256e2
movq (%rbx), %rdi
addq 0x8(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq ... | /llvm/Demangle/ItaniumDemangle.h |
(anonymous namespace)::Demangler::demangleOptionalBinder() | void Demangler::demangleOptionalBinder() {
uint64_t Binder = parseOptionalBase62Number('G');
if (Error || Binder == 0)
return;
// In valid inputs each bound lifetime is referenced later. Referencing a
// lifetime requires at least one byte of input. Reject inputs that are too
// short to reference all bo... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x47, %esi
callq 0x33aeae
testq %rax, %rax
je 0x33c828
cmpb $0x0, 0x31(%rbx)
jne 0x33c828
movq %rax, %r14
movq 0x18(%rbx), %rax
subq 0x10(%rbx), %rax
cmpq %rax, %r14
jae 0x33c824
leaq 0xd32aa(%rip), %rdx # 0x40fa65
movl $0x4, %esi
movq %rb... | /Demangle/RustDemangle.cpp |
delaunator::Delaunator::Delaunator(std::vector<double, std::allocator<double>> const&) | Delaunator::Delaunator(std::vector<double> const& in_coords)
: coords(in_coords),
triangles(),
halfedges(),
hull_prev(),
hull_next(),
hull_tri(),
hull_start(),
m_hash(),
m_center_x(),
m_center_y(),
m_hash_size(),
m_edge_stack() {
std::size_t n = ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, (%rdi)
addq $0x8, %rdi
leaq 0x20(%r14), %rax
movq %rax, -0xe0(%rbp)
leaq 0x38(%r14), %rax
movq %rax, -0xf0(%rbp)
leaq 0x50(%r14), %rax
movq %rax, -0x68(%rbp)
leaq 0x68(%r14), %ra... | /ConNoa[P]reaarangingpixels/source/librarys/delaunator.hpp |
Portioner::get_bucket_cluster(Point_d const&) | std::vector<std::vector<Point_d>>Portioner::get_bucket_cluster(Point_d const& point_in_bucket)
{
std::vector<std::vector<Point_d>>point_cluster;
long minusvalue = ((int)point_in_bucket.x%_X_Bucketsize);
int bucket_collumn = (int)(point_in_bucket.x-minusvalue)/_X_Bucketsize;
/*
DEBUG
std::cout<<"bucket column "... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
movsd (%rdx), %xmm0
cvttsd2si %xmm0, %eax
movsd 0x8(%rdx), %xmm1
movl 0x38(%rsi), %edi
cltd
idivl %edi
cvtsi2sd %edx, %x... | /ConNoa[P]reaarangingpixels/source/sorting/portioner.cpp |
Mems::get_mirror_cluster(Point_d const&) | std::vector<Mirror> Mems::get_mirror_cluster(Point_d const& displayed_sample){
std::vector<Mirror> m_cluster;
for(auto it = std::begin(_mems_mirrors); it != std::end(_mems_mirrors); it++)
{
double dis_x = displayed_sample.x - it->_position.x;
double dis_y = displayed_sample.y - it->_position.y;
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r12
cmpq 0x8(%rsi), %r12
je 0xccd0
movq %rdx, %r14
movq %rsi, %r15
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
subsd 0x8(%r12), %xmm0
subsd 0x10(%r12), %xmm1
... | /ConNoa[P]reaarangingpixels/source/mems.cpp |
Sampler::Sampler(int, cv::Mat const&) | Sampler(int amount, Mat const& image):
_Amount(amount),
_Image(image),
// _SampleMap_x(),
_SampleMap_xy()
//_Out(generalout),
// _Overlapmap(brigthnesmap)
{
srand(time(NULL)); //SEED
_Beamer_Resolution_x = 1920;
_Beamer_Resolution_y = 1080;
_X=_Im... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, (%rdi)
addq $0x8, %rdi
movq %rdx, %rsi
callq 0x8230
leaq 0x70(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x68(%rbx)
movq %rax, 0x80(%rbx)
movq %rax, 0x88(%rbx)
movq $0x0, 0x90(%rbx)
xorl %edi,... | /ConNoa[P]reaarangingpixels/source/sampling/sample.cpp |
Pixel_d::print(std::ostream&) const | void Pixel_d::print(std::ostream& os) const
{
os << "Pixel[" << (double)x << ',' << (double)y << "]("
<< color[0] << ','
<< color[1] << ','
<< color[2] << ')';
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1954(%rip), %rsi # 0x15a19
movl $0x6, %edx
movq %r14, %rdi
callq 0x8110
movsd (%rbx), %xmm0
movq %r14, %rdi
callq 0x8370
movb $0x2c, %r15b
leaq -0x19(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %ra... | /ConNoa[P]reaarangingpixels/source/pixel.cpp |
int ncnn::reduction_op_keepdims<std::plus<float>, std::plus<float>>(ncnn::Mat const&, ncnn::Mat&, float, bool, bool, bool, ncnn::Option const&) | static int reduction_op_keepdims(const Mat& a, Mat& b, float v0, bool reduce_w, bool reduce_h, bool reduce_c, const Option& opt)
{
Op op;
Op2 op2;
size_t elemsize = a.elemsize;
int dims = a.dims;
if (dims == 1)
{
int w = a.w;
b.create(1, elemsize, opt.blob_allocator);
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, %rbx
movq %rsi, (%rsp)
movq 0x10(%rdi), %r12
movq %rdi, 0x10(%rsp)
movl 0x28(%rdi), %eax
cmpl $0x3, %eax
je 0x3e049
cmpl $0x2, %eax
je 0x3df93
movq $0x0, 0x8(%rsp)
cmpl $0x1, %eax
jne 0x3e476
movq 0x10(%rsp), %r15
movl 0x2c(%r1... | /xiangweizeng[P]ncnn/src/layer/reduction.cpp |
int ncnn::reduction_post_process<ncnn::post_process_identity<float>>(ncnn::Mat&, float, ncnn::Option const&) | static int reduction_post_process(Mat& a, float coeff, const Option& opt)
{
MathOp mathop;
int dims = a.dims;
if (dims == 1)
{
int w = a.w;
#pragma omp parallel for num_threads(opt.num_threads)
for (int i=0; i<w; i++)
a[i] = mathop(a[i]) * coeff;
}
else if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x28(%rdi), %eax
cmpl $0x3, %eax
je 0x3f694
cmpl $0x2, %eax
je 0x3f667
cmpl $0x1, %eax
jne 0x3f72d
movl 0x2c(%rbx), %eax
movq (%rbx), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x3f72... | /xiangweizeng[P]ncnn/src/layer/reduction.cpp |
ncnn::fastMalloc(unsigned long) | static inline void* fastMalloc(size_t size)
{
#if _MSC_VER
return _aligned_malloc(size, MALLOC_ALIGN);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
void* ptr = 0;
if (posix_memalign(&ptr, MALLOC_ALIGN, size))
ptr = 0;
return ptr;
#elif __ANDROID__ && __ANDROID_API__... | pushq %rax
movq %rdi, %rdx
movq %rsp, %rdi
andq $0x0, (%rdi)
pushq $0x10
popq %rsi
callq 0x130e0
testl %eax, %eax
jne 0x3f759
movq (%rsp), %rax
jmp 0x3f75b
xorl %eax, %eax
popq %rcx
retq
| /xiangweizeng[P]ncnn/src/allocator.h |
int ncnn::reduction_op_keepdims<ncnn::reduction_op_sumsq<float>, std::plus<float>>(ncnn::Mat const&, ncnn::Mat&, float, bool, bool, bool, ncnn::Option const&) | static int reduction_op_keepdims(const Mat& a, Mat& b, float v0, bool reduce_w, bool reduce_h, bool reduce_c, const Option& opt)
{
Op op;
Op2 op2;
size_t elemsize = a.elemsize;
int dims = a.dims;
if (dims == 1)
{
int w = a.w;
b.create(1, elemsize, opt.blob_allocator);
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, %rbx
movq %rsi, (%rsp)
movq 0x10(%rdi), %r12
movq %rdi, 0x10(%rsp)
movl 0x28(%rdi), %eax
cmpl $0x3, %eax
je 0x3f8a1
cmpl $0x2, %eax
je 0x3f7e7
movq $0x0, 0x8(%rsp)
cmpl $0x1, %eax
jne 0x3fcf2
movq 0x10(%rsp), %r15
movl 0x2c(%r1... | /xiangweizeng[P]ncnn/src/layer/reduction.cpp |
int ncnn::reduction_post_process<ncnn::post_process_log<float>>(ncnn::Mat&, float, ncnn::Option const&) | static int reduction_post_process(Mat& a, float coeff, const Option& opt)
{
MathOp mathop;
int dims = a.dims;
if (dims == 1)
{
int w = a.w;
#pragma omp parallel for num_threads(opt.num_threads)
for (int i=0; i<w; i++)
a[i] = mathop(a[i]) * coeff;
}
else if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x28(%rdi), %eax
cmpl $0x3, %eax
je 0x40f7f
cmpl $0x2, %eax
je 0x40f4a
cmpl $0x1, %eax
jne 0x41012
movl 0x2c(%rbx), %r14d
movq (%rbx), %rbx
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je... | /xiangweizeng[P]ncnn/src/layer/reduction.cpp |
ncnn::ReLU::forward_inplace_int8(ncnn::Mat&, ncnn::Option const&) const | int ReLU::forward_inplace_int8(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
if (slope == 0.f)
{
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<cha... | xorps %xmm0, %xmm0
ucomiss 0xb8(%rdi), %xmm0
jne 0x4113d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl 0x30(%rsi), %r12d
movl 0x34(%rsi), %ebp
imull 0x2c(%rsi), %r12d
xorl %r14d, %r14d
testl %r12d, %r12d
cmovlel %r14d, %r12d
testl %ebp, %ebp
cmovlel %r14d, %ebp
... | /xiangweizeng[P]ncnn/src/layer/relu.cpp |
ncnn::ReLU::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int ReLU::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
if (bottom_top_blob.elemsize == 1u)
return ReLU::forward_inplace_int8(bottom_top_blob, opt);
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
if (slope ==... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x1, 0x10(%rsi)
jne 0x41177
movq %r14, %rdi
movq %rbx, %rsi
callq 0x410b2
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x30(%rbx), %r13d
imul... | /xiangweizeng[P]ncnn/src/layer/relu.cpp |
ncnn::fastMalloc(unsigned long) | static inline void* fastMalloc(size_t size)
{
#if _MSC_VER
return _aligned_malloc(size, MALLOC_ALIGN);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
void* ptr = 0;
if (posix_memalign(&ptr, MALLOC_ALIGN, size))
ptr = 0;
return ptr;
#elif __ANDROID__ && __ANDROID_API__... | pushq %rax
movq %rdi, %rdx
movq %rsp, %rdi
andq $0x0, (%rdi)
pushq $0x10
popq %rsi
callq 0x130e0
testl %eax, %eax
jne 0x415f0
movq (%rsp), %rax
jmp 0x415f2
xorl %eax, %eax
popq %rcx
retq
| /xiangweizeng[P]ncnn/src/allocator.h |
ncnn::Scale::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Scale::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
std::vector<Mat> bottom_top_blobs(2);
bottom_top_blobs[0] = bottom_top_blob;
bottom_top_blobs[1] = scale_data;
return forward_inplace(bottom_top_blobs, opt);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %r12
pushq $0x2
popq %rsi
leaq 0xf(%rsp), %rdx
movq %r12, %rdi
callq 0x20744
movq (%r12), %rdi
movq %r15, %rsi
callq 0x13a86
leaq 0xc0(%r14), %rsi
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
callq 0x... | /xiangweizeng[P]ncnn/src/layer/scale.cpp |
ncnn::Sigmoid::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Sigmoid::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
float* ptr =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0x30(%rsi), %r12d
imull 0x2c(%rsi), %r12d
xorl %r14d, %r14d
testl %r12d, %r12d
cmovlel %r14d, %r12d
movq %rsi, (%rsp)
movl 0x34(%rsi), %ebp
testl %ebp, %ebp
cmovlel %r14d, %ebp
leaq 0x8(%rsp), %r15
cmpl %ebp, %r14d
je 0x4205f
movq %... | /xiangweizeng[P]ncnn/src/layer/sigmoid.cpp |
ncnn::Slice::load_param(ncnn::ParamDict const&) | int Slice::load_param(const ParamDict& pd)
{
slices = pd.get(0, Mat());
axis = pd.get(1, 0);
return 0;
} | pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rcx
movups %xmm0, 0xc(%rcx)
movaps %xmm0, (%rcx)
movaps %xmm0, 0x20(%rcx)
movaps %xmm0, 0x30(%rcx)
movq %rsp, %rdi
xorl %edx, %edx
callq 0x21736
leaq 0xb8(%rbx), %rdi
movq %rsp, %rsi
callq 0x13a86
movq %rsp, %rdi... | /xiangweizeng[P]ncnn/src/layer/slice.cpp |
basic_suite::value_false() | void value_false()
{
const value_type input[] = { token::code::false_value };
format::reader reader(input);
TRIAL_PROTOCOL_TEST_EQUAL(reader.code(), token::code::false_value);
TRIAL_PROTOCOL_TEST_EQUAL(reader.symbol(), token::symbol::boolean);
TRIAL_PROTOCOL_TEST_EQUAL(reader.category(), token::cate... | pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp # imm = 0x2B0
movb $-0x80, -0x1(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0x218(%rbp)
leaq -0x1(%rbp), %rsi
callq 0x188e0
movq -0x218(%rbp), %rdi
callq 0x182a0
movl %eax, -0x88(%rbp)
movl $0x80, -0x8c(%rbp)
movq %rsp, %rax
leaq -0x8c(%rbp), %rcx
movq %rcx, (%rax)
l... | /breese[P]trial/test/bintoken/reader_suite.cpp |
basic_suite::value_true() | void value_true()
{
const value_type input[] = { token::code::true_value };
format::reader reader(input);
TRIAL_PROTOCOL_TEST_EQUAL(reader.code(), token::code::true_value);
TRIAL_PROTOCOL_TEST_EQUAL(reader.symbol(), token::symbol::boolean);
TRIAL_PROTOCOL_TEST_EQUAL(reader.category(), token::categor... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movb $-0x7f, -0x1(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
leaq -0x1(%rbp), %rsi
callq 0x188e0
movq -0xd0(%rbp), %rdi
callq 0x182a0
movl %eax, -0x88(%rbp)
movl $0x81, -0x8c(%rbp)
movq %rsp, %rax
leaq -0x8c(%rbp), %rcx
movq %rcx, (%rax)
leaq 0x242dd(%rip), %rdi ... | /breese[P]trial/test/bintoken/reader_suite.cpp |
basic_suite::run() | void run()
{
value_empty();
value_false();
output_false();
value_true();
value_null();
output_null();
} | pushq %rbp
movq %rsp, %rbp
callq 0x2540
callq 0x26f0
callq 0x3600
callq 0x4310
callq 0x4620
callq 0x4be0
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /breese[P]trial/test/bintoken/reader_suite.cpp |
number_suite::value_int16() | void value_int16()
{
const value_type input[] = { token::code::int16, 0x00, 0x01 };
format::reader reader(input);
TRIAL_PROTOCOL_TEST_EQUAL(reader.code(), token::code::int16);
TRIAL_PROTOCOL_TEST_EQUAL(reader.symbol(), token::symbol::integer);
TRIAL_PROTOCOL_TEST_EQUAL(reader.category(), token::cate... | pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp # imm = 0x310
movb $0x1, -0x2(%rbp)
movw $0xb2, -0x4(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0x260(%rbp)
leaq -0x4(%rbp), %rsi
callq 0x1a690
movq -0x260(%rbp), %rdi
callq 0x182a0
movl %eax, -0x88(%rbp)
movl $0xb2, -0x8c(%rbp)
movq %rsp, %rax
leaq -0x8c(%rbp), %rc... | /breese[P]trial/test/bintoken/reader_suite.cpp |
number_suite::output_int16() | void output_int16()
{
const value_type input[] = { token::code::int16, 0x00, 0x01 };
format::reader reader(input);
TRIAL_PROTOCOL_TEST(reader.length() == 1);
{
auto result = std::numeric_limits<token::boolean::type>::max();
TRIAL_PROTOCOL_TEST_THROW_EQUAL(reader.array(&result, 1),
... | pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp # imm = 0x260
movb $0x1, -0x2(%rbp)
movw $0xb2, -0x4(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
leaq -0x4(%rbp), %rsi
callq 0x1a690
movq -0x1f0(%rbp), %rdi
callq 0x18740
movq %rax, -0x1e8(%rbp)
jmp 0x968e
movq -0x1e8(%rbp), %rax
subq $0x1, %rax
sete %al
... | /breese[P]trial/test/bintoken/reader_suite.cpp |
number_suite::value_uint16() | void value_uint16()
{
const value_type input[] = {
token::code::int16, 0xFF, 0x7F,
token::code::int16, 0x00, 0x80,
token::code::int16, 0xFF, 0xFF
};
format::reader reader(input);
TRIAL_PROTOCOL_TEST_EQUAL(reader.code(), token::code::int16);
TRIAL_PROTOCOL_TEST_EQUAL(reader.sy... | pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
movabsq $-0x4d7fff4d80004e, %rax # imm = 0xFFB28000B27FFFB2
movq %rax, -0x10(%rbp)
movb $-0x1, -0x8(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x1a750
movq -0x1e8(%rbp), %rdi
callq 0x182a0
movl %eax, -0x90(%rbp)... | /breese[P]trial/test/bintoken/reader_suite.cpp |
number_suite::value_int32() | void value_int32()
{
const value_type input[] = { token::code::int32, 0x00, 0x00, 0x01, 0x00 };
format::reader reader(input);
TRIAL_PROTOCOL_TEST_EQUAL(reader.code(), token::code::int32);
TRIAL_PROTOCOL_TEST_EQUAL(reader.symbol(), token::symbol::integer);
TRIAL_PROTOCOL_TEST_EQUAL(reader.category(),... | pushq %rbp
movq %rsp, %rbp
subq $0x350, %rsp # imm = 0x350
movb $0x0, -0x4(%rbp)
movl $0x10000c4, -0x8(%rbp) # imm = 0x10000C4
leaq -0x80(%rbp), %rdi
movq %rdi, -0x290(%rbp)
leaq -0x8(%rbp), %rsi
callq 0x19ee0
movq -0x290(%rbp), %rdi
callq 0x182a0
movl %eax, -0x88(%rbp)
movl $0xc4, -0x8c(%rbp)
movq %rsp, %r... | /breese[P]trial/test/bintoken/reader_suite.cpp |
number_suite::value_int64() | void value_int64()
{
const value_type input[] = { token::code::int64, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00 };
format::reader reader(input);
TRIAL_PROTOCOL_TEST_EQUAL(reader.code(), token::code::int64);
TRIAL_PROTOCOL_TEST_EQUAL(reader.symbol(), token::symbol::integer);
TRIAL_PROTOCOL_TEST_... | pushq %rbp
movq %rsp, %rbp
subq $0x390, %rsp # imm = 0x390
movabsq $0x100000000d6, %rax # imm = 0x100000000D6
movq %rax, -0x10(%rbp)
movb $0x0, -0x8(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0x2c8(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x1a750
movq -0x2c8(%rbp), %rdi
callq 0x182a0
movl %eax, -0x90(%rbp)
movl $... | /breese[P]trial/test/bintoken/reader_suite.cpp |
compact_suite::fail_int16_overflow() | void fail_int16_overflow()
{
const value_type input[] = {
token::code::array8_int16, 3 * token::int16::size,
0x41, 0x00,
0x42, 0x00,
0x43, 0x00 };
format::reader reader(input);
TRIAL_PROTOCOL_TEST(reader.length() == 3);
std::array<std::int16_t, 1> buffer = {};
TRIAL_P... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movabsq $0x430042004106aa, %rax # imm = 0x430042004106AA
movq %rax, -0x8(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
leaq -0x8(%rbp), %rsi
callq 0x1b5c0
movq -0xd0(%rbp), %rdi
callq 0x18740
movq %rax, -0xc8(%rbp)
jmp 0x15022
movq -0xc8(%rbp),... | /breese[P]trial/test/bintoken/reader_suite.cpp |
compact_suite::test_float64() | void test_float64()
{
const value_type input[] = {
token::code::array8_float64, 3 * token::float64::size,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x40 };
format::reader reader(input)... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movups 0x11f98(%rip), %xmm0 # 0x285da
movups %xmm0, -0x16(%rbp)
movaps 0x11f83(%rip), %xmm0 # 0x285d0
movaps %xmm0, -0x20(%rbp)
leaq -0x98(%rbp), %rdi
movq %rdi, -0x158(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x1bef0
movq -0x158(%rbp), %rdi
callq 0x... | /breese[P]trial/test/bintoken/reader_suite.cpp |
buffer_queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::push(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool push(const T &item)
{
unique_lock<mutex> lck (b_mutex);;
if (b_size >= capacity)
{
b_cond.notify_all();
return false;
}
b_last = (b_last + 1) % capacity;
b_array[b_last] = item;
b_size++;
if(b_deb... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %rdi, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0x3ab8
movb $0x1, 0x8(%r15)
movl 0x7c(%rbx), %ebp
movl 0x80(%rbx), %r15d
cmpl %r15d, %ebp
jge 0x3923
movl 0x78(%rbx), %eax
incl %eax
cltd
idivl %... | /AlberTTreblA[P]HighPerformanceConcurrentServer/log/log_queue.h |
PP_point::PP_point(PP_point&) | PP_point( PP_point& other )
{
this->x = other.x;
this->y = other.y;
this->z = other.z;
this->e.clear();
for(unsigned int i=0 ; i<other.e.size() ; i++)
this->e.push_back(other.e.at(i));
this->canBePartOfGraph = other.canBePartOfGraph;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0xec49(%rip), %rax # 0x15fa8
addq $0x10, %rax
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movq $0x0, 0x38(%rdi)
movups 0x8(%rsi), %xmm0
movups %xmm0, 0x8(%rdi)
movsd 0x18(%rsi), %xmm0
movsd %xmm0, 0x18(%rd... | /matthewozon[P]simulationToolsCompPhy/compPhy/PP_graph.h |
PP_point::~PP_point() | virtual ~PP_point()
{
e.clear();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0xeabe(%rip), %rax # 0x15fa8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x28(%rdi), %r14
movq 0x28(%rdi), %r12
movq 0x30(%rdi), %r13
cmpq %r12, %r13
je 0x7520
movq %rdi, %rbx
movq %r12, %r15
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
addq $0x90, %r15
cm... | /matthewozon[P]simulationToolsCompPhy/compPhy/PP_graph.h |
PP_edge::PP_edge(PP_edge const&) | PP_edge( const PP_edge& other )
{
this->p1 = other.p1;
this->p2 = other.p2;
this->distp1p2 = other.distp1p2;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0xe6db(%rip), %rax # 0x15f80
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq 0xe6f1(%rip), %rax # 0x15fa8
addq $0x10, %rax
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
xorl %ecx, %ecx
m... | /matthewozon[P]simulationToolsCompPhy/compPhy/PP_graph.h |
PP_RK4::RK4step(double, double, double, double, double) | double* PP_RK4::RK4step(double x, double y, double z, double t, double dt)
{
double* K1 = RK4K1(x, y, z, t, dt);
double* K2 = RK4K2(x, y, z, K1[0], K1[1], K1[2], t, dt);
double* K3 = RK4K3(x, y, z, K2[0], K2[1], K2[2], t, dt);
double* K4 = RK4K4(x, y, z, K3[0], K3[1], K3[2], t, dt);
double* dr = new... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movaps %xmm4, 0x20(%rsp)
movsd %xmm3, 0x48(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r15
movq (%rdi), %rax
callq *(%rax)
movq %rax, %rbx
movupd (%rax), %xmm1
movapd 0x20(%rsp), %xmm0
movapd %xmm0, %xmm... | /matthewozon[P]simulationToolsCompPhy/compPhy/PP_RK4.cpp |
PP_FDTD_1D::PP_FDTD_1D(double, double, double, double, double, double, double, double) | PP_FDTD_1D::PP_FDTD_1D(double _dt, double _DT, double _dz, double _DZ, double _R, double _L, double _C, double _G)
{
dt = _dt;
DT = _DT;
dz = _dz;
DZ = _DZ;
R = _R;
L = _L;
C = _C;
G = _G;
Nt = (unsigned long) (DT/dt);
Nz = (unsigned long) (DZ/dz);
V = myAllocator.allocateDou... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm7, 0x28(%rsp)
movsd %xmm6, 0x20(%rsp)
movsd %xmm5, 0x18(%rsp)
movsd %xmm4, 0x10(%rsp)
movaps %xmm3, 0x40(%rsp)
movsd %xmm2, 0x8(%rsp)
movaps %xmm1, 0x30(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %rbx
movq 0xdc50(%rip), %rax # 0x15fd8
addq $0x10, %rax
movq %rax, (%rdi)
le... | /matthewozon[P]simulationToolsCompPhy/compPhy/PP_FDTD_1D.cpp |
PP_FDTD_1D::PP_FDTD_1D(PP_FDTD_1D const&) | PP_FDTD_1D::PP_FDTD_1D(PP_FDTD_1D const &other)
{
this->dt = other.dt;
this->DT = other.DT;
this->dz = other.dz;
this->DZ = other.DZ;
this->R = other.R;
this->L = other.L;
this->C = other.C;
this->G = other.G;
this->Nt = other.Nt;
this->Nz = other.Nz;
//copy initial conditio... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xdb5f(%rip), %rax # 0x15fd8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x28, %rdi
callq 0x6300
movups 0x50(%rbx), %xmm0
movups %xmm0, 0x50(%r14)
movups 0x60(%rbx), %xmm0
movups %xmm0, 0x60(%r14)
movups 0x8(%rbx), %xmm0
movups %xmm0, 0x8(%r14)
mov... | /matthewozon[P]simulationToolsCompPhy/compPhy/PP_FDTD_1D.cpp |
PP_FDTD_1D::run(bool, bool) | bool PP_FDTD_1D::run(bool shortCircuit, bool borderExcitationON)
{
//determine the coefficient of numerical iteration equations
calculateCoefficients();
//at t=0 initialize the whole space
intialState();
//iterations
for(unsigned long n=1 ; n<Nt ; n++) //loop over time
{
//determin... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x6680
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpq $0x2, 0x30(%r14)
jb 0x87bb
movq 0x38(%r14), %rax
movl $0x1, %r15d
movq %rax, %rcx
cmpq $0x2, %rcx
jb 0x86a3
movq 0x40(%r14), %rdi
movq 0x48(%r14), ... | /matthewozon[P]simulationToolsCompPhy/compPhy/PP_FDTD_1D.cpp |
PP_FDTD_1D::intialState() | void PP_FDTD_1D::intialState(void)
{
V[0][0] = 1.0;
/*for(unsigned long k=0 ; k<Nz ; k++)
{
//V[0][k] = cos(2*3.14161*4*k/Nz);
//I[0][k] = cos(2*3.14161*4*k/Nz);
if((10*k)>(Nz) && (10*k)<(2*Nz))
{
V[0][k] = 1.0;
I[0][k] = 1.0;
}
else
... | movq 0x48(%rdi), %rax
movq (%rax), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax)
retq
nop
| /matthewozon[P]simulationToolsCompPhy/compPhy/PP_FDTD_1D.cpp |
PP_smartAlloc::allocateDouble(unsigned long, unsigned long) | double ** PP_smartAlloc::allocateDouble(unsigned long _Nt, unsigned long _Nz)
{
double** _M = new double*[_Nt];
if(_M!=NULL)
{
unsigned long I = _Nt+1;
for(unsigned long i=0 ; i<_Nt ; i++)
{
_M[i] = new double[_Nz];
if(_M[i]==NULL)
{
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rsi, %rax
shrq $0x3d, %rax
leaq (,%rsi,8), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x6030
movq %rax, %r14
testq %rbx, %rbx
je 0x889e
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
leaq ... | /matthewozon[P]simulationToolsCompPhy/compPhy/PP_smartAlloc.cpp |
PP_COORD::show() | void PP_COORD::show(void)
{
std::cout << "(x,y,z)=(" << x << "," << y << "," << z << ")" << std::endl;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xc9fd(%rip), %r14 # 0x15fc0
leaq 0x7bb4(%rip), %rsi # 0x1117e
movl $0x9, %edx
movq %r14, %rdi
callq 0x6430
movsd (%rbx), %xmm0
movq %r14, %rdi
callq 0x6590
movq %rax, %r14
leaq 0x7a46(%rip), %r15 # 0x11033
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %... | /matthewozon[P]simulationToolsCompPhy/compPhy/PP_COORD.cpp |
PP_particle_set::PP_particle_set(int, double, double, double) | PP_particle_set::PP_particle_set(int N, double _R, double _m, double _e)
{
alpha=1.0;
PP_particle p_default;
p_default.R=_R;
p_default.m=_m;
p_default.e=_e;
for(int i=0 ; i<N ; i++)
S.push_back(p_default);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x18(%rdi)
leaq 0x18(%rsp), %rdi
call... | /matthewozon[P]simulationToolsCompPhy/compPhy/PP_particle_set.cpp |
load_model(test_model&, bool) | void load_model(test_model & model, bool use_gpu = false) {
// create data
int KW = 3, KH = 3, IC = 10, OC = 10;
int IW = 8, IH = 6, N = 1;
// Initialize adata
std::vector<float> adata(KW * KH * IC * OC);
for (int i = 0; i < KW * KH * IC * OC; i++) {
adata[i] = 2.5f;
}
// Conve... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x80(%rsp), %r14
leaq 0x60(%rsp), %rdx
movl $0x384, %esi # imm = 0x384
movq %r14, %rdi
callq 0x2d12
xorl %eax, %eax
movq (%r14), %rcx
cmpq $0x384, %rax # imm = 0x384
je 0x24f0
movl $0x40200000, (%rcx,%rax,4) # imm = ... | /ggerganov[P]ggml/tests/test-conv2d.cpp |
compute_graph(test_model const&, ggml_gallocr*) | struct ggml_cgraph * compute_graph(const test_model & model, ggml_gallocr_t allocr) {
struct ggml_cgraph * gf = build_graph(model);
// allocate tensors
ggml_gallocr_alloc_graph(allocr, gf);
int n_threads = 1;
if (ggml_backend_is_cpu(model.backend)) {
ggml_backend_cpu_set_n_threads(model.ba... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x27c5
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
callq 0x22b0
movq 0x10(%r14), %rdi
callq 0x21b0
testb %al, %al
je 0x29d4
movq 0x10(%r14), %rdi
pushq $0x1
popq %rsi
callq 0x2390
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x20f0
movq %rbx, %ra... | /ggerganov[P]ggml/tests/test-conv2d.cpp |
gpioStartThread | pthread_t *gpioStartThread(gpioThreadFunc_t f, void *userdata)
{
pthread_t *pth;
pthread_attr_t pthAttr;
DBG(DBG_USER, "f=%08"PRIXPTR", userdata=%08"PRIXPTR, (uintptr_t)f, (uintptr_t)userdata);
CHECK_INITED_RET_NULL_PTR;
pth = malloc(sizeof(pthread_t));
if (pth)
{
if (pthread_attr_init(&p... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl 0x18a5b(%rip), %eax # 0x32778
cmpl $0x4, %eax
jb 0x19d30
btl $0xa, 0x18a56(%rip) # 0x32780
jae 0x19e3e
cmpb $0x0, 0xa6ac1(%rip) # 0xc07f8
je 0x19d8a
pushq $0x8
popq %rdi
callq 0x7850
testq %rax, %rax
je 0x19d9e
movq %rax,... | /maxnet[P]pigpio/pigpio.c |
gpioStopThread | void gpioStopThread(pthread_t *pth)
{
DBG(DBG_USER, "pth=%08"PRIXPTR, (uintptr_t)pth);
CHECK_INITED_RET_NIL;
if (pth)
{
if (pthread_self() == *pth)
{
free(pth);
pthread_exit(NULL);
}
else
{
pthread_cancel(*pth);
pthread_join(*pth, NULL);
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x188bf(%rip), %eax # 0x32778
cmpl $0x4, %eax
jb 0x19ec8
btl $0xa, 0x188ba(%rip) # 0x32780
jae 0x19f1d
cmpb $0x0, 0xa6929(%rip) # 0xc07f8
jne 0x19ee1
movl 0x188a1(%rip), %eax # 0x32778
btl $0xa, 0x188a1(%rip) # 0x32780
jae 0x19f53
testq %rbx, %rb... | /maxnet[P]pigpio/pigpio.c |
gpioStoreScript | int gpioStoreScript(char *script)
{
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
gpioScript_t *s;
int status, slot, i;
DBG(DBG_USER, "script=[%s]", script);
CHECK_INITED;
slot = -1;
pthread_mutex_lock(&mutex);
for (i=0; i<PI_MAX_SCRIPTS; i++)
{
if (gpioScript[i].state ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x187d3(%rip), %eax # 0x32778
cmpl $0x4, %eax
jb 0x19fb8
btl $0xa, 0x187ce(%rip) # 0x32780
jae 0x1a10f
cmpb $0x0, 0xa6839(%rip) # 0xc07f8
je 0x19ff0
leaq 0xad5b8(%rip), %rdi # 0xc7580
callq 0x7e10
leaq 0xa9ab0(%rip), %rcx # ... | /maxnet[P]pigpio/pigpio.c |
absl::lts_20240722::debugging_internal::BoundedUtf8LengthSequence<256u>::InsertAndReturnSumOfPredecessors(unsigned int, unsigned int) | uint32_t InsertAndReturnSumOfPredecessors(
uint32_t index, uint32_t utf8_length) {
// The caller shouldn't pass out-of-bounds inputs, but if it does happen,
// clamp the values and try to continue. If we're being called from a
// signal handler, the last thing we want to do is crash. Emitting
//... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl $0xff, %eax
cmpl %eax, %esi
cmovbl %esi, %eax
leal (%rax,%rax), %ecx
andl $0x3e, %ecx
movq $-0x1, %r9
shlq %cl, %r9
movl %eax, %r8d
shrl $0x5, %r8d
movq %r9, %r11
notq %r11
movq (%rdi,%r8,8), %r10
movq %r10, %rbx
andq %r11, %rbx
movabsq $0x2aaaaaaaaaaaaaaa, %r14 # imm = ... | /pybind[P]pybind11_abseil/build_O3/_deps/absl-src/absl/debugging/internal/bounded_utf8_length_sequence.h |
test | int test(char *URL)
{
int res;
CURL *curl;
int sdp;
FILE *sdpf = NULL;
struct_stat file_info;
char *stream_uri = NULL;
int request=1;
struct curl_slist *custom_headers=NULL;
if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
fprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MA... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0xc8(%rbp)
movl $0x1, -0xcc(%rbp)
movq $0x0, -0xd8(%rbp)
movl $0x3, %edi
callq 0x1110
cmpl $0x0, %eax
je 0x12ca
movq 0x2d33(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0xd4d(%rip), %rsi # 0x2004
movb $0x0, %... | /lesstif[P]curl/tests/libtest/lib568.c |
main | int main(){
std::chrono::system_clock::time_point up = std::chrono::system_clock::now();
struct sigaction act, old_act;
act.sa_handler = signal_handler;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
act.sa_flags |= SA_INTERRUPT;
if(sigaction(SIGALRM, &act, &old_act) < 0){
fprintf(s... | pushq %rbp
movq %rsp, %rbp
subq $0x940, %rsp # imm = 0x940
movl $0x0, -0x4(%rbp)
callq 0x4080
movq %rax, -0x10(%rbp)
leaq -0x32(%rip), %rax # 0x4910
movq %rax, -0xa8(%rbp)
leaq -0xa8(%rbp), %rdi
addq $0x8, %rdi
callq 0x4520
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
orl $0x20000000, %eax # imm... | /kametan0730[P]my_awesome_bgp/main.cpp |
void log<>(log_level, char const*) | void log(log_level level, const char *format, Args const & ... args){
if(console_mode == 1 and level > log_level::NOTICE){
return;
}
if(level > log_level::TRACE){
return;
}
if(level == log_level::ERROR){
if(log_id == 0xff){
fprintf(stderr, "\e[31m[ERROR] ");
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movzbl 0x3a633(%rip), %eax # 0x40439
cmpl $0x1, %eax
jne 0x5e16
cmpl $0x2, -0x4(%rbp)
jle 0x5e16
jmp 0x5f99
cmpl $0x5, -0x4(%rbp)
jle 0x5e21
jmp 0x5f99
cmpl $0x0, -0x4(%rbp)
jne 0x5ea0
movzbl 0x3a60a(%rip), %eax # 0x40438
c... | /kametan0730[P]my_awesome_bgp/logger.h |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::at(std::__cxx11::basic_string<char, std::char_traits<char>,... | reference at(const typename object_t::key_type& key)
{
// at only works for objects
if (JSON_HEDLEY_LIKELY(is_object()))
{
JSON_TRY
{
return set_parent(m_value.object->at(key));
}
JSON_CATCH (std::out_of_range&)
{
... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x9be0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x6130
jmp 0x6285
movq -0xc0(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x211b0
movq %rax, -0xc8(%rbp)... | /kametan0730[P]my_awesome_bgp/build_O0/json-src/single_include/nlohmann/json.hpp |
void log<unsigned int>(log_level, char const*, unsigned int const&) | void log(log_level level, const char *format, Args const & ... args){
if(console_mode == 1 and level > log_level::NOTICE){
return;
}
if(level > log_level::TRACE){
return;
}
if(level == log_level::ERROR){
if(log_id == 0xff){
fprintf(stderr, "\e[31m[ERROR] ");
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movzbl 0x39f8f(%rip), %eax # 0x40439
cmpl $0x1, %eax
jne 0x64ba
cmpl $0x2, -0x4(%rbp)
jle 0x64ba
jmp 0x6649
cmpl $0x5, -0x4(%rbp)
jle 0x64c5
jmp 0x6649
cmpl $0x0, -0x4(%rbp)
jne 0x654a
movzbl 0x39f66(%rip... | /kametan0730[P]my_awesome_bgp/logger.h |
void log<char*>(log_level, char const*, char* const&) | void log(log_level level, const char *format, Args const & ... args){
if(console_mode == 1 and level > log_level::NOTICE){
return;
}
if(level > log_level::TRACE){
return;
}
if(level == log_level::ERROR){
if(log_id == 0xff){
fprintf(stderr, "\e[31m[ERROR] ");
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movzbl 0x39d9f(%rip), %eax # 0x40439
cmpl $0x1, %eax
jne 0x66aa
cmpl $0x2, -0x4(%rbp)
jle 0x66aa
jmp 0x683f
cmpl $0x5, -0x4(%rbp)
jle 0x66b5
jmp 0x683f
cmpl $0x0, -0x4(%rbp)
jne 0x673f
movzbl 0x39d72(%rip... | /kametan0730[P]my_awesome_bgp/logger.h |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::size() const | size_type size() const noexcept
{
switch (m_type)
{
case value_t::null:
{
// null values are empty
return 0;
}
case value_t::array:
{
// delegate call to array_t::size()
retur... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movzbl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x9, %rax
ja 0x68b7
movq -0x18(%rbp), %rax
leaq 0x247d0(%rip), %rcx # 0x2b04c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, -0x8(%rbp)
... | /kametan0730[P]my_awesome_bgp/build_O0/json-src/single_include/nlohmann/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::operator[](unsigned long) | reference operator[](size_type idx)
{
// implicitly convert null value to an empty array
if (is_null())
{
m_type = value_t::array;
m_value.array = create<array_t>();
assert_invariant();
}
// operator[] only works for arrays
if (JSO... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x21250
testb $0x1, %al
jne 0x68f6
jmp 0x6914
movq -0x70(%rbp), %rax
movb $0x2, (%rax)
callq 0xbaa0
movq -0x70(%rbp), %rdi
movq %rax, 0x8(%rdi)
movl $0x1, %esi
callq 0x9080
movq -0... | /kametan0730[P]my_awesome_bgp/build_O0/json-src/single_include/nlohmann/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::basic_json(nlohmann::basic_json<std::map, std::vector, std:... | basic_json(const basic_json& other)
: m_type(other.m_type)
{
// check of passed value is valid
other.assert_invariant();
switch (m_type)
{
case value_t::object:
{
m_value = *other.m_value.object;
break;
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rcx
movb (%rcx), %cl
movb %cl, (%rax)
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x9080
movq -0x60(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0... | /kametan0730[P]my_awesome_bgp/build_O0/json-src/single_include/nlohmann/json.hpp |
void console<>(char const*) | void console(const char *format, Args const & ... args){
if(console_mode == 0){
return;
}
printf("\e[m");
printf("[CONSOLE] ");
printf(format, args ...);
printf("\n");
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movzbl 0x39566(%rip), %eax # 0x40439
cmpl $0x0, %eax
jne 0x6eda
jmp 0x6f0f
leaq 0x286cd(%rip), %rdi # 0x2f5ae
movb $0x0, %al
callq 0x4070
leaq 0x286c3(%rip), %rdi # 0x2f5b2
movb $0x0, %al
callq 0x4070
movq -0x8(%rbp), %rdi
movb $0x0, %al
call... | /kametan0730[P]my_awesome_bgp/logger.h |
nlohmann::detail::json_sax_dom_parser<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::start_object(unsigne... | bool start_object(std::size_t len)
{
ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len),... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x78(%rbp)
movb $0x1, -0x19(%rbp)
leaq -0x19(%rbp), %rsi
callq 0x1f0b0
movq -0x78(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
ca... | /kametan0730[P]my_awesome_bgp/build_O0/json-src/single_include/nlohmann/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::set_parent(nlohmann::basic_json<std::map, std::vector, std:... | reference set_parent(reference j, std::size_t old_capacity = std::size_t(-1))
{
#if JSON_DIAGNOSTICS
if (old_capacity != std::size_t(-1))
{
// see https://github.com/nlohmann/json/issues/2838
JSON_ASSERT(type() == value_t::array);
if (JSON_HEDLEY_UNLIKELY(m_value.... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /kametan0730[P]my_awesome_bgp/build_O0/json-src/single_include/nlohmann/json.hpp |
bgp_neighbor_route_command(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&, bgp_peer*) | command_result_status bgp_neighbor_route_command(const std::vector<std::string>& command_params, bgp_peer* peer){
size_t param_count = command_params.size();
if(param_count < 5){
return command_result_status::INVALID_PARAMS;
}
node<adj_ribs_in_data>* res = search_prefix(peer->adj_ribs_in, ntohl... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26f40
movq %rax, -0x20(%rbp)
cmpq $0x5, -0x20(%rbp)
jae 0x269e3
movl $0x2, -0x4(%rbp)
jmp 0x26b57
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4,... | /kametan0730[P]my_awesome_bgp/command.cpp |
bgp_command(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&) | command_result_status bgp_command(const std::vector<std::string>& command_params){
size_t param_count = command_params.size();
if(param_count < 2){
return command_result_status::INVALID_PARAMS;
}
if(command_params[1] == "route"){ // bgp route
return bgp_route_command(command_params);
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26f40
movq %rax, -0x18(%rbp)
cmpq $0x2, -0x18(%rbp)
jae 0x26c5c
movl $0x2, -0x4(%rbp)
jmp 0x26cf6
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x27060
movq %rax, %rdi
leaq 0x9240(%rip), %rsi # 0x2feb4
callq 0x6d90
tes... | /kametan0730[P]my_awesome_bgp/command.cpp |
void console<int, unsigned int>(char const*, int const&, unsigned int const&) | void console(const char *format, Args const & ... args){
if(console_mode == 0){
return;
}
printf("\e[m");
printf("[CONSOLE] ");
printf(format, args ...);
printf("\n");
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x1954e(%rip), %rax # 0x40439
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x26ef5
jmp 0x26f36
leaq 0x86b2(%rip), %rdi # 0x2f5ae
movb $0x0, %al
callq 0x4070
leaq 0x86a8(%rip), %rdi # 0x2f5b2
mov... | /kametan0730[P]my_awesome_bgp/logger.h |
void console<char [16], unsigned char, unsigned char, char [16], unsigned int, unsigned int>(char const*, char const (&) [16], unsigned char const&, unsigned char const&, char const (&) [16], unsigned int const&, unsigned int const&) | void console(const char *format, Args const & ... args){
if(console_mode == 0){
return;
}
printf("\e[m");
printf("[CONSOLE] ");
printf(format, args ...);
printf("\n");
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x1938e(%rip), %rax # 0x40439
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x270b5
jmp 0x27110
leaq 0x84f2(%rip), %... | /kametan0730[P]my_awesome_bgp/logger.h |
node<adj_ribs_in_data>* search_prefix<adj_ribs_in_data>(node<adj_ribs_in_data>*, unsigned int, unsigned char, bool) | node<DATA_TYPE>* search_prefix(node<DATA_TYPE>* root, uint32_t address, uint8_t max_prefix_len = 32, bool is_prefix_strict = false){
node<DATA_TYPE>* current = root;
node<DATA_TYPE>* next = nullptr;
node<DATA_TYPE>* match_node = root;
uint8_t i = 0;
while(i < max_prefix_len){
next = (check_b... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb %cl, -0x15(%rbp)
andb $0x1, %al
movb %al, -0x16(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movzb... | /kametan0730[P]my_awesome_bgp/tree.h |
node<adj_ribs_in_data>* add_prefix<adj_ribs_in_data>(node<adj_ribs_in_data>*, unsigned int, unsigned char, adj_ribs_in_data, bool*) | node<DATA_TYPE>* add_prefix(node<DATA_TYPE>* root, uint32_t prefix, uint8_t prefix_len, DATA_TYPE data, bool* is_updated = nullptr){
node<DATA_TYPE>* current = search_prefix(root, prefix, prefix_len-1);
uint8_t current_prefix_len = current->prefix_len;
#ifdef TEST_RIB_TREE_TEST_TREE
printf("Get prefix: %d\n... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
leaq 0x10(%rbp), %rdx
movq %rdx, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movzbl -0xd(%rbp), %eax
subl $0x1, %eax
xorl %ecx, %ecx
movzbl %al, %edx
callq 0x2719... | /kametan0730[P]my_awesome_bgp/tree.h |
main | int main(int argc, char **argv)
{
// Sets the log level to DEBUG
logger.setLevel(ERROR);
try
{
// Create (sample, signal) vectors
std::vector<double> x,y;
// Read in (sample, signal) = (x,y) values
IO::readData<double>(argv[1],x);
IO::readData<double>(argv[2],y);
// Create options f... | pushq %r14
pushq %rbx
subq $0xa98, %rsp # imm = 0xA98
movq %rsi, %rbx
leaq 0x44d3c(%rip), %rax # 0x7c18c
movl $0x4, 0x4(%rax)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq 0x8(%rbx), %rdi
callq 0x375c2
movq 0x10(%rbx), ... | /rkwitt[P]polyran/src/fit.cpp |
PolyFit<double>::PolyFit(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, PolyFit<double>::Options&) | PolyFit(std::vector<T> &x, std::vector<T> &y, Options &options):
x(x), y(y), options(options)
{
if (!x.size() || !y.size() || (x.size() != y.size()))
{
logger.log(ERROR, "[%s]: Size mismatch (%d,%d)\n",
__func__, x.size(), y.size());
throw std::exception();
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
callq 0x38196
leaq 0x9c8(%r14), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x9c8(%r14)
movq %rbp, 0x9d8(%r14)
movq %r13, 0x9e0(%r14)
leaq 0x9e8(%r14), %r15
movups %xmm0, 0x9e8(%r14)
an... | /rkwitt[P]polyran/src/polyfit.h |
PolyFit<double>::solveRLS() | void solveRLS(void)
{
std::vector<int> bestSubset;
Eigen::Matrix<T, Eigen::Dynamic, 1> bestCoef;
// Probability that we can at least choose
// one sample with options.maxMPts free of
// outliers (sugg. by Peter Kovesi's code)
double p = 0.99;
int trialCount = 0; int... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x20(%rsp), %rax
movaps %xmm0, (%rax)
leaq 0x9c8(%rdi), %rax
movq %rax, 0x18(%rsp)
pushq $0x1
popq %rbp
leaq 0x447f4(%rip), %r13 ... | /rkwitt[P]polyran/src/polyfit.h |
PolyFit<double>::dataToEigen() | void dataToEigen(void)
{
xM.resize(static_cast<int>(x.size()),1);
yM.resize(static_cast<int>(y.size()),1);
for (int i=0;i<static_cast<int>(x.size()); ++i)
xM(i,0) = x[i];
for (int i=0;i<static_cast<int>(y.size()); ++i)
yM(i,0) = y[i];
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9e8(%rdi), %r15
movq 0x9d8(%rdi), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x3, %rcx
movslq %ecx, %rsi
pushq $0x1
popq %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x38222
leaq 0x9f8(%rbx), %r14
movq 0x9e0(%rbx), %rax
movq 0x8(%rax), %... | /rkwitt[P]polyran/src/polyfit.h |
PolyFit<double>::dataToEigenSubset(std::set<int, std::less<int>, std::allocator<int>>&) | void dataToEigenSubset(std::set<int> &indexSet)
{
int nVal = static_cast<int>(indexSet.size());
xM.resize(nVal,1);
yM.resize(nVal,1);
int cnt = 0;
std::set<int>::iterator it = indexSet.begin();
while (it != indexSet.end())
{
xM(cnt,0) = x[*it];
yM(c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x28(%rsi), %r13
leaq 0x9e8(%rdi), %r15
pushq $0x1
popq %rbp
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x38222
leaq 0x9f8(%r14), %r12
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x38... | /rkwitt[P]polyran/src/polyfit.h |
logging::log(loglevel, char const*, ...) | void logging::log(loglevel level, const char* fmt, ... ) {
// Save some statistics
if(level == ERROR)
cntErrors++;
if(level == WARNING)
cntWarnings++;
// Check if level suffices...
if( ! doPrint(level) )
return;
// Default output of log message
std::ostream & os = level >= INFO ? std::cerr : std::cout... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4d0, %rsp # imm = 0x4D0
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x51d96
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %x... | /rkwitt[P]polyran/src/logging.cpp |
MDPSolver::LoadQTables(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, std::vector<QTable, std::allocator<QTable>>&) | void MDPSolver::LoadQTables(const string &filename, int nrTables,
QTables &Qs)
{
QTable::Load(filename,
GetPU()->GetNrStates(),
GetPU()->GetNrJointActions(),
nrTables,
Qs);
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x71ff40
movq %rax, %rdi
callq 0x6da210
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x71ff40
movq %rax, %rdi
callq 0x6ded80
... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/planning/MDPSolver.cpp |
PlanningUnitMADPDiscrete::GetTransitionModelDiscretePtr() const | const TransitionModelDiscrete* GetTransitionModelDiscretePtr() const
{
#if 0
std::cerr <<
"GetTransitionModelDiscretePtr deprecated, use GetProblem->GetTGet()"
<<std::endl;
#endif
return(GetMADPDI()->GetTransitionModelDiscretePtr());
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x6e3ed0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x130(%rax)
popq %rcx
retq
nopl (%rax)
| /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/planning/../../src/support/PlanningUnitMADPDiscrete.h |
void MDPValueIteration::Plan<boost::numeric::ublas::matrix<double, boost::numeric::ublas::basic_row_major<unsigned long, long>, boost::numeric::ublas::unbounded_array<double, std::allocator<double>>>>(std::vector<boost::numeric::ublas::matrix<double, boost::numeric::ublas::basic_row_major<unsigned long, long>, boost::n... | void MDPValueIteration::Plan(std::vector<const M*> T)
{
size_t horizon = GetPU()->GetHorizon();
size_t nrS = GetPU()->GetNrStates();
size_t nrJA = GetPU()->GetNrJointActions();
Index sI,ssucI;
double gamma=GetPU()->GetDiscount();
double R_i,R_f,maxQsuc;
// cache immediate reward f... | subq $0x348, %rsp # imm = 0x348
movq %rsi, 0x120(%rsp)
movq %rdi, 0x340(%rsp)
movq %rsi, 0x338(%rsp)
movq 0x340(%rsp), %rdi
movq %rdi, 0x128(%rsp)
callq 0x71ff40
movq %rax, %rdi
callq 0x730020
movq 0x128(%rsp), %rdi
movq %rax, 0x330(%rsp)
callq 0x71ff40
movq %rax, %rdi
callq 0x6da210
movq 0x128(%rsp), %rdi
m... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/planning/MDPValueIteration.cpp |
boost::numeric::ublas::compressed_matrix<double, boost::numeric::ublas::basic_row_major<unsigned long, long>, 0ul, boost::numeric::ublas::unbounded_array<unsigned long, std::allocator<unsigned long>>, boost::numeric::ublas::unbounded_array<double, std::allocator<double>>>::const_iterator2::operator==(boost::numeric::ub... | BOOST_UBLAS_INLINE
bool operator == (const const_iterator2 &it) const {
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
// BOOST_UBLAS_CHECK (rank_ == it.rank_, internal_logic ());
if (rank_ == 1 || it.rank_ == 1) {
return it_... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpl $0x1, 0x8(%rax)
je 0x779de5
movq -0x18(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x779e02
movq -0x20(%rsp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x28(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/planning/../../src/boost/boost/numeric/ublas/matrix_sparse.hpp |
MDPPolicyIteration::Initialize() | void MDPPolicyIteration::Initialize()
{
StartTimer("Initialize");
size_t horizon = GetPU()->GetHorizon();
size_t nrS = GetPU()->GetNrStates();
size_t nrJA = GetPU()->GetNrJointActions();
size_t nrQfunctions;
if(horizon==MAXHORIZON)
{
_m_finiteHorizon=false;
nrQfunctions=1... | subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x10, %rax
movq %rax, 0x20(%rsp)
leaq 0xcf(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x720440
movq 0x28(%rsp), %rdx
leaq 0x341795(%rip), %rsi # 0xabd8d8
leaq 0xd0(%rsp), %rdi
callq 0x72ccc0
jmp 0x77c152
movq 0x20(%rsp), %rdi
leaq ... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/planning/MDPPolicyIteration.cpp |
BayesianGameWithClusterInfo::BayesianGameWithClusterInfo(PlanningUnitDecPOMDPDiscrete const*, QFunctionJAOHInterface const*, unsigned int, boost::shared_ptr<BayesianGameWithClusterInfo const> const&, boost::shared_ptr<JointPolicyDiscretePure const> const&, unsigned long, std::vector<unsigned long, std::allocator<unsign... | BayesianGameWithClusterInfo::BayesianGameWithClusterInfo(
const PlanningUnitDecPOMDPDiscrete* pu,
const QFunctionJAOHInterface* q,
Index t,
const BGwCI_constPtr &prevBG,
const boost::shared_ptr<const JointPolicyDiscretePure> &prevJPolBG,
size_t nrAgents,
... | subq $0xb8, %rsp
movl 0xd8(%rsp), %eax
movq 0xd0(%rsp), %rax
movq 0xc8(%rsp), %rax
movq 0xc0(%rsp), %rax
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movl %ecx, 0x9c(%rsp)
movq %r8, 0x90(%rsp)
movq %r9, 0x88(%rsp)
vmovsd %xmm0, 0x80(%rsp)
vmovsd %xmm1, 0x78(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/planning/BayesianGameWithClusterInfo.cpp |
BayesianGameWithClusterInfo::BayesianGameWithClusterInfo(BayesianGameWithClusterInfo const&) | BayesianGameWithClusterInfo::BayesianGameWithClusterInfo(const BayesianGameWithClusterInfo& o) :
BayesianGameForDecPOMDPStage( o )
{
_m_pBG = o._m_pBG;
_m_qJB = o._m_qJB;
_m_qHybrid = o._m_qHybrid;
_m_pBGJPol = o._m_pBGJPol;
_m_jaohReps = o._m_jaohReps;
_m_clusterAlgorithm = o._m_cluster... | subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xe0(%rsp), %rdi
movq %rdi, 0x88(%rsp)
movq 0xd8(%rsp), %rsi
callq 0x731e00
movq 0x88(%rsp), %rdi
movq 0x4941c5(%rip), %rax # 0xc4fc38
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, (%rdi)
addq $0x60, %rax
movq %rax, 0x20(%rdi)
addq $0x150, %rdi ... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/planning/BayesianGameWithClusterInfo.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> PrintTools::SoftPrintVector<unsigned int>(std::vector<unsigned int, std::allocator<unsigned int>> const&) | static std::string SoftPrintVector(const std::vector<T> &v)
{
std::stringstream ss;
typename std::vector<T>::const_iterator it = v.begin();
typename std::vector<T>::const_iterator last = v.end();
ss << "< ";
while(it != last)
{
if(it != v.begin())
ss << ", ";
ss <<... | subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x6e8d80
movq 0x1f8(%rsp), %rdi
callq 0x6db590
movq %rax, 0x68(%rsp)
movq 0x1f8(%rsp), %rdi
callq 0x72e340
movq %rax, 0x60(%rsp)
leaq 0x80(%rsp... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/planning/../../src/base/PrintTools.h |
BayesianGameWithClusterInfo::SoftPrint[abi:cxx11](BayesianGameWithClusterInfo::BGClusterAlgorithm) | string BayesianGameWithClusterInfo::SoftPrint(BGClusterAlgorithm clusterAlg)
{
switch(clusterAlg)
{
case Lossless:
return("Lossless");
case ApproxJB:
return("ApproxJB");
case ApproxPjaoh:
return("ApproxPjaoh");
case ApproxPjaohJB:
return("ApproxPjaohJB");
}
... | subq $0x68, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
movq %rax, 0x40(%rsp)
subq $0x3, %rax
ja 0x7c1ad8
movq 0x40(%rsp), %rax
leaq 0x2fdebf(%rip), %rcx # 0xabf848
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5b(%... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/planning/BayesianGameWithClusterInfo.cpp |
JointPolicyPureVectorForClusteredBG::ToJointPolicyPureVector() const | JPPV_sharedPtr
JointPolicyPureVectorForClusteredBG::ToJointPolicyPureVector() const
{
#if DEBUG_TOJPPV
cout << ">>>JointPolicyPureVectorForClusteredBG::ToJointPolicyPureVector() started"<<endl;
#endif
const PlanningUnitDecPOMDPDiscrete* pu = _m_bg->GetPUDecPOMDPDiscrete();
JPPV_sharedPtr jppv =
JP... | subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, 0x88(%rsp)
movq %rdi, %rax
movq %rax, 0x90(%rsp)
movq %rdi, 0x1a0(%rsp)
movq %rsi, 0x198(%rsp)
movq 0x198(%rsp), %rdi
movq %rdi, 0x98(%rsp)
addq $0x88, %rdi
callq 0x717690
movq %rax, %rdi
callq 0x7191c0
movq %rax, 0x190(%rsp)
movb $0x0, 0x18f(%rsp)
movl $0x98, %edi
... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/planning/JointPolicyPureVectorForClusteredBG.cpp |
JointPolicyPureVectorForClusteredBG::StartRecursiveConstructionPerAgent(PlanningUnitDecPOMDPDiscrete const*, boost::shared_ptr<JointPolicyPureVector>, unsigned int, std::vector<JointPolicyDiscretePure const*, std::allocator<JointPolicyDiscretePure const*>> const&, std::vector<boost::shared_ptr<BayesianGameWithClusterIn... | void
JointPolicyPureVectorForClusteredBG::StartRecursiveConstructionPerAgent(
const PlanningUnitDecPOMDPDiscrete* pu,
JPPV_sharedPtr jpolJPPV,
Index ts,
const vector<const JointPolicyDiscretePure*> & jpolBGVec,
const vector<boost::shared_ptr<const BayesianGameWithClusterInfo> >... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdx, -0x130(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movl %ecx, -0x3c(%rbp)
movq %r8, -0x48(%rbp)
movq %r9, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x128(%rbp)... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/planning/JointPolicyPureVectorForClusteredBG.cpp |
JointPolicyPureVectorForClusteredBG::RecursivelyFillPolicyForAgent(PlanningUnitDecPOMDPDiscrete const*, boost::shared_ptr<JointPolicyPureVector>, unsigned int, unsigned int, unsigned int, unsigned int, TypeCluster const*, unsigned int, unsigned int, std::vector<JointPolicyDiscretePure const*, std::allocator<JointPolicy... | void
JointPolicyPureVectorForClusteredBG::RecursivelyFillPolicyForAgent(
const PlanningUnitDecPOMDPDiscrete* pu,
JPPV_sharedPtr jpolJPPV,
Index agI,
Index ts,
Index aohI,
Index ohI,
const TypeCluster* tc,
Index tI,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdx, 0x88(%rsp)
movq 0x178(%rsp), %rax
movq 0x170(%rsp), %rax
movl 0x168(%rsp), %eax
movl 0x160(%rsp), %eax
movq 0x158(%rsp), %rax
movl 0x150(%rsp), %eax
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movl... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/planning/JointPolicyPureVectorForClusteredBG.cpp |
JointPolicyPureVectorForClusteredBG::SoftPrint[abi:cxx11]() const | string JointPolicyPureVectorForClusteredBG::SoftPrint() const
{
cout << "JointPolicyPureVectorForClusteredBG:SoftPrint"<<endl;
size_t depth = GetDepth();
stringstream ss;
ss << "JointPolicyPureVectorForClusteredBG, depth "
<< GetDepth() << endl;
if(depth == 0)
{
ss << "empty poli... | subq $0x3d8, %rsp # imm = 0x3D8
movq %rdi, 0x108(%rsp)
movq %rdi, %rax
movq %rax, 0x110(%rsp)
movq %rdi, 0x3d0(%rsp)
movq %rsi, 0x3c8(%rsp)
movq 0x3c8(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0x486047(%rip), %rdi # 0xc4f1c8
leaq 0x2f6bbd(%rip), %rsi # 0xabfd45
callq 0x6fb6a0
movq %rax, %rdi
movq 0x486a1... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/planning/JointPolicyPureVectorForClusteredBG.cpp |
JointPolicyPureVectorForClusteredBG::SoftPrintBrief[abi:cxx11]() const | string JointPolicyPureVectorForClusteredBG::SoftPrintBrief() const
{
if(JointPolicyDiscretePure::GetInterfacePTPDiscretePureShared() == 0 &&
JointPolicyDiscretePure::GetInterfacePTPDiscretePure() == 0)
throw E("JointPolicyPureVectorForClusteredBG:SoftPrintBrief - Error!!! PTPDP==0");
... | subq $0x228, %rsp # imm = 0x228
movq %rdi, 0x50(%rsp)
movq %rdi, %rax
movq %rax, 0x58(%rsp)
movq %rdi, 0x220(%rsp)
movq %rsi, 0x218(%rsp)
movq 0x218(%rsp), %rsi
movq %rsi, 0x60(%rsp)
leaq 0x208(%rsp), %rdi
callq 0x704b20
leaq 0x208(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6e9e10
movb %al, %cl
xorl... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/planning/JointPolicyPureVectorForClusteredBG.cpp |
boost::shared_ptr<BayesianGameWithClusterInfo const> boost::dynamic_pointer_cast<BayesianGameWithClusterInfo const, BayesianGameIdenticalPayoffInterface const>(boost::shared_ptr<BayesianGameIdenticalPayoffInterface const> const&) | shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> const & r ) BOOST_NOEXCEPT
{
(void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
typedef typename shared_ptr<T>::element_type E;
E * p = dynamic_cast< E* >( r.get() );
return p? shared_ptr<T>( r, p ): shared_ptr<T>();
} | subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb $0x1, %al
testb $0x1, %al
jne 0x7caabf
xorl %eax, %eax
movl %eax, %edi
movq 0x4841e4(%rip), %rsi # 0xc4ec90
movq 0x48419d(%rip), %rdx # 0xc4ec50
movl $0x20, %ecx
callq 0x720010
jmp 0x7caac... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/planning/../../src/boost/boost/smart_ptr/shared_ptr.hpp |
JointPolicyDiscretePure::GetInterfacePTPDiscretePure() const | const Interface_ProblemToPolicyDiscretePure*
GetInterfacePTPDiscretePure() const
{
const Interface_ProblemToPolicyDiscrete* p =
GetInterfacePTPDiscrete();
const Interface_ProblemToPolicyDiscretePure* pp =
dynamic_cast<const Interface_ProblemT... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x6f6de0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x7cb07a
movq 0x8(%rsp), %rdi
movq 0x484bb4(%rip), %rsi # 0xc4fc18
movq 0x484dd5(%rip), %rdx # 0xc4fe40
xorl %eax, %eax
movl %eax, %ecx
callq 0x720010
mov... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/planning/../../src/support/JointPolicyDiscretePure.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.