name string | code string | asm string | file string |
|---|---|---|---|
mbedtls_pk_verify_ext | int mbedtls_pk_verify_ext( mbedtls_pk_type_t type, const void *options,
mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
const unsigned char *sig, size_t sig_len )
{
if( ctx == NULL || ctx->pk_info == NULL )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0xffffc180, %r13d # imm = 0xFFFFC180
testq %rdx, %rdx
je 0x339d1
movq %rdx, %rbx
movq %r8, 0x10(%rsp)
movq (%rdx), %rax
testq %rax, %rax
je 0x339d1
movq %r9, %r12
movl %ecx, %ebp
movq %rsi, %r14
movl %edi, %r15d
movq 0x58(%rsp... | /project-everest[P]mbedtls/library/pk.c |
mbedtls_pk_sign | int mbedtls_pk_sign( mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
unsigned char *sig, size_t *sig_len,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
if( ctx == NULL || ctx->pk_info == NULL ||
pk_hashlen... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movl $0xffffc180, %r12d # imm = 0xFFFFC180
testq %rdi, %rdi
je 0x33a58
movq %rdi, %r13
cmpq $0x0, (%rdi)
je 0x33a58
movq %r9, %rbx
movq %r8, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rsp, %rsi
movl %ebp, %edi
callq 0x33... | /project-everest[P]mbedtls/library/pk.c |
mbedtls_pk_decrypt | int mbedtls_pk_decrypt( mbedtls_pk_context *ctx,
const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen, size_t osize,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
if( ctx == NULL || ctx->pk_info == NULL )
return( MBEDTL... | movl $0xffffc180, %eax # imm = 0xFFFFC180
testq %rdi, %rdi
je 0x33ac8
movq (%rdi), %r10
testq %r10, %r10
je 0x33ac8
movq 0x30(%r10), %rax
testq %rax, %rax
je 0x33ac3
movq 0x8(%rdi), %rdi
jmpq *%rax
movl $0xffffc100, %eax # imm = 0xFFFFC100
retq
| /project-everest[P]mbedtls/library/pk.c |
mbedtls_pk_encrypt | int mbedtls_pk_encrypt( mbedtls_pk_context *ctx,
const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen, size_t osize,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
if( ctx == NULL || ctx->pk_info == NULL )
return( MBEDTL... | movl $0xffffc180, %eax # imm = 0xFFFFC180
testq %rdi, %rdi
je 0x33aef
movq (%rdi), %r10
testq %r10, %r10
je 0x33aef
movq 0x38(%r10), %rax
testq %rax, %rax
je 0x33aea
movq 0x8(%rdi), %rdi
jmpq *%rax
movl $0xffffc100, %eax # imm = 0xFFFFC100
retq
| /project-everest[P]mbedtls/library/pk.c |
mbedtls_pk_check_pair | int mbedtls_pk_check_pair( const mbedtls_pk_context *pub, const mbedtls_pk_context *prv )
{
if( pub == NULL || pub->pk_info == NULL ||
prv == NULL || prv->pk_info == NULL ||
prv->pk_info->check_pair_func == NULL )
{
return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
}
if( prv->pk_info->ty... | movl $0xffffc180, %eax # imm = 0xFFFFC180
testq %rdi, %rdi
je 0x33b44
movq (%rdi), %rcx
testq %rcx, %rcx
sete %dl
testq %rsi, %rsi
sete %r8b
orb %dl, %r8b
jne 0x33b44
movq (%rsi), %r8
testq %r8, %r8
je 0x33b44
movq 0x40(%r8), %rdx
testq %rdx, %rdx
je 0x33b44
cmpl $0x5, (%r8)
jne 0x33b3a
movl $0xffffc100, %eax ... | /project-everest[P]mbedtls/library/pk.c |
mbedtls_pk_debug | int mbedtls_pk_debug( const mbedtls_pk_context *ctx, mbedtls_pk_debug_item *items )
{
if( ctx == NULL || ctx->pk_info == NULL )
return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
if( ctx->pk_info->debug_func == NULL )
return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
ctx->pk_info->debug_func( ctx->pk_ctx, ite... | movl $0xffffc180, %eax # imm = 0xFFFFC180
testq %rdi, %rdi
je 0x33b84
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x33b84
movq 0x58(%rcx), %rax
testq %rax, %rax
je 0x33b85
pushq %rax
movq 0x8(%rdi), %rdi
callq *%rax
xorl %eax, %eax
addq $0x8, %rsp
retq
movl $0xffffc100, %eax # imm = 0xFFFFC100
retq
| /project-everest[P]mbedtls/library/pk.c |
OpenMD::TruncatedCube::TruncatedCube(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int) | TruncatedCube(std::string lattice, int cells, int planes) :
Cuboctahedron(lattice, cells, planes) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x185b0
movq %rbx, %rdi
movq %r15, %rsi
movl ... | /OpenMD[P]OpenMD/src/clusters/Cuboctahedron.hpp |
OpenMD::Cuboctahedron::~Cuboctahedron() | virtual ~Cuboctahedron() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x113455(%rip), %rax # 0x12b9a0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x18567
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x12430
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x1857c
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x12430
movq 0x8(%rbx)... | /OpenMD[P]OpenMD/src/clusters/Cuboctahedron.hpp |
cmdline_parser2 | int
cmdline_parser2 (int argc, char **argv, struct gengetopt_args_info *args_info, int override, int initialize, int check_required)
{
int result;
struct cmdline_parser_params params;
params.override = override;
params.initialize = initialize;
params.check_required = check_required;
params.check_ambiguit... | subq $0x18, %rsp
leaq 0x4(%rsp), %rax
movl %ecx, (%rax)
movl %r8d, 0x4(%rax)
movl %r9d, 0x8(%rax)
movabsq $0x100000000, %rcx # imm = 0x100000000
movq %rcx, 0xc(%rax)
movq %rax, %rcx
callq 0x18d6b
addq $0x18, %rsp
retq
| /OpenMD[P]OpenMD/src/applications/nanoparticleBuilder/icosahedralBuilderCmd.cpp |
OpenMD::SimplePreprocessor::doPreprocess(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, std::ostream&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, s... | bool doPreprocess(std::istream& myStream, const std::string& filename, int startingLine, ostream& os, std::set<std::string>& defineSet, std::stack<bool>& ifStates) {
//std::ifstream input(filename.c_str());
//if (!input.is_open()) {
// std::stringstream ss;
// ss <<... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x24c8, %rsp # imm = 0x24C8
movq %r9, %r15
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %r12
leaq 0xca304(%rip), %rsi # 0xe82d0
movl $0x6, %edx
movq %r8, %rdi
callq 0x12500
movq %r14, %rdi
movl %ebp, %esi
callq 0x12810
mo... | /OpenMD[P]OpenMD/src/mdParser/SimplePreprocessor.hpp |
OpenMD::SimInfo::prepareTopology() | void SimInfo::prepareTopology() {
// calculate mass ratio of cutoff group
SimInfo::MoleculeIterator mi;
Molecule* mol;
Molecule::CutoffGroupIterator ci;
CutoffGroup* cg;
Molecule::AtomIterator ai;
Atom* atom;
RealType totalMass;
/**
* The mass factor is the relative mass of an ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x168(%rdi), %r14
movq 0x168(%rdi), %rax
cmpq %rax, 0x170(%rdi)
je 0x231b1
movq %rax, 0x170(%rbx)
movl 0x28(%rbx), %esi
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x8(%rsp), %rdx
movq %rax, (%r... | /OpenMD[P]OpenMD/src/brains/SimInfo.cpp |
OpenMD::DumpReader::parseDumpLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void DumpReader::parseDumpLine(const std::string& line) {
StringTokenizer tokenizer(line);
int nTokens;
nTokens = tokenizer.countTokens();
if (nTokens < 2) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
"DumpReader Error: Not enough Tokens.\n%s\n", line.c_str());
pain... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x70(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc19cf(%rip), %rsi # 0xe82da
leaq 0xc19cd(%rip), %rdx # 0xe82df
leaq 0x60(%rsp), %rdi
callq 0x1eea8
leaq 0xb0(%rsp), %rd... | /OpenMD[P]OpenMD/src/io/DumpReader.cpp |
OpenMD::basic_teebuf<char, std::char_traits<char>>::overflow(int) | int_type overflow(int_type c = traits_type::eof()) {
// avoid writing eof to stream
if (c == traits_type::eof()) { return traits_type::eof(); }
typename std::vector<streambuf_type*>::iterator
iter; // typename is needed since it's a dependant name
for (iter = buffers_.begin(); iter !... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
cmpl $-0x1, %esi
je 0x2a016
movl %esi, %ebp
movq %rdi, %r14
movq 0x40(%rdi), %r12
cmpq 0x48(%rdi), %r12
je 0x2a014
movzbl %bpl, %r15d
movq (%r12), %rdi
movq 0x28(%rdi), %rax
cmpq 0x30(%rdi), %rax
jae 0x2a004
movb %bpl... | /OpenMD[P]OpenMD/src/io/basic_teebuf.hpp |
antlr::LexerInputState::~LexerInputState() | virtual ~LexerInputState()
{
if (inputResponsible)
delete input;
} | pushq %rbx
movq %rdi, %rbx
leaq 0xfd215(%rip), %rax # 0x1284d0
movq %rax, (%rdi)
cmpb $0x1, 0x48(%rdi)
jne 0x2b2d3
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x2b2d3
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rdi
addq $0x30, %rbx
cmpq %rbx, %rdi
je 0x2b2ec
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x12430
... | /OpenMD[P]OpenMD/src/antlr/LexerSharedInputState.hpp |
antlr::TokenBuffer::LT(unsigned int) | RefToken TokenBuffer::LT(unsigned int i)
{
fill(i);
return queue.elementAt(markerOffset+i-1);
} | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x2b36c
movl 0x14(%r15), %eax
addl %r14d, %eax
decl %eax
movq 0x38(%r15), %rcx
shlq $0x3, %rcx
addq 0x20(%r15), %rcx
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x2b4eb
incl 0x8(%rax)
movq %rax, (%rb... | /OpenMD[P]OpenMD/src/antlr/TokenBuffer.cpp |
antlr::TokenStreamRecognitionException::~TokenStreamRecognitionException() | virtual ~TokenStreamRecognitionException() throw()
{
} | pushq %rbx
movq %rdi, %rbx
leaq 0xf6b4d(%rip), %rax # 0x1287a0
movq %rax, (%rdi)
addq $0x28, %rdi
callq 0x1fd36
leaq 0xf6572(%rip), %rax # 0x1281d8
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x31c82
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x12430
popq %rbx
retq
| /OpenMD[P]OpenMD/src/antlr/TokenStreamRecognitionException.hpp |
void OpenMD::DataHolder::assign<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | void assign(const std::string& keyword, T val) {
ParamMap::iterator i = parameters_.find(keyword);
if (i != parameters_.end()) {
bool result = i->second->setData(val);
if (!result) {
std::stringstream ss;
ss << "Error in parsing " << keyword << ": expected "
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, 0xc(%rsp)
addq $0x8, %rdi
callq 0x4d63c
movq %rax, %r14
leaq 0x10(%r15), %rax
cmpq %rax, %r14
je 0x4bb6c
movq 0x40(%r14), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x20(%... | /OpenMD[P]OpenMD/src/types/DataHolder.hpp |
void OpenMD::DataHolder::assign<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double) | void assign(const std::string& keyword, T val) {
ParamMap::iterator i = parameters_.find(keyword);
if (i != parameters_.end()) {
bool result = i->second->setData(val);
if (!result) {
std::stringstream ss;
ss << "Error in parsing " << keyword << ": expected "
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rsi, %rbx
movq %rdi, %r15
movsd %xmm0, 0x20(%rsp)
movsd %xmm0, 0x28(%rsp)
addq $0x8, %rdi
callq 0x4d63c
movq %rax, %r14
leaq 0x10(%r15), %rax
cmpq %rax, %r14
je 0x4be24
movq 0x40(%r14), %rdi
movq (%rdi), %rax
movsd 0x20(%rsp), ... | /OpenMD[P]OpenMD/src/types/DataHolder.hpp |
void OpenMD::DataHolder::assign<std::vector<double, std::allocator<double>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<double, std::allocator<double>>) | void assign(const std::string& keyword, T val) {
ParamMap::iterator i = parameters_.find(keyword);
if (i != parameters_.end()) {
bool result = i->second->setData(val);
if (!result) {
std::stringstream ss;
ss << "Error in parsing " << keyword << ": expected "
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
addq $0x8, %rdi
callq 0x4d63c
movq %rax, %r15
leaq 0x10(%r12), %rax
cmpq %rax, %r15
je 0x4c415
movq 0x40(%r15), %r12
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %rb... | /OpenMD[P]OpenMD/src/types/DataHolder.hpp |
OpenMD::BendStamp::setMembers(std::vector<int, std::allocator<int>> const&) | void setMembers(const std::vector<int>& members) {
members_ = members;
if (members_.size() < 2 || members_.size() > 3) {
std::ostringstream oss;
oss << "members" << containerToString(members) << " is invalid"
<< std::endl;
throw OpenMDException(oss.str());
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rsi, %rbx
movq %rdi, %r14
addq $0x98, %rdi
callq 0x20844
movq 0xa0(%r14), %rax
subq 0x98(%r14), %rax
andq $-0x8, %rax
cmpq $0x8, %rax
jne 0x4cae5
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rb... | /OpenMD[P]OpenMD/src/types/BendStamp.hpp |
OpenMD::Thermo::getElectronicKinetic() | RealType Thermo::getElectronicKinetic() {
Snapshot* snap = info_->getSnapshotManager()->getCurrentSnapshot();
if (!snap->hasElectronicKineticEnergy) {
SimInfo::MoleculeIterator miter;
vector<Atom*>::iterator iiter;
Molecule* mol;
Atom* atom;
RealType cvel;
RealType cmass;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x2f8(%rdi), %rax
movq 0x18(%rax), %rbx
cmpb $0x0, 0xa73(%rbx)
jne 0x4db64
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
callq 0x22a2e
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0x4db5c
leaq 0x8(%rsp), %r15
movq 0x100(%rax), %rcx
movq 0x108(%... | /OpenMD[P]OpenMD/src/brains/Thermo.cpp |
OpenMD::Thermo::getTemperature() | RealType Thermo::getTemperature() {
Snapshot* snap = info_->getSnapshotManager()->getCurrentSnapshot();
if (!snap->hasTemperature) {
RealType nuclearKE =
this->getTranslationalKinetic() + this->getRotationalKinetic();
RealType temperature {};
// With no degrees of freedom, T is no... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rax
movq 0x2f8(%rax), %rax
movq 0x18(%rax), %rbx
cmpb $0x0, 0xa7f(%rbx)
jne 0x4dc96
movq %rdi, %r14
callq 0x4d6c8
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x4d7d6
movsd %xmm0, 0x8(%rsp)
movq (%r14), %rdi
movl 0x80(%rdi), %ebp
callq 0x22bb2
xorpd %xmm0, %x... | /OpenMD[P]OpenMD/src/brains/Thermo.cpp |
OpenMD::Thermo::getComAll(OpenMD::Vector3<double>&, OpenMD::Vector3<double>&) | void Thermo::getComAll(Vector3d& com, Vector3d& comVel) {
Snapshot* snap = info_->getSnapshotManager()->getCurrentSnapshot();
if (!(snap->hasCOM && snap->hasCOMvel)) {
SimInfo::MoleculeIterator i;
Molecule* mol;
RealType totalMass(0.0);
com = 0.0;
comVel = 0.0;
for (mo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
movq 0x2f8(%rdi), %rax
movq 0x18(%rax), %r13
cmpb $0x1, 0xa83(%r13)
jne 0x4ff9f
cmpb $0x0, 0xa84(%r13)
jne 0x50135
movq %r13, 0x30(%rsp)
xorl %eax, %eax
leaq 0x38(%rsp), %... | /OpenMD[P]OpenMD/src/brains/Thermo.cpp |
OpenMD::Thermo::getHullVolume() | RealType Thermo::getHullVolume() {
#ifdef HAVE_QHULL
Snapshot* snap = info_->getSnapshotManager()->getCurrentSnapshot();
if (!snap->hasHullVolume) {
Hull* surfaceMesh_;
Globals* simParams = info_->getSimParams();
const std::string ht = simParams->getHULL_Method();
if (ht == "Convex")... | xorps %xmm0, %xmm0
retq
| /OpenMD[P]OpenMD/src/brains/Thermo.cpp |
antlr::CharBuffer::getChar() | int CharBuffer::getChar()
{
// try {
return input.get();
// }
// catch (ANTLR_USE_NAMESPACE(std)ios_base::failure& e) {
// throw CharStreamIOException(e);
// }
} | movq 0x38(%rdi), %rdi
jmp 0x12550
nop
| /OpenMD[P]OpenMD/src/antlr/CharBuffer.cpp |
antlr::CharBuffer::~CharBuffer() | class ANTLR_API CharBuffer : public InputBuffer {
public:
/// Create a character buffer
CharBuffer( ANTLR_USE_NAMESPACE(std)istream& input );
/// Get the next character from the stream
int getChar();
protected:
private:
// character source
ANTLR_USE_NAMESPACE(std)istream& input;
// NOTE: Unimplemented
CharBu... | pushq %rbx
movq %rdi, %rbx
leaq 0xd72f9(%rip), %rax # 0x128888
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x515ab
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x12430
movl $0x40, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x12430
nop
| /OpenMD[P]OpenMD/src/antlr/CharBuffer.hpp |
OpenMD::Revision::getVersion[abi:cxx11]() | std::string Revision::getVersion() {
std::string v;
v.assign("Version: ");
v.append(version);
return v;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x992cb(%rip), %rcx # 0xeac89
movl $0x9, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x126f0
leaq 0x9925c(%rip), %rsi # 0xeac30
movq %rbx, %rdi
callq 0x128f0
movq %rbx, %rax
po... | /OpenMD[P]OpenMD/build_O3/Revision.cpp |
OpenMD::Revision::getFullRevision[abi:cxx11]() | std::string Revision::getFullRevision() {
std::string fr;
fr.assign(getVersion());
fr.append(", ");
fr.append(getRevision());
return fr;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rdi
callq 0x5199c
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12580
movq (%r14), %rdi
leaq 0x18(%rsp), %r12
cmpq %r12, %rdi
je... | /OpenMD[P]OpenMD/build_O3/Revision.cpp |
antlr::ASTFactory::ASTFactory() | ASTFactory::ASTFactory()
: default_factory_descriptor(ANTLR_USE_NAMESPACE(std)make_pair(CommonAST::TYPE_NAME,&CommonAST::factory))
{
nodeFactories.resize( Token::MIN_USER_TYPE, &default_factory_descriptor );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xd6af5(%rip), %rax # 0x128910
movq %rax, (%rdi)
leaq 0x8(%rdi), %rax
leaq 0xd6b0f(%rip), %rcx # 0x128938
movq (%rcx), %rcx
movq %rcx, 0x8(%rdi)
leaq 0x2b25(%rip), %rcx # 0x5495c
movq %rcx, 0x10(%rdi)
leaq 0x18(%rdi), %r14
xorps %xmm0, ... | /OpenMD[P]OpenMD/src/antlr/ASTFactory.cpp |
antlr::ASTFactory::registerFactory(int, char const*, antlr::ASTRefCount<antlr::AST> (*)()) | void ASTFactory::registerFactory( int type, const char* ast_name, factory_type factory )
{
// check validity of arguments...
if( type < Token::MIN_USER_TYPE )
throw ANTLRException("Internal parser error invalid type passed to RegisterFactory");
if( factory == 0 )
throw ANTLRException("Internal parser error 0 fac... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x3, %esi
jle 0x52005
movq %rcx, %rbx
testq %rcx, %rcx
je 0x5207b
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %r12
movq 0x18(%rdi), %r13
movq 0x20(%rdi), %rcx
subq %r13, %rcx
sarq $0x3, %rcx
leal 0x1(%r14), %eax
cmpq %rax, %rcx
jae... | /OpenMD[P]OpenMD/src/antlr/ASTFactory.cpp |
antlr::ASTFactory::create(antlr::ASTRefCount<antlr::AST>) | RefAST ASTFactory::create(RefAST tr)
{
if (!tr)
return nullAST;
// cout << "create(tr)" << endl;
RefAST t = nodeFactories[tr->getType()]->second();
t->initialize(tr);
return t;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdx), %rax
testq %rax, %rax
je 0x522de
movq (%rax), %rdi
testq %rdi, %rdi
je 0x522de
movq %rdx, %r14
movq %rsi, %r15
movq (%rdi), %rax
callq *0x80(%rax)
cltq
movq 0x18(%r15), %rcx
movq (%rcx,%rax,8), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq (%rb... | /OpenMD[P]OpenMD/src/antlr/ASTFactory.cpp |
antlr::ASTFactory::dup(antlr::ASTRefCount<antlr::AST>) | RefAST ASTFactory::dup(RefAST t)
{
if( t )
return t->clone();
else
return RefAST(nullASTptr);
} | pushq %rbx
movq %rdi, %rbx
movq (%rdx), %rax
testq %rax, %rax
je 0x524b9
movq (%rax), %rsi
testq %rsi, %rsi
je 0x524b9
movq (%rsi), %rax
movq %rbx, %rdi
callq *0x18(%rax)
jmp 0x524d4
leaq 0x98880(%rip), %rax # 0xead40
movq (%rax), %rdi
testq %rdi, %rdi
je 0x524cf
callq 0x53064
jmp 0x524d1
xorl %eax, %eax
movq %rax,... | /OpenMD[P]OpenMD/src/antlr/ASTFactory.cpp |
antlr::ASTFactory::makeASTRoot(antlr::ASTPair&, antlr::ASTRefCount<antlr::AST>) | void ASTFactory::setMaxNodeType( int type )
{
if( nodeFactories.size() < (static_cast<unsigned int>(type)+1) )
nodeFactories.resize( type+1, &default_factory_descriptor );
} | pushq %r14
pushq %rbx
pushq %rax
movq (%rdx), %rax
testq %rax, %rax
je 0x52a7c
movq (%rax), %rdi
testq %rdi, %rdi
je 0x52a7c
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rax
testq %rax, %rax
je 0x52a49
incl 0x8(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movq (%rdi), %rax
callq *0x58(%rax)
movq %rsp, %rdi
callq 0x1d29a
le... | /OpenMD[P]OpenMD/src/antlr/ASTFactory.cpp |
antlr::BaseAST::findAll(antlr::ASTRefCount<antlr::AST>) | vector<RefAST> BaseAST::findAll(RefAST target)
{
ANTLR_USE_NAMESPACE(std)vector<RefAST> roots;
// the empty tree cannot result in an enumeration
if (target) {
doWorkForFindAll(roots,target,false); // find all matches recursively
}
return roots;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rax
testq %rax, %rax
je 0x53993
cmpq $0x0, (%rax)
je 0x53993
incl 0x8(%rax)
movq %rsp, %rdx
movq %rax, (%rdx)
movq %rsi, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x5310a
movq %rsp, %rdi
callq 0... | /OpenMD[P]OpenMD/src/antlr/BaseAST.cpp |
antlr::BaseAST::findAllPartial(antlr::ASTRefCount<antlr::AST>) | vector<RefAST> BaseAST::findAllPartial(RefAST target)
{
ANTLR_USE_NAMESPACE(std)vector<RefAST> roots;
// the empty tree cannot result in an enumeration
if (target)
doWorkForFindAll(roots,target,true); // find all matches recursively
return roots;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rax
testq %rax, %rax
je 0x539fe
cmpq $0x0, (%rax)
je 0x539fe
incl 0x8(%rax)
movq %rsp, %rdx
movq %rax, (%rdx)
movq %rsi, %rdi
movq %rbx, %rsi
movl $0x1, %ecx
callq 0x5310a
movq %rsp, %rdi
callq 0... | /OpenMD[P]OpenMD/src/antlr/BaseAST.cpp |
antlr::ASTRefCount<antlr::BaseAST>::operator=(antlr::ASTRefCount<antlr::BaseAST> const&) | ASTRefCount<T>& operator=(const ASTRefCount<T>& other)
{
if( other.ref != ref )
{
ASTRef* tmp = other.ref ? other.ref->increment() : 0;
if (ref && ref->decrement())
delete ref;
ref=tmp;
}
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %r15
movq (%rdi), %r14
cmpq %r14, %r15
je 0x53eab
testq %r15, %r15
je 0x53e88
incl 0x8(%r15)
testq %r14, %r14
je 0x53ea8
decl 0x8(%r14)
jne 0x53ea8
movq %r14, %rdi
callq 0x53054
movl $0x10, %esi
movq %r14, %rdi
callq 0x12430
movq %r15, (%rbx)
movq %rbx, %rax... | /OpenMD[P]OpenMD/src/antlr/ASTRefCount.hpp |
antlr::BitSet::BitSet(unsigned int) | BitSet::BitSet(unsigned int nbits)
: storage(nbits)
{
for (unsigned int i = 0; i < nbits ; i++ )
storage[i] = false;
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %esi
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x6(%rsp), %rcx
callq 0x542dc
testl %ebx, %ebx
je 0x540af
movq (%r14), %rax
xorl %ecx, %ecx
movl %ecx, %edx
movq $-0x2, %rsi
rolq %cl, %rsi
shrl $0x6, %edx
andq %rsi, (%rax,%rdx,8)
incl %ecx
cmpl... | /OpenMD[P]OpenMD/src/antlr/BitSet.cpp |
antlr::BitSet::BitSet(unsigned long const*, unsigned int) | BitSet::BitSet( const unsigned long* bits_, unsigned int nlongs )
: storage(nlongs*32)
{
for ( unsigned int i = 0 ; i < (nlongs * 32); i++)
storage[i] = (bits_[i>>5] & (1UL << (i&31))) ? true : false;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
shll $0x5, %ebx
leaq 0xf(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0xe(%rsp), %rcx
movq %rbx, %rsi
callq 0x542dc
testl %ebx, %ebx
je 0x5411c
movq (%r15), %rax
xorl %ecx, %ecx
movl %ecx, %edx
shrl $0x5, %edx
movl (%r14,%rdx,8), %e... | /OpenMD[P]OpenMD/src/antlr/BitSet.cpp |
antlr::ASTRefCount<antlr::BaseAST>::operator=(antlr::AST*) | ASTRefCount<T>& operator=(AST* other)
{
ASTRef* tmp = ASTRef::getRef(other);
if (ref && ref->decrement())
delete ref;
ref=tmp;
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x53064
movq %rax, %r14
movq (%rbx), %r15
testq %r15, %r15
je 0x54f44
decl 0x8(%r15)
jne 0x54f44
movq %r15, %rdi
callq 0x53054
movl $0x10, %esi
movq %r15, %rdi
callq 0x12430
movq %r14, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
| /OpenMD[P]OpenMD/src/antlr/ASTRefCount.hpp |
antlr::CommonToken::CommonToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Token()
: ref(0)
, type(INVALID_TYPE)
{
} | movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
leaq 0xd3b82(%rip), %rax # 0x128b70
movq %rax, (%rdi)
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x14(%rdi)
leaq 0x20(%rdi), %rax
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
addq %rcx, %rdx
movq %rax, %rdi
movq %rc... | /OpenMD[P]OpenMD/src/antlr/Token.hpp |
antlr::CommonToken::toString[abi:cxx11]() const | string CommonToken::toString() const
{
return "[\""+getText()+"\",<"+getType()+">,line="+getLine()+",column="+getColumn()+"]";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0xe8(%rsp), %r15
movq %r15, %rdi
callq *0x20(%rax)
leaq 0x95d51(%rip), %rcx # 0xeada0
movl $0x2, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
ca... | /OpenMD[P]OpenMD/src/antlr/CommonToken.cpp |
antlr::CommonToken::getText[abi:cxx11]() const | string getText() const
{
return text;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x185b0
movq %rbx, %rax
popq %rbx
retq
nop
| /OpenMD[P]OpenMD/src/antlr/CommonToken.hpp |
antlr::LLkParser::trace(char const*, char const*) | void LLkParser::trace(const char* ee, const char* rname)
{
traceIndent();
cout << ee << rname << ((inputState->guessing>0)?"; [guessing]":"; ");
for (int i = 1; i <= k; i++)
{
if (i != 1) {
cout << ", ";
}
cout << "LA(" << i << ")==";
string temp;
try {
temp = LT(i)->getText().c_str();
}
cat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
callq *0xd8(%rax)
testq %r15, %r15
je 0x5564b
movq %r15, %rdi
callq 0x121c0
movq 0xd6982(%rip), %rdi # 0x12bfc0
movq %r15, %rsi
movq %rax, %rdx
callq 0x12500
jmp 0x556... | /OpenMD[P]OpenMD/src/antlr/LLkParser.cpp |
antlr::MismatchedCharException::MismatchedCharException(int, int, bool, antlr::CharScanner*) | MismatchedCharException::MismatchedCharException(
int c,
int expecting_,
bool matchNot,
CharScanner* scanner_
) : RecognitionException("Mismatched char",
scanner_->getFilename(),
scanner_->getLine(), scanner_->getColumn())
, mismatchType(matchNot ? NOT_CHAR : CHAR)
, foundChar(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movl %ecx, %r12d
movl %edx, 0x4(%rsp)
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x9517e(%rip), %rsi # 0xeae72
leaq 0x95186(%rip), %rdx # 0xeae81
leaq 0x8(%rsp), %rdi
callq 0... | /OpenMD[P]OpenMD/src/antlr/MismatchedCharException.cpp |
antlr::MismatchedCharException::getMessage[abi:cxx11]() const | string MismatchedCharException::getMessage() const
{
ANTLR_USE_NAMESPACE(std)string s;
switch (mismatchType) {
case CHAR :
s += "expecting '" + charName(expecting) + "', found '" + charName(foundChar) + "'";
break;
case NOT_CHAR :
s += "expecting anything but '" + charName(expecting) + "'; got it anyway";
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rsi, %r14
leaq 0x10(%rdi), %rbx
movq %rbx, (%rdi)
movq $0x0, 0x8(%rdi)
movq %rdi, 0x68(%rsp)
movb $0x0, 0x10(%rdi)
movl 0x50(%rsi), %eax
decl %eax
cmpl $0x5, %eax
ja 0x56130
leaq 0x94efb(%rip), %rcx # ... | /OpenMD[P]OpenMD/src/antlr/MismatchedCharException.cpp |
antlr::MismatchedTokenException::MismatchedTokenException() | MismatchedTokenException::MismatchedTokenException()
: RecognitionException("Mismatched Token: expecting any AST node","<AST>",-1,-1)
, token(0)
, node(nullASTptr)
, tokenNames(0)
, numTokens(0)
{
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x93cc9(%rip), %rsi # 0xeaf7b
leaq 0x93cea(%rip), %rdx # 0xeafa3
leaq 0x28(%rsp), %rdi
callq 0x1eea8
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x93cd0(%rip), %rsi # 0xeafa4
... | /OpenMD[P]OpenMD/src/antlr/MismatchedTokenException.cpp |
antlr::MismatchedTokenException::MismatchedTokenException(char const* const*, int, antlr::ASTRefCount<antlr::AST>, int, int, bool) | MismatchedTokenException::MismatchedTokenException(
const char* const* tokenNames_,
const int numTokens_,
RefAST node_,
int lower,
int upper_,
bool matchNot
) : RecognitionException("Mismatched Token","<AST>",-1,-1)
, token(0)
, node(node_)
, tokenText( (node_ ? node_->toString(): ANTLR_USE_NAMESPACE(std)st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, %r15d
movl %r8d, %r12d
movq %rcx, %r13
movl %edx, 0xc(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
leaq 0x48(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x93b53(%rip), %rsi # 0xeafaa
leaq 0x93b5c(%rip), %rdx # 0xeafba
leaq ... | /OpenMD[P]OpenMD/src/antlr/MismatchedTokenException.cpp |
antlr::MismatchedTokenException::MismatchedTokenException(char const* const*, int, antlr::ASTRefCount<antlr::AST>, antlr::BitSet, bool) | MismatchedTokenException::MismatchedTokenException(
const char* const* tokenNames_,
const int numTokens_,
RefAST node_,
BitSet set_,
bool matchNot
) : RecognitionException("Mismatched Token","<AST>",-1,-1)
, token(0)
, node(node_)
, tokenText( (node_ ? node_->toString(): ANTLR_USE_NAMESPACE(std)string("<empt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, %r12d
movq %r8, %r15
movq %rcx, %r13
movl %edx, 0xc(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
leaq 0x48(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x93793(%rip), %rsi # 0xeafaa
leaq 0x9379c(%rip), %rdx # 0xeafba
leaq 0x... | /OpenMD[P]OpenMD/src/antlr/MismatchedTokenException.cpp |
antlr::NoViableAltForCharException::NoViableAltForCharException(int, antlr::CharScanner*) | NoViableAltForCharException::NoViableAltForCharException(int c, CharScanner* scanner)
: RecognitionException("NoViableAlt",
scanner->getFilename(),
scanner->getLine(),scanner->getColumn()),
foundChar(c)
{
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x91ab1(%rip), %rsi # 0xeb00b
leaq 0x91ab5(%rip), %rdx # 0xeb016
leaq 0x8(%rsp), %rdi
callq 0x1eea8
movq (%r15), %rax
movq %r15, %r... | /OpenMD[P]OpenMD/src/antlr/NoViableAltForCharException.cpp |
antlr::NoViableAltForCharException::getMessage[abi:cxx11]() const | string NoViableAltForCharException::getMessage() const
{
return ANTLR_USE_NAMESPACE(std)string("unexpected char: ")+charName(foundChar);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x919d4(%rip), %rsi # 0xeb0a7
leaq 0x919de(%rip), %rdx # 0xeb0b8
leaq 0x20(%rsp), %rdi
callq 0x1eea8
movl 0x50(%r14), %esi
movq %rsp, %rdi
callq 0x5a785
movq 0x20(%rsp), %rcx
movq ... | /OpenMD[P]OpenMD/src/antlr/NoViableAltForCharException.cpp |
antlr::Parser::reportError(antlr::RecognitionException const&) | void Parser::reportError(const RecognitionException& ex)
{
ANTLR_USE_NAMESPACE(std)cerr << ex.toString().c_str() << ANTLR_USE_NAMESPACE(std)endl;
} | pushq %rbx
subq $0x20, %rsp
movq (%rsi), %rax
movq %rsp, %rbx
movq %rbx, %rdi
callq *0x10(%rax)
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x5985d
movq %rbx, %rdi
callq 0x121c0
movq 0xd2798(%rip), %rdi # 0x12bfe8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x12500
jmp 0x5987b
movq 0xd2784(%rip), %rax # 0x12bfe8
movq (%rax... | /OpenMD[P]OpenMD/src/antlr/Parser.cpp |
antlr::Parser::reportError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void Parser::reportError(const ANTLR_USE_NAMESPACE(std)string& s)
{
if ( getFilename()=="" )
ANTLR_USE_NAMESPACE(std)cerr << "error: " << s.c_str() << ANTLR_USE_NAMESPACE(std)endl;
else
ANTLR_USE_NAMESPACE(std)cerr << getFilename().c_str() << ": error: " << s.c_str() << ANTLR_USE_NAMESPACE(std)endl;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x40(%rax)
leaq 0x975f7(%rip), %rsi # 0xf0f11
movq %r15, %rdi
callq 0x12130
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x10(%rsp), %r12
cmpq %r... | /OpenMD[P]OpenMD/src/antlr/Parser.cpp |
antlr::Parser::traceOut(char const*) | void Parser::traceOut(const char* rname)
{
for( int i = 0; i < traceDepth; i++ )
ANTLR_USE_NAMESPACE(std)cout << " ";
ANTLR_USE_NAMESPACE(std)cout << "< " << rname
<< "; LA(1)==" << LT(1)->getText().c_str()
<< ((inputState->guessing>0)?" [guessing]":"")
<< ANTLR_USE_NAMESPACE(std)endl;
traceDepth--;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
jle 0x59f33
xorl %ebp, %ebp
movq 0xd20ab(%rip), %r15 # 0x12bfc0
leaq 0x8f280(%rip), %r12 # 0xe919c
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x12500
incl %ebp
cmpl 0x18(%rbx)... | /OpenMD[P]OpenMD/src/antlr/Parser.cpp |
antlr::RecognitionException::getFileLineColumnString[abi:cxx11]() const | string RecognitionException::getFileLineColumnString() const
{
ANTLR_USE_NAMESPACE(std)string fileLineColumnString;
if ( fileName.length() > 0 )
fileLineColumnString = fileName + ":";
if ( line != -1 )
{
if ( fileName.length() == 0 )
fileLineColumnString = fileLineColumnString + "line ";
fileLineColumnS... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x30(%rsi), %rdx
testq %rdx, %rdx
je 0x5a2f9
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x28(%r14), %rsi
addq %rsi, %rdx
... | /OpenMD[P]OpenMD/src/antlr/RecognitionException.cpp |
antlr::operator+(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | string operator+( const ANTLR_USE_NAMESPACE(std)string& lhs, const int rhs )
{
char tmp[100];
snprintf(tmp,100,"%d",rhs);
return lhs+tmp;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %ecx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8ea95(%rip), %rdx # 0xe9137
movq %rsp, %r15
movl $0x64, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x12760
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rd... | /OpenMD[P]OpenMD/src/antlr/String.cpp |
antlr::operator+(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) | string operator+( const ANTLR_USE_NAMESPACE(std)string& lhs, size_t rhs )
{
char tmp[100];
snprintf(tmp,100,"%lu",(unsigned long)rhs);
return lhs+tmp;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rcx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x90a05(%rip), %rdx # 0xeb126
movq %rsp, %r15
movl $0x64, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x12760
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rd... | /OpenMD[P]OpenMD/src/antlr/String.cpp |
antlr::Token::toString[abi:cxx11]() const | string Token::toString() const
{
return "[\""+getText()+"\",<"+type+">]";
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq *0x20(%rax)
leaq 0x904af(%rip), %rcx # 0xeada0
movl $0x2, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x124d0
leaq 0x18(%rsp), %r15
movq %r15, -0x... | /OpenMD[P]OpenMD/src/antlr/Token.cpp |
antlr::TreeParser::traceOut(char const*, antlr::ASTRefCount<antlr::AST>) | void TreeParser::traceOut(const char* rname, RefAST t)
{
traceIndent();
ANTLR_USE_NAMESPACE(std)cout << "< " << rname
<< "(" << (t ? t->toString().c_str() : "null") << ")"
<< ((inputState->guessing>0)?" [guessing]":"")
<< ANTLR_USE_NAMESPACE(std)endl;
traceDepth--;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x60(%rax)
movq 0xd1040(%rip), %r12 # 0x12bfc0
leaq 0x8fe67(%rip), %rsi # 0xeadee
movl $0x2, %edx
movq %r12, %rdi
callq 0x12500
testq %r15, %r15
je 0x5afb5
movq %r15, ... | /OpenMD[P]OpenMD/src/antlr/TreeParser.cpp |
OpenMD::ForceField::ForceField(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | ForceField::ForceField(std::string ffName) : wildCardAtomTypeName_("X") {
char* tempPath;
tempPath = getenv("FORCE_PARAM_PATH");
if (tempPath == NULL) {
// convert a macro from compiler to a string in c++
STR_DEFINE(ffPath_, FRC_PATH);
} else {
ffPath_ = tempPath;
}
setForceF... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xce02d(%rip), %rax # 0x129190
movq %rax, (%rdi)
xorl %eax, %eax
movl %eax, 0x8(%rdi)
leaq 0x18(%rdi), %rcx
movl %eax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
... | /OpenMD[P]OpenMD/src/brains/ForceField.cpp |
OpenMD::ForceField::getBendType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | BendType* ForceField::getBendType(const std::string& at1,
const std::string& at2,
const std::string& at3) {
std::vector<std::string> keys;
keys.push_back(at1);
keys.push_back(at2);
keys.push_back(at3);
// try exact match first
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x5e916
leaq 0xa0(%rsp), %rdi
movq %r13, %rsi
callq 0x5e9... | /OpenMD[P]OpenMD/src/brains/ForceField.cpp |
OpenMD::ForceField::getTorsionType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_stri... | TorsionType* ForceField::getTorsionType(const std::string& at1,
const std::string& at2,
const std::string& at3,
const std::string& at4) {
std::vector<std::string> keys;
keys.push_back(at... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, 0x40(%rsp)
xorps %xmm0, %xmm0
leaq 0x100(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x5e916
leaq 0x100(%rsp), %rdi
movq... | /OpenMD[P]OpenMD/src/brains/ForceField.cpp |
OpenMD::ForceField::getNonBondedInteractionType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | NonBondedInteractionType* ForceField::getNonBondedInteractionType(
const std::string& at1, const std::string& at2) {
std::vector<std::string> keys;
keys.push_back(at1);
keys.push_back(at2);
// try exact match first
NonBondedInteractionType* nbiType =
nonBondedInteractionTypeCont_.find... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x5e916
leaq 0x80(%rsp), %rdi
movq %r12, %rsi
callq 0x5e916
leaq 0x120(%rbx), %rdi
leaq 0x80(%rsp),... | /OpenMD[P]OpenMD/src/brains/ForceField.cpp |
OpenMD::ForceField::addAtomType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, OpenMD::AtomType*) | bool ForceField::addAtomType(const std::string& at, AtomType* atomType) {
std::vector<std::string> keys;
keys.push_back(at);
atypeIdentToName[atomType->getIdent()] = at;
return atomTypeCont_.add(keys, atomType);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x5e916
movq %rbx, %rdi
callq 0xb1e6c
leaq 0x808(%r14), %rdi
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
callq 0x5fedc
movq %rax, %rdi
mo... | /OpenMD[P]OpenMD/src/brains/ForceField.cpp |
OpenMD::TypeContainer<OpenMD::BendType, 3>::find(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>>>>&) | ElemPtr find(KeyType& keys) {
assert(keys.size() == SIZE);
MapTypeIterator i;
i = data_.find(keys);
if (i != data_.end()) { return (i->second).second; }
KeyType reversedKeys = keys;
std::reverse(reversedKeys.begin(), reversedKeys.end());
i = data_.find(reversedKeys);
i... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x62078
movq %rax, %rbx
addq $0x10, %r12
cmpq %r12, %rax
je 0x5eed1
movq 0x40(%rbx), %rbx
jmp 0x5ef37
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5eac4
movq (%r12), %r15
mo... | /OpenMD[P]OpenMD/src/utils/TypeContainer.hpp |
OpenMD::TypeContainer<OpenMD::InversionType, 4>::find(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>>>>&) | ElemPtr find(KeyType& keys) {
assert(keys.size() == SIZE);
MapTypeIterator i;
i = data_.find(keys);
if (i != data_.end()) { return (i->second).second; }
KeyType reversedKeys = keys;
std::reverse(reversedKeys.begin(), reversedKeys.end());
i = data_.find(reversedKeys);
i... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x636ec
movq %rax, %rbx
addq $0x10, %r12
cmpq %r12, %rax
je 0x5fe53
movq 0x40(%rbx), %rbx
jmp 0x5feb9
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5eac4
movq (%r12), %r15
mo... | /OpenMD[P]OpenMD/src/utils/TypeContainer.hpp |
OpenMD::TypeContainer<OpenMD::BondType, 2>::add(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>>>>&, OpenMD::BondType*) | bool add(KeyType& keys, ElemPtr elem) {
assert(keys.size() == SIZE);
assert(elem);
return data_.insert(value_type(keys, std::make_pair(index_++, elem)))
.second;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
leaq 0x8(%rdi), %r14
movl (%rdi), %r12d
leal 0x1(%r12), %eax
movl %eax, (%rdi)
movq %rsp, %r15
movq %r15, %rdi
callq 0x5eac4
movl %r12d, 0x18(%r15)
movq %rbx, 0x20(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6424c
movl %edx, %ebx
movq %rsp, ... | /OpenMD[P]OpenMD/src/utils/TypeContainer.hpp |
OpenMD::TypeContainer<OpenMD::BendType, 3>::add(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>>>>&, OpenMD::BendType*) | bool add(KeyType& keys, ElemPtr elem) {
assert(keys.size() == SIZE);
assert(elem);
return data_.insert(value_type(keys, std::make_pair(index_++, elem)))
.second;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
leaq 0x8(%rdi), %r14
movl (%rdi), %r12d
leal 0x1(%r12), %eax
movl %eax, (%rdi)
movq %rsp, %r15
movq %r15, %rdi
callq 0x5eac4
movl %r12d, 0x18(%r15)
movq %rbx, 0x20(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x64406
movl %edx, %ebx
movq %rsp, ... | /OpenMD[P]OpenMD/src/utils/TypeContainer.hpp |
OpenMD::TypeContainer<OpenMD::NonBondedInteractionType, 2>::add(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>>>>&, OpenMD::NonBondedInteractionType*) | bool add(KeyType& keys, ElemPtr elem) {
assert(keys.size() == SIZE);
assert(elem);
return data_.insert(value_type(keys, std::make_pair(index_++, elem)))
.second;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
leaq 0x8(%rdi), %r14
movl (%rdi), %r12d
leal 0x1(%r12), %eax
movl %eax, (%rdi)
movq %rsp, %r15
movq %r15, %rdi
callq 0x5eac4
movl %r12d, 0x18(%r15)
movq %rbx, 0x20(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x64934
movl %edx, %ebx
movq %rsp, ... | /OpenMD[P]OpenMD/src/utils/TypeContainer.hpp |
bool Parameter<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::internalSetData<std::vector<double, std::allocator<double>>>(std::vector<double, std::allocator<double>>) | static bool convert(RepType v, RepType& r) {
r = v;
return true;
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x20(%rsp), %rdi
callq 0x4c696
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x60859
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x12430
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x6086f
movq 0x10(%rs... | /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
void OpenMD::Utils::deletePointers<std::map<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>>>>, std::pair<int, OpenMD::TorsionType*>, std::less<std::vector<std::__cxx11::basic_string<... | void deletePointers(Container& container) {
if constexpr(details::is_container_v<typename Container::value_type>) {
for (auto& elem : container)
deletePointers(elem);
} else {
for (auto& elem : container)
details::lifted_deleter(elem);
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
addq $0x8, %rbx
cmpq %rbx, %r14
je 0x60adb
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x60acb
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0x122c0
movq %rax, %r14
cmpq %rbx, %rax
jne 0x60abc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /OpenMD[P]OpenMD/src/utils/MemoryUtils.hpp |
OpenMD::MoleculeCreator::createOverrideAtomTypes(OpenMD::ForceField*, OpenMD::MoleculeStamp*) | void MoleculeCreator::createOverrideAtomTypes(ForceField* ff,
MoleculeStamp* molStamp) {
// Some stamps have overrides of default types in the force field.
// This runs through atomStamps which can have overrides and makes sure
// that the types are created, even if this processor doesn't end up
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rsi, 0x8(%rsp)
movq 0xf0(%rdx), %r12
movq %rdx, 0x98(%rsp)
subq 0xe8(%rdx), %r12
je 0x64e99
sarq $0x3, %r12
leaq 0xb0(%rsp), %r13
cmpq $0x1, %r12
adcq $0x0, %r12
xorl %r14d, %r14d
movq 0x98(%rsp), %rax
mov... | /OpenMD[P]OpenMD/src/brains/MoleculeCreator.cpp |
OpenMD::MoleculeCreator::createAtom(OpenMD::ForceField*, OpenMD::AtomStamp*, OpenMD::LocalIndexManager*) | Atom* MoleculeCreator::createAtom(ForceField* ff, AtomStamp* stamp,
LocalIndexManager* localIndexMan) {
AtomType* atomType;
Atom* atom;
atomType = ff->getAtomType(stamp->getType());
if (atomType == NULL) {
snprintf(painCave.errMsg, MAX_SIM_ERROR_MSG_LENGTH,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r14
leaq 0xa0(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq 0x98(%rdx), %rsi
movq 0xa0(%rdx), %rdx
addq %rsi, %rdx
leaq 0x90(%rsp), %r15
movq %r15, %rdi
callq 0x185b0
movq %... | /OpenMD[P]OpenMD/src/brains/MoleculeCreator.cpp |
OpenMD::MoleculeCreator::createBond(OpenMD::ForceField*, OpenMD::Molecule*, OpenMD::BondStamp*, OpenMD::LocalIndexManager*) | Bond* MoleculeCreator::createBond(ForceField* ff, Molecule* mol,
BondStamp* stamp,
LocalIndexManager* localIndexMan) {
BondTypeParser btParser;
BondType* bondType = NULL;
Atom* atomA;
Atom* atomB;
atomA = mol->getAtomAt(stamp->... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %rbx
movq %rsi, %r13
leaq 0x98(%rsp), %rdi
callq 0xb59f0
movl 0xa0(%rbp), %eax
movl 0xa4(%rbp), %ecx
movq 0x10(%rbx), %rdx
movq (%rdx,%rax,8), %r15
movq (%rdx,%rcx,8), %r12
cmpb $0x1, 0xa8(%rbp)
... | /OpenMD[P]OpenMD/src/brains/MoleculeCreator.cpp |
OpenMD::MoleculeCreator::createTorsion(OpenMD::ForceField*, OpenMD::Molecule*, OpenMD::TorsionStamp*, OpenMD::LocalIndexManager*) | Torsion* MoleculeCreator::createTorsion(ForceField* ff, Molecule* mol,
TorsionStamp* stamp,
LocalIndexManager* localIndexMan) {
TorsionTypeParser ttParser;
TorsionType* torsionType = NULL;
Torsion* torsion = NULL;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
leaq 0xf0(%rsp), %rdi
callq 0xd0de6
leaq 0x98(%r15), %rsi
leaq 0xa8(%rsp), %rdi
callq 0x1d5c6
movq 0xa8(%rsp), %rdi
movq 0xb0(%rsp), %rcx
subq %rdi,... | /OpenMD[P]OpenMD/src/brains/MoleculeCreator.cpp |
OpenMD::GenericData::~GenericData() | virtual ~GenericData() {} | pushq %rbx
movq %rdi, %rbx
leaq 0xc053b(%rip), %rax # 0x129470
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x68f50
movq (%rax), %rsi
incq %rsi
callq 0x12430
movl $0x28, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x12430
| /OpenMD[P]OpenMD/src/utils/GenericData.hpp |
OpenMD::Bond::~Bond() | void calcForce(bool doParticlePot) {
RealType len;
RealType dvdr;
Vector3d r12;
Vector3d force;
r12 = atoms_[1]->getPos() - atoms_[0]->getPos();
snapshotMan_->getCurrentSnapshot()->wrapVector(r12);
len = r12.length();
bondType_->calcForce(len, potential_, dvdr);
f... | pushq %rbx
movq %rdi, %rbx
callq 0x6917c
movl $0x98, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x12430
nop
| /OpenMD[P]OpenMD/src/primitives/Bond.hpp |
OpenMD::PairList::removePairs(std::set<int, std::less<int>, std::allocator<int>>&, std::set<int, std::less<int>, std::allocator<int>>&) | void PairList::removePairs(std::set<int>& set1, std::set<int>& set2) {
for (std::set<int>::iterator iter1 = set1.begin(); iter1 != set1.end();
++iter1) {
for (std::set<int>::iterator iter2 = set2.begin(); iter2 != set2.end();
++iter2) {
this->removePair(*iter1, *iter2);
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x18(%rsi), %r12
addq $0x8, %r14
cmpq %r14, %r12
je 0x69bc5
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x8(%rdx), %rbp
movq 0x18(%rbx), %r13
cmpq %rbp, %r13
je 0x69bb5
movl 0x20(%r12), %esi
movl 0x20(%r13), %edx
movq %r15, %rdi
... | /OpenMD[P]OpenMD/src/brains/PairList.cpp |
OpenMD::SimSnapshotManager::SimSnapshotManager(OpenMD::SimInfo*, int, int, int) | SimSnapshotManager::SimSnapshotManager(SimInfo* info, int atomStorageLayout,
int rigidBodyStorageLayout,
int cutoffGroupStorageLayout) :
SnapshotManager(atomStorageLayout, rigidBodyStorageLayout,
cutoffGroupSto... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r15d
movl %edx, %r13d
movq %rdi, %rbx
movl %edx, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
movq %r8, 0x20(%rsp)
movl %r8d, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
leaq 0xbf614(%rip), %rax # 0x129500
movq %rax, (%rdi)
... | /OpenMD[P]OpenMD/src/brains/SimSnapshotManager.cpp |
OpenMD::SimSnapshotManager::resetToPrevious() | bool SimSnapshotManager::resetToPrevious() {
int prevID = previousSnapshot_->getID();
*currentSnapshot_ = *previousSnapshot_;
currentSnapshot_->setID(prevID);
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x6b956
movl %eax, %ebp
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6a4e6
movl $0x1c0, %esi # imm = 0x1C0
leaq (%r14,%rsi), %rdi
addq %r15, %rsi
callq 0x6a4e6
movl $0x380... | /OpenMD[P]OpenMD/src/brains/SimSnapshotManager.cpp |
OpenMD::SnapshotManager::~SnapshotManager() | virtual ~SnapshotManager() {
delete currentSnapshot_;
delete previousSnapshot_;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xbf2f6(%rip), %rax # 0x129570
movq %rax, (%rdi)
movq 0x18(%rdi), %r14
testq %r14, %r14
je 0x6a2b7
movq 0xa68(%r14), %rdi
testq %rdi, %rdi
je 0x6a297
callq 0x23d2e
leaq 0x380(%r14), %rdi
callq 0x6a31a
leaq 0x1c0(%r14), %rdi
callq 0x6a31a
movq %r14, %rdi
callq 0x... | /OpenMD[P]OpenMD/src/brains/SnapshotManager.hpp |
OpenMD::Snapshot::getXZarea() | RealType Snapshot::getXZarea() {
if (!hasXZarea) {
Vector3d x = frameData.hmat.getColumn(0);
Vector3d z = frameData.hmat.getColumn(2);
frameData.xzArea = cross(x, z).length();
hasXZarea = true;
}
return frameData.xzArea;
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x1, 0xa7b(%rdi)
jne 0x6bd3a
movsd 0x7f0(%rbx), %xmm0
jmp 0x6be1f
leaq 0x550(%rbx), %rax
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
xorl %ecx, %ecx
movsd (%rax), %xmm0
movsd %xmm0, (%rsp,%rcx,8)
incq %rcx
addq $0x18, %rax
cmpq $0x3, %rcx
jne 0x6bd53
m... | /OpenMD[P]OpenMD/src/brains/Snapshot.cpp |
OpenMD::Snapshot::getVolume() | RealType Snapshot::getVolume() {
if (!hasVolume) {
frameData.volume = frameData.hmat.determinant();
hasVolume = true;
}
return frameData.volume;
} | pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0xa7d(%rdi)
jne 0x6bf47
movsd 0x800(%rbx), %xmm0
jmp 0x6bf62
leaq 0x550(%rbx), %rdi
callq 0x6ce4c
movsd %xmm0, 0x800(%rbx)
movb $0x1, 0xa7d(%rbx)
popq %rbx
retq
| /OpenMD[P]OpenMD/src/brains/Snapshot.cpp |
OpenMD::Snapshot::getSelfPotential() | RealType Snapshot::getSelfPotential() {
if (!hasSelfPotential) {
frameData.selfPotential = 0.0;
for (int i = 0; i < N_INTERACTION_FAMILIES; i++) {
frameData.selfPotential += frameData.selfPotentials[i];
}
hasSelfPotential = true;
hasPotentialEnergy = false;
hasTotalEner... | cmpb $0x1, 0xa78(%rdi)
jne 0x6c3f6
movsd 0x720(%rdi), %xmm0
retq
xorpd %xmm0, %xmm0
xorl %eax, %eax
addsd 0x728(%rdi,%rax,8), %xmm0
incq %rax
cmpq $0x7, %rax
jne 0x6c3fc
movsd %xmm0, 0x720(%rdi)
movw $0x1, 0xa78(%rdi)
movb $0x0, 0xa70(%rdi)
retq
nop
| /OpenMD[P]OpenMD/src/brains/Snapshot.cpp |
OpenMD::Snapshot::getHeatFlux() | Vector3d Snapshot::getHeatFlux() {
// BE CAREFUL WITH UNITS
return getConductiveHeatFlux() + getConvectiveHeatFlux();
} | movq %rdi, %rax
movq 0xa38(%rsi), %rcx
movq %rcx, -0x8(%rsp)
movups 0xa28(%rsi), %xmm0
movaps %xmm0, -0x18(%rsp)
movq 0xa50(%rsi), %rcx
movq %rcx, -0x28(%rsp)
movupd 0xa40(%rsi), %xmm0
movapd %xmm0, -0x38(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, -0x58(%rsp)
movq $0x0, -0x48(%rsp)
xorl %ecx, %ecx
movsd -0x18(%rsp,%rcx,8),... | /OpenMD[P]OpenMD/src/brains/Snapshot.cpp |
bool OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD... | bool operator()(DataType data) const {
return cons1_(data) || cons2_(data);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x185b0
movq %r15, %rdi
movq %r12, %rsi... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>::~OrParamConstraint() | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbx
movq %rdi, %rbx
movq 0x140(%rdi), %rdi
leaq 0x150(%rbx), %rax
cmpq %rax, %rdi
je 0x70caa
movq (%rax), %rsi
incq %rsi
callq 0x12430
movq 0x120(%rbx), %rdi
leaq 0x130(%rbx), %rax
cmpq %rax, %rdi
je 0x70cc8
movq (%rax), %rsi
incq %rsi
callq 0x12430
leaq 0x20(%rbx), %rdi
callq 0x70cec
movq (%rbx), %rdi
addq $0x1... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
bool OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::all... | bool operator()(DataType data) const {
return cons1_(data) || cons2_(data);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x185b0
movq %r15, %rdi
movq %r12, %rsi... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::AndParamConstraint<OpenMD::GreaterThanConstraint<double>, OpenMD::LessThanOrEqualToConstraint<double>>::~AndParamConstraint() | AndParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << "(" << cons1_.getConstraintDescription() << " and "
<< cons2_.getConstraintDescription() << ")";
this->description_ = iss.str();
} | pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x71058
movq (%rax), %rsi
incq %rsi
callq 0x12430
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x71070
movq (%rax), %rsi
incq %rsi
callq 0x12430
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x71088
movq ... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
Parameter<bool>::setData(std::vector<double, std::allocator<double>>) | virtual bool setData(std::vector<RealType> pval) {
return internalSetData<std::vector<RealType>>(pval);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x4c696
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7156a
movl %eax, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x713b8
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x12430
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
m... | /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
bool Parameter<bool>::internalSetData<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | bool internalSetData(T data) {
ParamType tmp {};
bool result = ValueType::convert(data, tmp);
if (result) {
empty_ = false;
data_ = tmp;
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %r14
movb $0x0, (%r14)
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x185b0
movq %r15, %rdi
movq %r14... | /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
bool Parameter<bool>::internalSetData<std::vector<double, std::allocator<double>>>(std::vector<double, std::allocator<double>>) | bool internalSetData(T data) {
ParamType tmp {};
bool result = ValueType::convert(data, tmp);
if (result) {
empty_ = false;
data_ = tmp;
}
return result;
} | pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4c696
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x71591
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x12430
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
nop
| /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
bool Parameter<double>::internalSetData<std::vector<double, std::allocator<double>>>(std::vector<double, std::allocator<double>>) | bool internalSetData(T data) {
ParamType tmp {};
bool result = ValueType::convert(data, tmp);
if (result) {
empty_ = false;
data_ = tmp;
}
return result;
} | pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4c696
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x71795
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x12430
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
nop
| /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
Parameter<int>::setData(std::vector<double, std::allocator<double>>) | virtual bool setData(std::vector<RealType> pval) {
return internalSetData<std::vector<RealType>>(pval);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x4c696
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7192e
movl %eax, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7189e
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x12430
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
m... | /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>::OrParamConstraint(OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreC... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x185b0
leaq 0x20(%rbx), %r14
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x71dca
leaq 0xc0(%rbx), %r12
leaq 0... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
bool OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>::operator()<std::__cxx11::basic_s... | bool operator()(DataType data) const {
return cons1_(data) || cons2_(data);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x185b0
movq %r15, %rdi
movq %r12, %rsi... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::EqualIgnoreCaseConstraint::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | bool operator()(std::string data) const {
return OpenMD::toUpperCopy(data) == rhs_;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x12930
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x72de4
movq 0x10(%rsp), %rdx
cmpq 0x28(%r14), %rdx
jne 0x72c9c
movq 0x8(%rsp), %rbx
testq %rdx, %rdx
je 0x72ca5
movq 0x20... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> OpenMD::toUpperCopy<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::locale const&) | Container toUpperCopy(const Container& cont,
const std::locale& = std::locale()) {
Container result {cont};
toUpper(result);
return result;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x185b0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x12930
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d345
leaq 0x8(%rsp), %rdi
callq 0x126... | /OpenMD[P]OpenMD/src/utils/CaseConversion.hpp |
OpenMD::GreaterThanConstraint<double>::GreaterThanConstraint(double) | GreaterThanConstraint(T rhs) : rhs_(rhs) {
std::stringstream iss;
iss << "greater than" << rhs;
this->description_ = iss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movsd %xmm0, (%rsp)
movsd %xmm0, 0x20(%rdi)
leaq 0x28(%rsp), %rdi
callq 0x122d0
leaq 0x38(%rsp), %r14
leaq 0x78937(%rip), %rsi # 0xeb8d1
movl... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::AndParamConstraint<OpenMD::GreaterThanConstraint<double>, OpenMD::LessThanOrEqualToConstraint<double>>::AndParamConstraint(OpenMD::GreaterThanConstraint<double>, OpenMD::LessThanOrEqualToConstraint<double>) | AndParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << "(" << cons1_.getConstraintDescription() << " and "
<< cons2_.getConstraintDescription() << ")";
this->description_ = iss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x30(%rdi), %rax
movq %rax, 0x8... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::AtomTypesSectionParser::AtomTypesSectionParser() | AtomTypesSectionParser::AtomTypesSectionParser() {
setSectionName("AtomTypes");
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0xb637f(%rip), %rax # 0x1297a0
movq %rax, (%rdi)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x7a41e(%rip), %rsi # 0xed853
leaq 0x7a420(%... | /OpenMD[P]OpenMD/src/io/AtomTypesSectionParser.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.