name string | code string | asm string | file string |
|---|---|---|---|
google::protobuf::util::converter::GetStringOptionOrDefault[abi:cxx11](google::protobuf::RepeatedPtrField<google::protobuf::Option> const&, google::protobuf::StringPiece, google::protobuf::StringPiece) | std::string GetStringOptionOrDefault(
const RepeatedPtrField<google::protobuf::Option>& options,
StringPiece option_name, StringPiece default_value) {
const google::protobuf::Option* opt = FindOptionOrNull(options, option_name);
if (opt == nullptr) {
return std::string(default_value);
}
return GetSt... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0xffbe0
testq %rax, %rax
je 0x220c06
movq 0x18(%rax), %rsi
testq %rsi, %rsi
jne 0x220bfc
movq 0x9dcf4(%rip), %rsi # 0x2be8f0
movq %rbx, %rdi
call... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/internal/utility.cc |
google::protobuf::util::converter::GetStringFromAny[abi:cxx11](google::protobuf::Any const&) | std::string GetStringFromAny(const google::protobuf::Any& any) {
google::protobuf::StringValue s;
ParseFromAny(any.value(), &s);
return s.value();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x102170
movq 0x18(%r14), %rsi
movq %r15, %rdi
callq 0x105ac0
movq -0x28(%rbp), %rax
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/internal/utility.cc |
google::protobuf::util::(anonymous namespace)::StatusErrorListener::InvalidValue(google::protobuf::util::converter::LocationTrackerInterface const&, google::protobuf::StringPiece, google::protobuf::StringPiece) | void InvalidValue(const converter::LocationTrackerInterface& loc,
StringPiece type_name,
StringPiece value) override {
status_ = util::Status(
util::error::INVALID_ARGUMENT,
StrCat(GetLocString(loc), ": invalid value ", string(value),
" fo... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %r9, %r12
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, -0x30(%rbp)
leaq -0xd8(%rbp), %rbx
movq %rbx, %rdi
callq 0x222c2a
movups (%rbx), %xmm0
movups %xmm0, -0x198(%rbp)
leaq 0x3... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/json_util.cc |
google::protobuf::util::(anonymous namespace)::StatusErrorListener::MissingField(google::protobuf::util::converter::LocationTrackerInterface const&, google::protobuf::StringPiece) | void MissingField(const converter::LocationTrackerInterface& loc,
StringPiece missing_name) override {
status_ = util::Status(util::error::INVALID_ARGUMENT,
StrCat(GetLocString(loc), ": missing field ",
std::string(missing_na... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq -0xa8(%rbp), %r12
movq %r12, %rdi
callq 0x222c2a
movups (%r12), %xmm0
movups %xmm0, -0x108(%rbp)
leaq 0x331ed(%rip), %rax # 0x255ca2
movq %rax, -0xd8... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/json_util.cc |
google::protobuf::util::MessageDifferencer::GetMapKeyComparator(google::protobuf::FieldDescriptor const*) const | inline bool FieldDescriptor::is_repeated() const {
return label() == LABEL_REPEATED;
} | cmpl $0x3, 0x3c(%rsi)
jne 0x223f31
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0xc8(%rdi), %rcx
testq %rcx, %rcx
je 0x223eec
leaq 0xc0(%rbx), %rdx
movq %rdx, %rax
xorl %esi, %esi
cmpq %r14, 0x20(%rcx)
setb %sil
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rsi,8), %rcx
te... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/descriptor.h |
google::protobuf::util::MessageDifferencer::TreatAsMap(google::protobuf::FieldDescriptor const*, google::protobuf::FieldDescriptor const*) | void MessageDifferencer::TreatAsMap(const FieldDescriptor* field,
const FieldDescriptor* key) {
GOOGLE_CHECK_EQ(FieldDescriptor::CPPTYPE_MESSAGE, field->cpp_type())
<< "Field has to be message type. Field name is: " << field->full_name();
GOOGLE_CHECK(key->containing_type(... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, -0x28(%rbp)
movq 0x30(%rsi), %rdi
testq %rdi, %rdi
je 0x2240ad
movq 0x9a0ae(%rip), %rax # 0x2be148
leaq -0x68(%rbp), %rsi
movq %rax, (%rsi)
leaq -0x30(%rbp), %rdx
movq %... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/message_differencer.cc |
google::protobuf::Duration google::protobuf::util::(anonymous namespace)::CreateNormalized<google::protobuf::Duration>(long, long) | Duration CreateNormalized(int64 seconds, int64 nanos) {
// Make sure nanos is in the range.
if (nanos <= -kNanosPerSecond || nanos >= kNanosPerSecond) {
seconds += nanos / kNanosPerSecond;
nanos = nanos % kNanosPerSecond;
}
// nanos should have the same sign as seconds.
if (seconds < 0 && nanos > 0) {... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq -0x3b9aca00(%rdx), %rax
cmpq $-0x77359400, %rax # imm = 0x88CA6C00
ja 0x22cb74
movabsq $0x112e0be826d694b3, %rcx # imm = 0x112E0BE826D694B3
movq %rbx, %rax
imulq %rcx
movq %r... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/time_util.cc |
google::protobuf::util::TimeUtil::DurationToMilliseconds(google::protobuf::Duration const&) | int64 TimeUtil::DurationToMilliseconds(const Duration& duration) {
return duration.seconds() * kMillisPerSecond +
RoundTowardZero(duration.nanos(), kNanosPerMillisecond);
} | pushq %rbp
movq %rsp, %rbp
imulq $0x3e8, 0x10(%rdi), %rax # imm = 0x3E8
movslq 0x18(%rdi), %rcx
cmpq $-0xf423f, %rcx # imm = 0xFFF0BDC1
setl %dl
imulq $0x431bde83, %rcx, %rsi # imm = 0x431BDE83
movq %rsi, %rdi
shrq $0x3f, %rdi
sarq $0x32, %rsi
addl %edi, %esi
movslq %esi, %rsi
imull $0xf4240, %esi, %edi # im... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/time_util.cc |
google::protobuf::util::TimeUtil::TimestampToMicroseconds(google::protobuf::Timestamp const&) | int64 TimeUtil::TimestampToMicroseconds(const Timestamp& timestamp) {
return timestamp.seconds() * kMicrosPerSecond +
RoundTowardZero(timestamp.nanos(), kNanosPerMicrosecond);
} | pushq %rbp
movq %rsp, %rbp
imulq $0xf4240, 0x10(%rdi), %rax # imm = 0xF4240
movslq 0x18(%rdi), %rcx
cmpq $-0x3e7, %rcx # imm = 0xFC19
setl %dl
imulq $0x10624dd3, %rcx, %rsi # imm = 0x10624DD3
movq %rsi, %rdi
shrq $0x3f, %rdi
sarq $0x26, %rsi
addl %edi, %esi
movslq %esi, %rsi
imull $0x3e8, %esi, %edi # im... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/time_util.cc |
google::protobuf::util::TimeUtil::TimestampToTimeval(google::protobuf::Timestamp const&) | timeval TimeUtil::TimestampToTimeval(const Timestamp& value) {
timeval result;
result.tv_sec = value.seconds();
result.tv_usec = RoundTowardZero(value.nanos(), kNanosPerMicrosecond);
return result;
} | pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rax
movslq 0x18(%rdi), %rcx
cmpq $-0x3e7, %rcx # imm = 0xFC19
setl %dl
imulq $0x10624dd3, %rcx, %rsi # imm = 0x10624DD3
movq %rsi, %rdi
shrq $0x3f, %rdi
sarq $0x26, %rsi
addl %edi, %esi
movslq %esi, %rsi
imull $0x3e8, %esi, %edi # imm = 0x3E8
subl %edi, %ecx
t... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/time_util.cc |
google::protobuf::util::TimeUtil::DurationToTimeval(google::protobuf::Duration const&) | timeval TimeUtil::DurationToTimeval(const Duration& value) {
timeval result;
result.tv_sec = value.seconds();
result.tv_usec = RoundTowardZero(value.nanos(), kNanosPerMicrosecond);
// timeval.tv_usec's range is [0, 1000000)
if (result.tv_usec < 0) {
result.tv_sec -= 1;
result.tv_usec += kMicrosPerSeco... | pushq %rbp
movq %rsp, %rbp
movslq 0x18(%rdi), %rax
cmpq $-0x3e7, %rax # imm = 0xFC19
setl %cl
imulq $0x10624dd3, %rax, %rdx # imm = 0x10624DD3
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x26, %rdx
addl %esi, %edx
movslq %edx, %rdx
imull $0x3e8, %edx, %esi # imm = 0x3E8
subl %esi, %eax
testl %eax, %eax
setg %... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/time_util.cc |
google::protobuf::operator+=(google::protobuf::Duration&, google::protobuf::Duration const&) | Duration& operator+=(Duration& d1, const Duration& d2) {
d1 = CreateNormalized<Duration>(d1.seconds() + d2.seconds(),
d1.nanos() + d2.nanos());
return d1;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %rax
addq 0x10(%rdi), %rax
movslq 0x18(%rdi), %rcx
movslq 0x18(%rsi), %rdx
addq %rcx, %rdx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x22cb22
movq 0x8(%rbx), %rax
testb $0x1, %al
jne 0x22d1ae
movq -0x28... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/time_util.cc |
google::protobuf::(anonymous namespace)::ToDuration(google::protobuf::uint128 const&, bool, google::protobuf::Duration*) | void ToDuration(const uint128& value, bool negative, Duration* duration) {
int64 seconds =
static_cast<int64>(Uint128Low64(value / kNanosPerSecond));
int32 nanos = static_cast<int32>(Uint128Low64(value % kNanosPerSecond));
if (negative) {
seconds = -seconds;
nanos = -nanos;
}
duration->set_secon... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, -0x2c(%rbp)
movq %rdi, %r15
movl $0x3b9aca00, %eax # imm = 0x3B9ACA00
leaq -0x50(%rbp), %r12
movq %rax, (%r12)
xorl %eax, %eax
movq %rax, 0x8(%r12)
movups (%rdi), %xmm0
leaq -0x40(%rbp), %... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/time_util.cc |
google::protobuf::operator*=(google::protobuf::Duration&, double) | Duration& operator*=(Duration& d, double r) { // NOLINT
double result = (d.seconds() * 1.0 + 1.0 * d.nanos() / kNanosPerSecond) * r;
int64 seconds = static_cast<int64>(result);
int32 nanos = static_cast<int32>((result - seconds) * kNanosPerSecond);
// Note that we normalize here not just because nanos can have... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cvtsi2sdq 0x10(%rdi), %xmm1
cvtsi2sdl 0x18(%rdi), %xmm2
movsd 0x27395(%rip), %xmm3 # 0x2548a0
divsd %xmm3, %xmm2
addsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %rsi
xorps %xmm0, %xmm0
cvtsi2sd %rsi, %xmm0
subsd %xmm0, %xmm2
mul... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/time_util.cc |
google::protobuf::operator/(google::protobuf::Duration const&, google::protobuf::Duration const&) | int64 operator/(const Duration& d1, const Duration& d2) {
bool negative1, negative2;
uint128 value1, value2;
ToUint128(d1, &value1, &negative1);
ToUint128(d2, &value2, &negative2);
int64 result = Uint128Low64(value1 / value2);
if (negative1 != negative2) {
result = -result;
}
return result;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r14
movaps %xmm0, (%r14)
leaq -0x40(%rbp), %r15
movaps %xmm0, (%r15)
leaq -0x2a(%rbp), %r12
movq %r14, %rsi
movq %r12, %rdx
callq 0x22d3c4
leaq -0x29(%rbp), %r13
movq ... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/time_util.cc |
google::protobuf::operator+=(google::protobuf::Timestamp&, google::protobuf::Duration const&) | Timestamp& operator+=(Timestamp& t, const Duration& d) { // NOLINT
t = CreateNormalized<Timestamp>(t.seconds() + d.seconds(),
t.nanos() + d.nanos());
return t;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %rax
addq 0x10(%rdi), %rax
movslq 0x18(%rdi), %rcx
movslq 0x18(%rsi), %rdx
addq %rcx, %rdx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x22c50e
movq 0x8(%rbx), %rax
testb $0x1, %al
jne 0x22d7cd
movq -0x28... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/time_util.cc |
google::protobuf::operator-=(google::protobuf::Timestamp&, google::protobuf::Duration const&) | Timestamp& operator-=(Timestamp& t, const Duration& d) { // NOLINT
t = CreateNormalized<Timestamp>(t.seconds() - d.seconds(),
t.nanos() - d.nanos());
return t;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x10(%rsi), %rax
movslq 0x18(%rdi), %rdx
movslq 0x18(%rsi), %rcx
subq %rcx, %rdx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x22c50e
movq 0x8(%rbx), %rax
testb $0x1, %al
jne 0x22d861
movq -0x28... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/time_util.cc |
google::protobuf::util::(anonymous namespace)::DescriptorPoolTypeResolver::~DescriptorPoolTypeResolver() | DescriptorPoolTypeResolver(const std::string& url_prefix,
const DescriptorPool* pool)
: url_prefix_(url_prefix), pool_(pool) {} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8fcf6(%rip), %rax # 0x2bd640
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x22d95f
callq 0xff870
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xff870
nop
| /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/type_resolver_util.cc |
google::protobuf::util::(anonymous namespace)::DescriptorPoolTypeResolver::ResolveEnumType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, google::protobuf::Enum*) | Status ResolveEnumType(const std::string& type_url,
Enum* enum_type) override {
std::string type_name;
Status status = ParseTypeUrl(type_url, &type_name);
if (!status.ok()) {
return status;
}
const EnumDescriptor* descriptor = pool_->FindEnumTypeByName(type_name);
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq -0x50(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb $0x0, (%rbx)
leaq -0xa8(%rbp), %rdi
leaq -0x60(%rbp), %rcx
callq 0x22e776
cmpl $0x0, -0xa8(%rbp)
je ... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/type_resolver_util.cc |
google::protobuf::util::(anonymous namespace)::DescriptorPoolTypeResolver::ParseTypeUrl(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>>*) | Status ParseTypeUrl(const string& type_url, std::string* type_name) {
if (type_url.substr(0, url_prefix_.size() + 1) != url_prefix_ + "/") {
return Status(
util::error::INVALID_ARGUMENT,
StrCat("Invalid type URL, type URLs must be of the form '",
url_prefix_, "/<type... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, -0x38(%rbp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x10(%rsi), %rcx
incq %rcx
leaq -0x98(%rbp), %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x100240
leaq -0x58(%rbp), %rbx
movq %rbx, -0x10(%rbx)
mo... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/util/type_resolver_util.cc |
google::protobuf::internal::WireFormat::SkipMessage(google::protobuf::io::CodedInputStream*, google::protobuf::UnknownFieldSet*) | bool WireFormat::SkipMessage(io::CodedInputStream* input,
UnknownFieldSet* unknown_fields) {
while (true) {
uint32 tag = input->ReadTag();
if (tag == 0) {
// End of input. This is a valid place to end, so return true.
return true;
}
WireFormatLite::WireType w... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%r14), %rax
cmpq 0x8(%r14), %rax
jae 0x22f57b
movzbl (%rax), %esi
testb %sil, %sil
js 0x22f57d
incq %rax
movq %rax, (%r14)
jmp 0x22f587
xorl %esi, %esi
movq %r14, %rdi
callq 0xfa7a0
movl %eax, %esi
movl %esi, 0x... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wire_format.cc |
google::protobuf::internal::WireFormat::ReadPackedEnumPreserveUnknowns(google::protobuf::io::CodedInputStream*, unsigned int, bool (*)(int), google::protobuf::UnknownFieldSet*, google::protobuf::RepeatedField<int>*) | bool WireFormat::ReadPackedEnumPreserveUnknowns(io::CodedInputStream* input,
uint32 field_number,
bool (*is_valid)(int),
UnknownFieldSet* unknown_fields,
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r13
movq %rcx, -0x38(%rbp)
movq %rdx, %r12
movl %esi, -0x30(%rbp)
movq %rdi, %rbx
movq (%rdi), %rax
cmpq 0x8(%rdi), %rax
jae 0x22f60a
movzbl (%rax), %esi
testb %sil, %sil
js 0x22f60c
incq %rax
movq %rax, (%rbx)... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wire_format.cc |
google::protobuf::internal::WireFormat::MessageSetItemByteSize(google::protobuf::FieldDescriptor const*, google::protobuf::Message const&) | size_t WireFormat::MessageSetItemByteSize(const FieldDescriptor* field,
const Message& message) {
const Reflection* message_reflection = message.GetReflection();
size_t our_size = WireFormatLite::kMessageSetItemTagsSize;
// type_id
our_size += io::CodedOutputStream::V... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x98(%rax)
movq %rdx, %rdi
movq 0x87d6f(%rip), %r15 # 0x2be2e0
movl 0x44(%r14), %eax
orl $0x1, %eax
bsrl %eax, %eax
leal (%rax,%rax,8), %r12d
addl $0x49, %r12d
shrl $0x6, %... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wire_format.cc |
google::protobuf::internal::MapKeyDataOnlyByteSize(google::protobuf::FieldDescriptor const*, google::protobuf::MapKey const&) | static size_t MapKeyDataOnlyByteSize(const FieldDescriptor* field,
const MapKey& value) {
GOOGLE_DCHECK_EQ(FieldDescriptor::TypeToCppType(field->type()), value.type());
switch (field->type()) {
case FieldDescriptor::TYPE_DOUBLE:
case FieldDescriptor::TYPE_FLOAT:
case... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x2365f6
movq 0x87b65(%rip), %rax # 0x2be148
leaq -0x58(%rbp), %rsi
movq %rax, (%rsi)
leaq -0x20(%rbp), %rdx
movq %r14, (%rdx)
callq 0x1051d0
movl 0x38(%r14), %eax
m... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wire_format.cc |
google::protobuf::internal::MapValueRefDataOnlyByteSize(google::protobuf::FieldDescriptor const*, google::protobuf::MapValueRef const&) | static size_t MapValueRefDataOnlyByteSize(const FieldDescriptor* field,
const MapValueRef& value) {
switch (field->type()) {
case FieldDescriptor::TYPE_GROUP:
GOOGLE_LOG(FATAL) << "Unsupported";
return 0;
#define CASE_TYPE(FieldType, CamelFieldType, CamelCppTy... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x236830
movq 0x8792b(%rip), %rax # 0x2be148
leaq -0x50(%rbp), %rsi
movq %rax, (%rsi)
leaq -0x18(%rbp), %rdx
movq %r14, (%rdx)
callq 0x1051d0
movl 0x38(%r14), %eax
decl %eax
cm... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wire_format.cc |
bool google::protobuf::internal::WireFormatLite::ReadGroup<google::protobuf::Message>(int, google::protobuf::io::CodedInputStream*, google::protobuf::Message*) | inline bool WireFormatLite::ReadGroup(int field_number,
io::CodedInputStream* input,
MessageType* value) {
if (!input->IncrementRecursionDepth()) return false;
if (!value->MergePartialFromCodedStream(input)) return false;
input->UnsafeDec... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x34(%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x34(%rsi)
testl %eax, %eax
jle 0x236b2d
movq %rsi, %rbx
movl %edi, %r14d
movq %rdx, %rdi
callq 0xfe4e0
testb %al, %al
je 0x236b2d
movl 0x34(%rbx), %eax
cmpl 0x38(%rbx), %eax
jge 0x236b34
incl %eax
movl %eax, 0x34(%r... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wire_format_lite.h |
InitDefaultsscc_info_BoolValue_google_2fprotobuf_2fwrappers_2eproto() | PROTOBUF_NAMESPACE_CLOSE
static void InitDefaultsscc_info_BoolValue_google_2fprotobuf_2fwrappers_2eproto() {
GOOGLE_PROTOBUF_VERIFY_VERSION;
{
void* ptr = &PROTOBUF_NAMESPACE_ID::_BoolValue_default_instance_;
new (ptr) PROTOBUF_NAMESPACE_ID::BoolValue();
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDes... | pushq %rbp
movq %rsp, %rbp
leaq 0x1e5bd(%rip), %rdx # 0x257814
movl $0x2df5a4, %edi # imm = 0x2DF5A4
movl $0x2df5a0, %esi # imm = 0x2DF5A0
callq 0x101680
movq 0x859e3(%rip), %rsi # 0x2bec50
movq $0x0, 0x8(%rsi)
movq 0x85454(%rip), %rax # 0x2be6d0
addq $0x10, %rax
movq %rax, (%rsi)
movl $0x0,... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wrappers.pb.cc |
google::protobuf::FloatValue::FloatValue(google::protobuf::FloatValue const&) | FloatValue::FloatValue(const FloatValue& from)
: ::PROTOBUF_NAMESPACE_ID::Message() {
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
value_ = from.value_;
// @@protoc_insertion_point(copy_constructor:google.protobuf.FloatValue)
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
movq 0x84c1c(%rip), %rax # 0x2be738
addq $0x10, %rax
movq %rax, (%rdi)
movl $0x0, 0x14(%rdi)
movq 0x8(%rsi), %rsi
testb $0x1, %sil
je 0x239b45
leaq 0x8(%rbx), %rdi
andq $-0x2, %rsi
addq $0x8, %rsi
callq 0x100c00
mo... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wrappers.pb.cc |
google::protobuf::Int64Value::_InternalSerialize(unsigned char*, google::protobuf::io::EpsCopyOutputStream*) const | ::PROTOBUF_NAMESPACE_ID::uint8* Int64Value::_InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
// @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Int64Value)
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void)... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x23a3c1
cmpq %rsi, (%rbx)
jbe 0x23a3e7
movb $0x8, (%rsi)
cmpq $0x7f, %rcx
ja 0x23a37f
movb %cl, 0x1(%rsi)
addq $0x2, %rsi
jmp 0x23a3c1
movl %ecx, %eax
orb $-0x80, %al
movb %al, 0x1(%rsi)
movq %rcx... | /LLNL[P]wcs/build_O3/src/src/google/protobuf/wrappers.pb.cc |
get_model_or_exit(int, char**) | char * get_model_or_exit(int argc, char *argv[]) {
char * model_path;
if (argc > 1) {
model_path = argv[1];
} else {
model_path = getenv("LLAMACPP_TEST_MODELFILE");
if (!model_path || strlen(model_path) == 0) {
fprintf(stderr, "\033[33mWARNING: No model file provided. Sk... | pushq %rax
cmpl $0x2, %edi
jl 0x1a74
movq 0x8(%rsi), %rax
jmp 0x1a8a
leaq 0x6ef(%rip), %rdi # 0x216a
callq 0x1110
testq %rax, %rax
je 0x1a8c
cmpb $0x0, (%rax)
je 0x1a8c
popq %rcx
retq
callq 0x11b0
| /ggerganov[P]llama/tests/get-model.cpp |
void test_2d_static<30ul, 1ul>() | void test_2d_static()
{ // {{{
layout_mapping_right<
dimensions<X, Y>, dimensions<1, 1>, dimensions<0, 0>
> const l{};
BOOST_TEST_EQ((l.is_regular()), true);
BOOST_TEST_EQ((l.stride(0)), 1);
BOOST_TEST_EQ((l.stride(1)), 1);
BOOST_TEST_EQ((l.size()), X * Y);
BOOST_TEST_EQ((l.span()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movb $0x1, %al
leaq 0x30(%rsp), %r15
movb %al, (%r15)
leaq 0x18(%rsp), %rbp
movb %al, (%rbp)
movq %rbp, (%rsp)
leaq 0xc263(%rip), %rdi # 0x11004
leaq 0xc26d(%rip), %rsi # 0x11015
leaq 0xc26b(%rip), %rb... | /brycelelbach[P]mdspan/tests/test_layout_mapping_right_basics.cpp |
void test_3d_static<30ul, 1ul, 1ul>() | void test_3d_static()
{ // {{{
layout_mapping_right<
dimensions<X, Y, Z>, dimensions<1, 1, 1>, dimensions<0, 0, 0>
> const l{};
BOOST_TEST_EQ((l.is_regular()), true);
BOOST_TEST_EQ((l.stride(0)), 1);
BOOST_TEST_EQ((l.stride(1)), 1);
BOOST_TEST_EQ((l.stride(2)), 1);
BOOST_TEST_EQ(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movb $0x1, %al
leaq 0x30(%rsp), %r15
movb %al, (%r15)
leaq 0x18(%rsp), %rbp
movb %al, (%rbp)
movq %rbp, (%rsp)
leaq 0x864b(%rip), %rdi # 0x11004
leaq 0x8655(%rip), %rsi # 0x11015
leaq 0x8653(%rip), %rb... | /brycelelbach[P]mdspan/tests/test_layout_mapping_right_basics.cpp |
void test_3d_dynamic<1ul, 30ul, 30ul>() | void test_3d_dynamic()
{ // {{{
layout_mapping_right<
dimensions<dyn, dyn, dyn>, dimensions<1, 1, 1>, dimensions<0, 0, 0>
> const l{{X, Y, Z}};
BOOST_TEST_EQ((l.is_regular()), true);
BOOST_TEST_EQ((l.stride(0)), 1);
BOOST_TEST_EQ((l.stride(1)), 1);
BOOST_TEST_EQ((l.stride(2)), 1);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movb $0x1, %al
leaq 0x18(%rsp), %r15
movb %al, (%r15)
leaq 0x30(%rsp), %rbp
movb %al, (%rbp)
movq %rbp, (%rsp)
leaq 0x40d0(%rip), %rdi # 0x11004
leaq 0x40da(%rip), %rsi # 0x11015
leaq 0x40d8(%rip), %rbx # 0x1101a
leaq 0x4c... | /brycelelbach[P]mdspan/tests/test_layout_mapping_right_basics.cpp |
void test_3d_dynamic<30ul, 15ul, 15ul>() | void test_3d_dynamic()
{ // {{{
layout_mapping_right<
dimensions<dyn, dyn, dyn>, dimensions<1, 1, 1>, dimensions<0, 0, 0>
> const l{{X, Y, Z}};
BOOST_TEST_EQ((l.is_regular()), true);
BOOST_TEST_EQ((l.stride(0)), 1);
BOOST_TEST_EQ((l.stride(1)), 1);
BOOST_TEST_EQ((l.stride(2)), 1);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movb $0x1, %al
leaq 0x18(%rsp), %r15
movb %al, (%r15)
leaq 0x30(%rsp), %rbp
movb %al, (%rbp)
movq %rbp, (%rsp)
leaq 0x30e6(%rip), %rdi # 0x11004
leaq 0x30f0(%rip), %rsi # 0x11015
leaq 0x30ee(%rip), %rbx # 0x1101a
leaq 0x3d... | /brycelelbach[P]mdspan/tests/test_layout_mapping_right_basics.cpp |
void test_3d_dynamic<15ul, 30ul, 15ul>() | void test_3d_dynamic()
{ // {{{
layout_mapping_right<
dimensions<dyn, dyn, dyn>, dimensions<1, 1, 1>, dimensions<0, 0, 0>
> const l{{X, Y, Z}};
BOOST_TEST_EQ((l.is_regular()), true);
BOOST_TEST_EQ((l.stride(0)), 1);
BOOST_TEST_EQ((l.stride(1)), 1);
BOOST_TEST_EQ((l.stride(2)), 1);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movb $0x1, %al
leaq 0x18(%rsp), %r15
movb %al, (%r15)
leaq 0x30(%rsp), %rbp
movb %al, (%rbp)
movq %rbp, (%rsp)
leaq 0x2b60(%rip), %rdi # 0x11004
leaq 0x2b6a(%rip), %rsi # 0x11015
leaq 0x2b68(%rip), %rbx # 0x1101a
leaq 0x38... | /brycelelbach[P]mdspan/tests/test_layout_mapping_right_basics.cpp |
test_exts() | static int
test_exts(void)
{
plan(25*9 + 11);
header();
test_ext(0x01);
test_ext(0x02);
test_ext(0x03);
test_ext(0x04);
test_ext(0x05);
test_ext(0x06);
test_ext(0x07);
test_ext(0x08);
test_ext(0x09);
test_ext(0x0a);
test_ext(0x0b);
test_ext(0x0c);
test_ext(0x0d);
test_ext(0x0e);
test_ext(0x0f);
test_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl $0xec, %edi
movl $0x1, %esi
callq 0x3a1f5
movq 0x33fcd(%rip), %rbx # 0x5afc0
movq (%rbx), %rdi
callq 0x3a1b8
leaq 0x1a15a(%rip), %rdi # 0x4115c
leaq 0x272b6(%rip), %rsi # 0x4e2bf
xorl %eax, %eax
callq 0x3030
movq (%rbx),... | /tarantool[P]msgpuck/test/msgpuck.cc |
mp_decode_extl | MP_IMPL uint32_t
mp_decode_extl(const char **data, int8_t *type) {
uint8_t c = mp_load_u8(data);
uint32_t len;
switch (c) {
case 0xd4:
case 0xd5:
case 0xd6:
case 0xd7:
case 0xd8:
len = 1u << (c - 0xd4);
break;
case 0xc7:
len = mp_load_u8(data);
break;
case 0xc8:
len = mp_load_u16(data);
break;
... | movq (%rdi), %r8
movzbl (%r8), %ecx
leaq 0x1(%r8), %rdx
movq %rdx, (%rdi)
leal -0xc7(%rcx), %eax
cmpl $0x11, %eax
ja 0x3ac94
leaq 0x1a43a(%rip), %r9 # 0x55084
movslq (%r9,%rax,4), %rax
addq %r9, %rax
jmpq *%rax
addb $0x2c, %cl
movl $0x1, %eax
shll %cl, %eax
jmp 0x3ac89
movl 0x1(%r8), %eax
bswapl %eax
addq $0x5, %r... | /tarantool[P]msgpuck/msgpuck.h |
mp_decode_ext | MP_IMPL const char *
mp_decode_ext(const char **data, int8_t *type, uint32_t *len) {
assert(len != NULL);
*len = mp_decode_extl(data, type);
const char *str = *data;
*data += *len;
return str;
} | pushq %rax
testq %rdx, %rdx
je 0x3ad43
movq (%rdi), %r9
movzbl (%r9), %ecx
leaq 0x1(%r9), %rax
movq %rax, (%rdi)
leal -0xc7(%rcx), %r8d
cmpl $0x11, %r8d
ja 0x3ad62
leaq 0x1a3e8(%rip), %r10 # 0x550cc
movslq (%r10,%r8,4), %r8
addq %r10, %r8
jmpq *%r8
addb $0x2c, %cl
movl $0x1, %r8d
shll %cl, %r8d
jmp 0x3ad28
movl 0x1... | /tarantool[P]msgpuck/msgpuck.h |
mp_encode_str0 | MP_IMPL char *
mp_encode_str0(char *data, const char *str)
{
return mp_encode_str(data, str, strlen(str));
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3050
cmpl $0x1f, %eax
ja 0x3b8a9
movl %eax, %ecx
orb $-0x60, %cl
movb %cl, (%rbx)
movl $0x1, %ecx
jmp 0x3b8e7
cmpl $0xff, %eax
ja 0x3b8bd
movb $-0x27, (%rbx)
movb %al, 0x1(%rbx)
movl $0x2, %ecx
jmp 0x3b8e7
cmpl $0xffff, %eax ... | /tarantool[P]msgpuck/msgpuck.h |
key_callback | static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
printf("%0.2f Key %s\n",
glfwGetTime(),
action == GLFW_PRESS ? "pressed" : "released");
if (action != GLFW_PRESS)
return;
switch (key)
{
case GLFW_KEY_I:
glfwIc... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
callq 0x20a91
cmpl $0x1, %r15d
leaq 0x191cb(%rip), %rax # 0x2f086
leaq 0x191cc(%rip), %rsi # 0x2f08e
cmoveq %rax, %rsi
leaq 0x191ab(%rip), %rdi # 0x2f078
movb $0x1, %al
callq 0x15090
cmpl... | /Rodousse[P]SSSGems/third_party/glfw/tests/iconify.c |
glfwIsValidContextConfig | GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
{
if (ctxconfig->share)
{
if (ctxconfig->client == GLFW_NO_API ||
ctxconfig->share->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return GLFW_FALSE;
}... | pushq %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1d640
cmpl $0x0, (%rdi)
je 0x1d6b6
cmpl $0x0, 0x1f8(%rax)
je 0x1d6b6
movl 0x4(%rdi), %edx
leal -0x36001(%rdx), %eax
cmpl $0x3, %eax
jae 0x1d6cb
movl (%rdi), %edx
testl %edx, %edx
je 0x1d7a5
cmpl $0x30001, %edx # imm = 0x30001
je 0x1d6e5
cmpl $0x30002, %edx... | /Rodousse[P]SSSGems/third_party/glfw/src/context.c |
glfwSwapBuffers | GLFWAPI void glfwSwapBuffers(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT,
"Cannot swap buffers of a window that h... | testq %rdi, %rdi
je 0x1e051
leaq 0x3da27(%rip), %rax # 0x5ba48
cmpl $0x0, (%rax)
je 0x1e035
cmpl $0x0, 0x1f8(%rdi)
je 0x1e03e
jmpq *0x248(%rdi)
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
jmp 0x1e04a
leaq 0x14467(%rip), %rsi # 0x324ac
movl $0x1000a, %edi # imm = 0x1000A
xorl %eax, %eax... | /Rodousse[P]SSSGems/third_party/glfw/src/context.c |
glfwGetError | GLFWAPI int glfwGetError(const char** description)
{
_GLFWerror* error;
int code = GLFW_NO_ERROR;
if (description)
*description = NULL;
if (_glfw.initialized)
error = _glfwPlatformGetTls(&_glfw.errorSlot);
else
error = &_glfwMainThreadError;
if (error)
{
co... | pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1e761
movq $0x0, (%rbx)
leaq 0x3d2e0(%rip), %rax # 0x5ba48
cmpl $0x0, (%rax)
je 0x1e787
movl $0x1fe14, %edi # imm = 0x1FE14
addq 0x3a85f(%rip), %rdi # 0x58fd8
callq 0x2b599
testq %rax, %rax
jne 0x1e78e
xorl %ecx, %ecx
jmp 0x1e7b4
leaq 0x5e332(%rip), %rax... | /Rodousse[P]SSSGems/third_party/glfw/src/init.c |
glfwInputChar | void _glfwInputChar(_GLFWwindow* window, unsigned int codepoint, int mods, GLFWbool plain)
{
if (codepoint < 32 || (codepoint > 126 && codepoint < 160))
return;
if (!window->lockKeyMods)
mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
if (window->callbacks.charmods)
window->call... | pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movl %esi, %ebx
cmpl $0x20, %esi
setb %al
leal -0x7f(%rbx), %ecx
cmpl $0x21, %ecx
setb %cl
orb %al, %cl
jne 0x1e8a0
movq %rdi, %r14
movq 0x330(%rdi), %rcx
testq %rcx, %rcx
je 0x1e885
movl %edx, %eax
andl $-0x31, %eax
cmpl $0x0, 0x70(%r14)
cmovnel %edx, %eax
movq %r14, %r... | /Rodousse[P]SSSGems/third_party/glfw/src/input.c |
glfwGetInputMode | GLFWAPI int glfwGetInputMode(GLFWwindow* handle, int mode)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(0);
switch (mode)
{
case GLFW_CURSOR:
return window->cursorMode;
case GLFW_STICKY_KEYS:
return wind... | pushq %rbx
testq %rdi, %rdi
je 0x1ec4a
leaq 0x3ce67(%rip), %rax # 0x5ba48
cmpl $0x0, (%rax)
je 0x1ec08
movl %esi, %edx
leal -0x33001(%rdx), %eax
cmpl $0x4, %eax
ja 0x1ec31
leaq 0x2ebbe(%rip), %rcx # 0x4d7b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x74(%rdi), %ebx
jmp 0x1ec46
xorl %ebx, %ebx
m... | /Rodousse[P]SSSGems/third_party/glfw/src/input.c |
glfwGetKeyName | GLFWAPI const char* glfwGetKeyName(int key, int scancode)
{
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (key != GLFW_KEY_UNKNOWN)
{
if (key != GLFW_KEY_KP_EQUAL &&
(key < GLFW_KEY_KP_0 || key > GLFW_KEY_KP_ADD) &&
(key < GLFW_KEY_APOSTROPHE || key > GLFW_KEY_WORLD_2))
{
... | pushq %rax
leaq 0x3cafd(%rip), %rax # 0x5ba48
cmpl $0x0, (%rax)
je 0x1ef88
cmpl $-0x1, %edi
je 0x1ef80
cmpl $0x150, %edi # imm = 0x150
je 0x1ef79
leal -0x14f(%rdi), %eax
cmpl $-0xf, %eax
setb %al
leal -0xa3(%rdi), %ecx
cmpl $-0x7c, %ecx
setb %cl
testb %cl, %al
jne 0x1ef96
callq 0x2ab1f
movl %eax, %esi
mo... | /Rodousse[P]SSSGems/third_party/glfw/src/input.c |
glfwGetMouseButton | GLFWAPI int glfwGetMouseButton(GLFWwindow* handle, int button)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
if (button < GLFW_MOUSE_BUTTON_1 || button > GLFW_MOUSE_BUTTON_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Inval... | pushq %rbx
testq %rdi, %rdi
je 0x1f0d1
leaq 0x3c9c6(%rip), %rax # 0x5ba48
cmpl $0x0, (%rax)
je 0x1f0a5
movl %esi, %edx
cmpl $0x8, %esi
jb 0x1f0b7
leaq 0x2e991(%rip), %rsi # 0x4da26
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x1e17d
jmp 0x1f0cd
xorl %ebx, %ebx
movl $0x1000... | /Rodousse[P]SSSGems/third_party/glfw/src/input.c |
glfwGetJoystickHats | char* glfwGetJoystickHats(int jid, int* count)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALI... | pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x1fa1f
cmpl $0x10, %edi
jae 0x1fa3e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1fa5d
movl $0x0, (%rbx)
leaq 0x3c088(%rip), %rax # 0x5ba48
cmpl $0x0, (%rax)
je 0x1fa04
movl %edi, %ecx
imulq $0x1fa0, %rcx, %rcx # imm = 0x1FA0
cmpl $0x0, 0x408(%rax,%rcx)
je 0x1fa00
... | /Rodousse[P]SSSGems/third_party/glfw/src/input.c |
glfwJoystickIsGamepad | GLFWAPI int glfwJoystickIsGamepad(int jid)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
... | pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x2069c
cmpl $0x10, %edi
jae 0x206bb
leaq 0x3b409(%rip), %rax # 0x5ba48
cmpl $0x0, (%rax)
je 0x2067e
movl %edi, %ecx
imulq $0x1fa0, %rcx, %rcx # imm = 0x1FA0
cmpl $0x0, 0x408(%rax,%rcx)
je 0x20690
leaq (%rax,%rcx), %r14
addq $0x408, %r14 # imm = 0x... | /Rodousse[P]SSSGems/third_party/glfw/src/input.c |
glfwAllocMonitor | _GLFWmonitor* _glfwAllocMonitor(const char* name, int widthMM, int heightMM)
{
_GLFWmonitor* monitor = calloc(1, sizeof(_GLFWmonitor));
monitor->widthMM = widthMM;
monitor->heightMM = heightMM;
if (name)
monitor->name = _glfw_strdup(name);
return monitor;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movl $0x1, %edi
movl $0xa8, %esi
callq 0x157c0
movq %rax, %rbx
movl %r15d, 0x10(%rax)
movl %ebp, 0x14(%rax)
testq %r14, %r14
je 0x20e97
movq %r14, %rdi
callq 0x1e130
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
... | /Rodousse[P]SSSGems/third_party/glfw/src/monitor.c |
glfwGetMonitorPos | GLFWAPI void glfwGetMonitorPos(GLFWmonitor* handle, int* xpos, int* ypos)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
if (xpos)
*xpos = 0;
if (ypos)
*ypos = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetMonitorPos(monitor, xpos, ypos);
} | testq %rdi, %rdi
je 0x211f2
testq %rsi, %rsi
je 0x211c8
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x211d3
movl $0x0, (%rdx)
leaq 0x3a86e(%rip), %rax # 0x5ba48
cmpl $0x0, (%rax)
je 0x211e4
jmp 0x263b7
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x1e17d
pushq %rax
leaq 0x2cfa4(%rip), ... | /Rodousse[P]SSSGems/third_party/glfw/src/monitor.c |
glfwGetGammaRamp | GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* handle)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
_glfwFreeGammaArrays(&monitor->currentRamp);
if (!_glfwPlatformGetGammaRamp(monitor, &monitor->currentRamp))
ret... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2174d
leaq 0x3a33f(%rip), %rax # 0x5ba48
cmpl $0x0, (%rax)
je 0x21732
movq %rdi, %rbx
leaq 0x68(%rdi), %r14
movq %r14, %rdi
callq 0x20ea5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26901
xorl %ebx, %ebx
testl %eax, %eax
cmovneq %r14, %rbx
jmp 0x21742
xorl %ebx, %e... | /Rodousse[P]SSSGems/third_party/glfw/src/monitor.c |
glfwDefaultWindowHints | void glfwDefaultWindowHints(void)
{
_GLFW_REQUIRE_INIT();
// The default is OpenGL with minimum version 1.0
memset(&_glfw.hints.context, 0, sizeof(_glfw.hints.context));
_glfw.hints.context.client = GLFW_OPENGL_API;
_glfw.hints.context.source = GLFW_NATIVE_CONTEXT_API;
_glfw.hints.context.major... | pushq %rbx
leaq 0x396f1(%rip), %rbx # 0x5ba48
cmpl $0x0, (%rbx)
je 0x223fe
xorps %xmm0, %xmm0
movups %xmm0, 0x3c0(%rbx)
movups %xmm0, 0x3b0(%rbx)
movq $0x0, 0x3d0(%rbx)
movaps 0x2ca0d(%rip), %xmm0 # 0x4ed90
movups %xmm0, 0x3a0(%rbx)
leaq 0x60(%rbx), %rdi
movl $0x340, %edx # imm = 0x340
xorl %esi, %esi... | /Rodousse[P]SSSGems/third_party/glfw/src/window.c |
glfwGetWindowPropertyX11 | unsigned long _glfwGetWindowPropertyX11(Window window,
Atom property,
Atom type,
unsigned char** value)
{
Atom actualType;
int actualFormat;
unsigned long itemCount, bytesAfter;
XGetW... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rax
movq %rdx, %r10
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x34e78(%rip), %rcx # 0x5ba48
movq 0x1fec0(%rcx), %rdi
leaq 0x8(%rsp), %r11
leaq 0x10(%rsp), %rbx
leaq 0x4(%rsp), %r14
leaq 0x18(%rsp), %r15
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFF... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_window.c |
glfwPlatformCreateWindow | int _glfwPlatformCreateWindow(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig)
{
Visual* visual;
int depth;
if (ctxconfig->client != GLFW_NO_API)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
cmpl $0x0, (%rdx)
je 0x272eb
movl 0x4(%r13), %eax
cmpl $0x36003, %eax # imm = 0x36003
je 0x272cd
cmpl $0x36002, %eax # imm = 0x36... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_window.c |
releaseMonitor | static void releaseMonitor(_GLFWwindow* window)
{
if (window->monitor->window != window)
return;
_glfwInputMonitorWindow(window->monitor, NULL);
_glfwRestoreVideoModeX11(window->monitor);
_glfw.x11.saver.count--;
if (_glfw.x11.saver.count == 0)
{
// Restore old screen saver se... | pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
cmpq %rbx, 0x18(%rdi)
jne 0x27e3d
xorl %esi, %esi
callq 0x20e5a
movq 0x40(%rbx), %rdi
callq 0x262d6
leaq 0x33c13(%rip), %rax # 0x5ba48
decl 0x20d20(%rax)
je 0x27e3f
popq %rbx
retq
movq 0x1fec0(%rax), %rdi
movl 0x20d24(%rax), %esi
movl 0x20d28(%rax), %edx
movl 0x20d2c... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_window.c |
glfwPlatformSetWindowAspectRatio | void _glfwPlatformSetWindowAspectRatio(_GLFWwindow* window, int numer, int denom)
{
int width, height;
_glfwPlatformGetWindowSize(window, &width, &height);
updateNormalHints(window, width, height);
XFlush(_glfw.x11.display);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x335df(%rip), %r15 # 0x5ba48
movq 0x1fec0(%r15), %rdi
movq 0x348(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x15870
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
movq %rbx, %rdi
callq 0x28308
movq 0x1fec0(%r15), %rdi
callq 0x15650
addq ... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_window.c |
glfwPlatformMaximizeWindow | void _glfwPlatformMaximizeWindow(_GLFWwindow* window)
{
if (!_glfw.x11.NET_WM_STATE ||
!_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT ||
!_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
{
return;
}
if (_glfwPlatformWindowVisible(window))
{
sendEventToWM(window,
_g... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
leaq 0x330fd(%rip), %r15 # 0x5ba48
cmpq $0x0, 0x20b20(%r15)
je 0x28b04
cmpq $0x0, 0x20b38(%r15)
je 0x28b04
cmpq $0x0, 0x20b40(%r15)
je 0x28b04
movq %rdi, %rbx
movq 0x1fec0(%r15), %rdi
movq 0x348(%rbx), %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdx... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_window.c |
glfwPlatformFocusWindow | void _glfwPlatformFocusWindow(_GLFWwindow* window)
{
if (_glfw.x11.NET_ACTIVE_WINDOW)
sendEventToWM(window, _glfw.x11.NET_ACTIVE_WINDOW, 1, 0, 0, 0, 0);
else if (_glfwPlatformWindowVisible(window))
{
XRaiseWindow(_glfw.x11.display, window->x11.handle);
XSetInputFocus(_glfw.x11.displa... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq 0x32e4b(%rip), %r15 # 0x5ba48
movq 0x20b80(%r15), %r14
testq %r14, %r14
je 0x28c6f
movq 0x348(%rbx), %r12
leaq 0x8(%rsp), %rbx
movl $0xc0, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x150f0
movl $0x21, (%rbx)
movq %r12, 0x20(%rbx)
mov... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_window.c |
glfwPlatformGetWindowOpacity | float _glfwPlatformGetWindowOpacity(_GLFWwindow* window)
{
float opacity = 1.f;
if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.NET_WM_CM_Sx))
{
CARD32* value = NULL;
if (_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.NET_WM_WINDOW_OPACITY... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x3269d(%rip), %r15 # 0x5ba48
movq 0x1fec0(%r15), %rdi
movq 0x20b68(%r15), %rsi
callq 0x159c0
testq %rax, %rax
je 0x29438
leaq 0x10(%rsp), %r14
movq $0x0, (%r14)
movq 0x348(%rbx), %rsi
movq 0x20b60(%r15), %rdx
movq 0x1fec0(%r15), %rdi
leaq 0x18(... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_window.c |
glfwPlatformSetCursorPos | void _glfwPlatformSetCursorPos(_GLFWwindow* window, double x, double y)
{
// Store the new position so it can be recognized later
window->x11.warpCursorPosX = (int) x;
window->x11.warpCursorPosY = (int) y;
XWarpPointer(_glfw.x11.display, None, window->x11.handle,
0,0,0,0, (int) x, (int... | pushq %rbx
subq $0x20, %rsp
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
cvttpd2dq %xmm0, %xmm0
movlpd %xmm0, 0x388(%rdi)
leaq 0x3145d(%rip), %rbx # 0x5ba48
movq 0x1fec0(%rbx), %rax
movq 0x348(%rdi), %rdx
pshufd $0x55, %xmm0, %xmm1 # xmm1 = xmm0[1,1,1,1]
movd %xmm1, 0x10(%rsp)
movd %xmm0, 0x8(%rsp)... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_window.c |
updateCursorImage | static void updateCursorImage(_GLFWwindow* window)
{
if (window->cursorMode == GLFW_CURSOR_NORMAL)
{
if (window->cursor)
{
XDefineCursor(_glfw.x11.display, window->x11.handle,
window->cursor->x11.handle);
}
else
XUndefineCursor(_g... | cmpl $0x34001, 0x74(%rdi) # imm = 0x34001
jne 0x2a9a7
movq 0x48(%rdi), %rcx
leaq 0x310c0(%rip), %rax # 0x5ba48
movq 0x1fec0(%rax), %rax
movq 0x348(%rdi), %rsi
testq %rcx, %rcx
je 0x2a9c8
movq 0x8(%rcx), %rdx
movq %rax, %rdi
jmp 0x157b0
leaq 0x3109a(%rip), %rax # 0x5ba48
movq 0x348(%rdi), %rsi
movq 0x1fec0(%r... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_window.c |
glfwSetX11SelectionString | GLFWAPI void glfwSetX11SelectionString(const char* string)
{
_GLFW_REQUIRE_INIT();
free(_glfw.x11.primarySelectionString);
_glfw.x11.primarySelectionString = _glfw_strdup(string);
XSetSelectionOwner(_glfw.x11.display,
_glfw.x11.PRIMARY,
_glfw.x11.helperWin... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x307b3(%rip), %r14 # 0x5ba48
cmpl $0x0, (%r14)
je 0x2b2f9
movq %rdi, %rbx
movq 0x1ff08(%r14), %rdi
callq 0x153e0
movq %rbx, %rdi
callq 0x1e130
movq %rax, 0x1ff08(%r14)
movq 0x20c10(%r14), %rsi
movq 0x1fec0(%r14), %rdi
movq 0x1fee0(%r14), %rdx
xorl %ecx, %ecx
callq 0x15680
movq... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_window.c |
makeContextCurrentEGL | static void makeContextCurrentEGL(_GLFWwindow* window)
{
if (window)
{
if (!eglMakeCurrent(_glfw.egl.display,
window->context.egl.surface,
window->context.egl.surface,
window->context.egl.handle))
{
_... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2e6b5(%rip), %r14 # 0x5ba48
movq 0x20f88(%r14), %rdi
movq 0x21010(%r14), %rax
testq %rbx, %rbx
je 0x2d3d4
movq 0x288(%rbx), %rcx
movq 0x290(%rbx), %rdx
movq %rdx, %rsi
callq *%rax
testl %eax, %eax
jne 0x2d3e0
callq *0x20fd0(%r14)
movl %eax, %edi
callq 0x2cb18
... | /Rodousse[P]SSSGems/third_party/glfw/src/egl_context.c |
destroyContextEGL | static void destroyContextEGL(_GLFWwindow* window)
{
#if defined(_GLFW_X11)
// NOTE: Do not unload libGL.so.1 while the X11 display is still open,
// as it will make XCloseDisplay segfault
if (window->context.client != GLFW_OPENGL_API)
#endif // _GLFW_X11
{
if (window->context.egl.client)
... | pushq %rbx
movq %rdi, %rbx
cmpl $0x30001, 0x1f8(%rdi) # imm = 0x30001
je 0x2d4f9
movq 0x298(%rbx), %rdi
testq %rdi, %rdi
je 0x2d4f9
callq 0x15a40
movq $0x0, 0x298(%rbx)
movq 0x290(%rbx), %rsi
testq %rsi, %rsi
je 0x2d524
leaq 0x2e53c(%rip), %rax # 0x5ba48
movq 0x20f88(%rax), %rdi
callq *0x20ff8(%rax)
movq $0x0, 0x... | /Rodousse[P]SSSGems/third_party/glfw/src/egl_context.c |
glfwPlatformPollJoystick | int _glfwPlatformPollJoystick(_GLFWjoystick* js, int mode)
{
// Read all queued events (non-blocking)
for (;;)
{
struct input_event e;
errno = 0;
if (read(js->linjs.fd, &e, sizeof(e)) < 0)
{
// Reset the joystick slot if the device was disconnected
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x15640
movq %rax, %r14
movl $0x0, (%rax)
movl 0x78(%rbx), %edi
leaq 0x8(%rsp), %rsi
movl $0x18, %edx
callq 0x15260
testq %rax, %rax
js 0x2e663
leaq 0x2d491(%rip), %r12 # 0x5ba48
leaq 0x8(%rsp), %r15
movzwl 0x18(%rsp), %eb... | /Rodousse[P]SSSGems/third_party/glfw/src/linux_joystick.c |
Ptex::v2_4::PtexReaderCache::logRecentlyUsed(Ptex::v2_4::PtexCachedReader*) | void PtexReaderCache::logRecentlyUsed(PtexCachedReader* reader)
{
while (1) {
MruList* mruList = _mruList;
int slot = AtomicIncrement(&mruList->next)-1;
if (slot < numMruFiles) {
mruList->files[slot] = reader;
return;
}
// no mru slot available, proces... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x480(%r14), %rax
movl $0x1, %ecx
lock
xaddl %ecx, (%rax)
leal 0x1(%rcx), %ebp
cmpl $0x33, %ebp
jl 0x5a40
movq %r14, %rdi
callq 0x5f7e
movq 0x480(%r14), %rax
movl (%rax), %eax
cmpl $0x31, %eax
jg 0x5a28
jmp 0x5a48
movslq %ecx, %rcx
movq %rbx, 0x8(%ra... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexCache.cpp |
Ptex::v2_4::PtexReaderCache::findFile(char const*&, 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 PtexReaderCache::findFile(const char*& filename, std::string& buffer, Ptex::String& error)
{
bool isAbsolute = (filename[0] == '/'
#ifdef PTEX_PLATFORM_WINDOWS
|| filename[0] == '\\'
|| (isalpha(filename[0]) && filename[1] == ':')
#endif
);
if (isAbsolute |... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, (%rsp)
movq (%rsi), %rax
movb $0x1, %bl
cmpb $0x2f, (%rax)
je 0x5bab
movq %rdi, %r13
movq 0x48(%rdi), %rax
cmpq 0x50(%rdi), %rax
je 0x5bab
movq %rdx, %r12
movq %rcx, 0x8(%rsp)
movl $0x100, %esi # imm = 0x100
movq %r... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexCache.cpp |
Ptex::v2_4::PtexReaderCache::purge(Ptex::v2_4::PtexTexture*) | void PtexReaderCache::purge(PtexTexture* texture)
{
PtexCachedReader* reader = static_cast<PtexCachedReader*>(texture);
reader->unref();
purge(reader);
reader->ref();
} | pushq %rbx
movq %rsi, %rbx
lock
decl 0x2d0(%rsi)
callq 0x5e82
movl 0x2d0(%rbx), %eax
testl %eax, %eax
js 0x631e
leal 0x1(%rax), %ecx
lock
cmpxchgl %ecx, 0x2d0(%rbx)
jne 0x631e
popq %rbx
retq
nop
| /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexCache.cpp |
Ptex::v2_4::PtexHashMap<Ptex::v2_4::StringKey, Ptex::v2_4::PtexCachedReader*>::get(Ptex::v2_4::StringKey&) | Value get(Key& key)
{
uint32_t mask = _numEntries-1;
Entry* entries = getEntries();
uint32_t hash = key.hash();
Value result = 0;
for (uint32_t i = hash;; ++i) {
Entry& e = entries[i & mask];
if (e.key.matches(key)) {
result = e.value;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %ebp
movq (%rdi), %rax
testq %rax, %rax
cmovneq %rax, %r15
je 0x65d9
decl %ebp
movl 0xc(%rbx), %r12d
xorl %r14d, %r14d
movl %r12d, %r13d
andl %ebp, %r13d
shlq $0x5, %r13
leaq (%r15,%r13), %rdi
movq %rbx, %rsi
ca... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexHashMap.h |
Ptex::v2_4::PtexLruList<Ptex::v2_4::PtexCachedReader, &Ptex::v2_4::PtexCachedReader::_activeFilesItem>::pop() | PtexLruItem* pop() {
if (_next == this) return 0;
PtexLruItem* item = _next;
_next->extract();
return item;
} | pushq %rbx
movq 0x8(%rdi), %rbx
cmpq %rdi, %rbx
je 0x68cc
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq (%rbx), %rax
movq %rcx, 0x8(%rax)
movq %rbx, (%rbx)
movq %rbx, 0x8(%rbx)
jmp 0x68ce
xorl %ebx, %ebx
movb 0x5f0dc(%rip), %al # 0x659b0
testb %al, %al
je 0x68eb
movq %rbx, %rax
subq 0x5f0c6(%rip), ... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexCache.h |
void Ptex::v2_4::PtexHashMap<Ptex::v2_4::StringKey, Ptex::v2_4::PtexCachedReader*>::foreach<Ptex::v2_4::PtexReaderCache::Purger>(Ptex::v2_4::PtexReaderCache::Purger&) | void foreach(Fn& fn)
{
Entry* entries = getEntries();
for (uint32_t i = 0; i < _numEntries; ++i) {
Value v = entries[i].value;
if (v) fn(v);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%r14), %rax
testq %rax, %rax
cmovneq %rax, %r15
je 0x6900
cmpl $0x0, 0x8(%r14)
je 0x693a
addq $0x18, %r15
xorl %r12d, %r12d
movq (%r15), %rsi
testq %rsi, %rsi
je 0x692a
movq %rbx, %rdi
callq 0x63a8
incq %r12
movl 0x8(%r14), %ea... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexHashMap.h |
Ptex::v2_4::StringKey::matches(Ptex::v2_4::StringKey const&) volatile | bool matches(const StringKey& key) volatile
{
return key._hash == _hash && key._len == _len && _val && 0 == memCompare(key._val, _val, _len);
} | movl 0xc(%rsi), %ecx
cmpl 0xc(%rdi), %ecx
jne 0x71b4
movq %rdi, %rax
movl 0x8(%rsi), %ecx
cmpl 0x8(%rdi), %ecx
jne 0x71b4
cmpq $0x0, (%rax)
je 0x71b4
pushq %rax
movq (%rsi), %rdi
movq (%rax), %rsi
movl 0x8(%rax), %edx
movl %edx, %eax
andl $-0x8, %eax
testl %eax, %eax
jle 0x719d
xorl %ecx, %ecx
movq (%rdi,%rcx), %r8
cmp... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexHashMap.h |
Ptex::v2_4::PtexHashMap<Ptex::v2_4::StringKey, Ptex::v2_4::PtexCachedReader*>::lockEntriesAndGrowIfNeeded(unsigned long&) | Entry* lockEntriesAndGrowIfNeeded(size_t& newMemUsed)
{
Entry* entries = lockEntries();
if (_size*2 >= _numEntries) {
entries = grow(entries, newMemUsed);
}
return entries;
} | movq %rsi, %rdx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x71d6
xorl %r8d, %r8d
movq %rsi, %rax
lock
cmpxchgq %r8, (%rdi)
je 0x71dc
movb $0x1, %r8b
movq %rcx, %rsi
movq %rsi, %rcx
testb %r8b, %r8b
jne 0x71c1
movl 0xc(%rdi), %eax
addl %eax, %eax
cmpl 0x8(%rdi), %eax
jae 0x71f6
movq %rsi, %rax
retq
| /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexHashMap.h |
Ptex::v2_4::PtexHashMap<Ptex::v2_4::StringKey, Ptex::v2_4::PtexCachedReader*>::grow(Ptex::v2_4::PtexHashMap<Ptex::v2_4::StringKey, Ptex::v2_4::PtexCachedReader*>::Entry*, unsigned long&) | Entry* grow(Entry* oldEntries, size_t& newMemUsed)
{
_oldEntries.push_back(oldEntries);
uint32_t numNewEntries = _numEntries*2;
Entry* entries = new Entry[numNewEntries];
newMemUsed = numNewEntries * sizeof(Entry);
uint32_t mask = numNewEntries-1;
for (uint32_t oldInd... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
movq %rsi, (%rsp)
movq 0x18(%rdi), %rsi
cmpq 0x20(%rdi), %rsi
je 0x721f
movq %rax, (%rsi)
addq $0x8, 0x18(%rbx)
jmp 0x722b
leaq 0x10(%rbx), %rdi
movq %rsp, %rdx
callq 0x72fa
movl 0x8(%rbx), %r15d
addl %r15d, %r15d
mov... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexHashMap.h |
Ptex::v2_4::PtexBicubicFilter::PtexBicubicFilter(Ptex::v2_4::PtexTexture*, Ptex::v2_4::PtexFilter::Options const&, float) | PtexBicubicFilter(PtexTexture* tx, const PtexFilter::Options& opts, float sharpness)
: PtexWidth4Filter(tx, opts, kernelFn, _coeffs)
{
// compute Cubic filter coefficients:
// abs(x) < 1:
// 1/6 * ((12 - 9*B - 6*C)*x^3 + (-18 + 12*B + 6*C)*x^2 + (6 - 2*B))
// == c[0]*x^3 ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
leaq 0x1cea7(%rip), %r14 # 0x245c8
movq %r14, (%rdi)
leaq 0x60(%rdi), %r15
callq 0x787a
leaq 0xd66(%rip), %rax # 0x849a
movq %rax, 0x50(%rbx)
movq %r15, 0x58(%rbx)
movq %r14, (%rbx)
movss 0x148c1(%rip), %xmm0 # 0x1c008... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexFilters.cpp |
Ptex::v2_4::PtexPointFilter::release() | virtual void eval(float* result, int firstchan, int nchannels,
int faceid, float u, float v,
float /*uw1*/, float /*vw1*/, float /*uw2*/, float /*vw2*/,
float /*width*/, float /*blur*/)
{
if (!_tx || nchannels <= 0) return;
if (faceid... | movq (%rdi), %rax
jmpq *0x8(%rax)
| /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexFilters.cpp |
Ptex::v2_4::PtexBilinearFilter::buildKernel(Ptex::v2_4::PtexSeparableKernel&, float, float, float, float, Ptex::v2_4::Res) | virtual void buildKernel(PtexSeparableKernel& k, float u, float v, float uw, float vw,
Res faceRes)
{
// clamp filter width to no larger than 1.0
uw = PtexUtils::min(uw, 1.0f);
vw = PtexUtils::min(vw, 1.0f);
// clamp filter width to no smaller than a tex... | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movzbl %dh, %eax
movd %eax, %xmm4
pinsrw $0x2, %edx, %xmm4
unpcklps %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
minps 0x14872(%rip), %xmm3 # 0x1c1a0
pslld $0x18, %xmm4
psrad $0x1, %xmm4
movdqa 0x14860(%rip), %xmm5 # 0x1c1a0
psubd %xmm4, %xmm5
movdqa... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexFilters.cpp |
Ptex::v2_4::PtexReader::readBlock(void*, int, bool) | bool PtexReader::readBlock(void* data, int size, bool reporterror)
{
assert(_fp && size >= 0);
if (!_fp || size < 0) return false;
int result = (int)_io->read(data, size, _fp);
if (result == size) {
_pos += size;
return true;
}
if (reporterror)
setError("PtexReader error:... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq 0x58(%rdi), %rcx
testq %rcx, %rcx
sete %al
testl %edx, %edx
sets %dl
orb %al, %dl
je 0x928d
xorl %eax, %eax
jmp 0x92ab
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
movl %r14d, %r15d
movq (%rdi), %rax
movq %r15, %rdx
callq *0x20(%rax)
... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.cpp |
Ptex::v2_4::PtexReader::readZipBlock(void*, int, int) | bool PtexReader::readZipBlock(void* data, int zipsize, int unzipsize)
{
if (zipsize < 0 || unzipsize < 0) return false;
if (!_zstream.state) {
inflateInit(&_zstream);
}
void* buff = alloca(BlockSize);
_zstream.next_out = (Bytef*) data;
_zstream.avail_out = unzipsize;
while (1) {
... | movl %ecx, %eax
orl %edx, %eax
js 0x9946
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x238(%rdi), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x270(%rdi)
jne 0x9881
leaq 0x12b99(%rip), %rsi # 0x1... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.cpp |
Ptex::v2_4::PtexReader::MetaData::getEntry(int) | PtexReader::MetaData::Entry*
PtexReader::MetaData::getEntry(int index)
{
if (index < 0 || index >= int(_entries.size())) {
return 0;
}
Entry* e = _entries[index];
if (!e->isLmd) {
// normal (small) meta data - just return directly
return e;
}
// large meta data - may no... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x9ba9
movq %rdi, %r15
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
cmpl %esi, %ecx
jle 0x9ba9
movl %esi, %ecx
movq (%rax,%rcx,8), %rbx
cmpb $0x1, 0x18(%rbx)
jne 0x9bab
cmpq $0x0, 0x20(%rbx)
jne 0x9bab
movq 0x8(%r1... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.cpp |
Ptex::v2_4::PtexReader::readFaceData(long, Ptex::v2_4::FaceDataHeader, Ptex::v2_4::Res, int, Ptex::v2_4::PtexReader::FaceData*&) | void PtexReader::readFaceData(FilePos pos, FaceDataHeader fdh, Res res, int levelid,
FaceData*& face)
{
AutoMutex locker(readlock);
if (face) {
return;
}
// keep new face local until fully initialized
FaceData* newface = 0;
size_t newMemUsed = 0;
seek(... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r13
movl %r8d, -0x30(%rbp)
movl %ecx, %r12d
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
addq $0x8, %rdi
movq %rdi, -0x58(%rbp)
callq 0x5360
cmpq $0x0, (%r13)
jne 0xa4e8
movl %ebx, -0x38(%rbp)
movl %r12d, -0... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.cpp |
Ptex::v2_4::PtexReader::PackedFace::reduce(Ptex::v2_4::PtexReader*, Ptex::v2_4::Res, void (*)(void const*, int, int, int, void*, int, Ptex::v2_4::DataType, int), unsigned long&) | PtexReader::FaceData*
PtexReader::PackedFace::reduce(PtexReader* r, Res newres, PtexUtils::ReduceFn reducefn,
size_t& newMemUsed)
{
// allocate a new face and reduce image
DataType dt = r->datatype();
int nchan = r->nchannels();
int memsize = _pixelsize * newres.size();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, 0x20(%rsp)
movl %edx, %r14d
movq %rdi, %rbx
movl %edx, %eax
shrl $0x8, %eax
movl 0x94(%rsi), %ecx
movq %rcx, 0x18(%rsp)
movzwl 0x9c(%rsi), %ecx
movq %rcx, 0x10(%rsp)
movl 0xc(%rdi), %ebp
movl $0x1, %r12d
mo... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.cpp |
Ptex::v2_4::PtexReader::TiledFaceBase::getPixel(int, int, void*) | void PtexReader::TiledFaceBase::getPixel(int ui, int vi, void* result)
{
int tileu = ui >> _tileres.ulog2;
int tilev = vi >> _tileres.vlog2;
PtexPtr<PtexFaceData> tile ( getTile(tilev * _ntilesu + tileu) );
tile->getPixel(ui - (tileu<<_tileres.ulog2),
vi - (tilev<<_tileres.vlog2), res... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movb 0x18(%rdi), %cl
movl %esi, %r12d
sarl %cl, %r12d
movl %edx, %r14d
movb 0x19(%rdi), %cl
movl %edx, %r13d
sarl %cl, %r13d
movl 0x24(%rdi), %esi
imull %r13d, %esi
addl %r12d, %esi
movq (%rdi), ... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.cpp |
Ptex::v2_4::PtexReader::Level::Level(int) | Level(int nfaces)
: fdh(nfaces),
offsets(nfaces),
faces(nfaces) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq %esi, %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0xd07c
leaq 0x18(%rbx), %r15
leaq 0xe(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xd0f4
leaq 0x30(%rbx), %rdi
leaq 0xd(%rsp), %rdx
movq %r14, %rsi
callq 0xd17e
addq $0x10, %rsp
popq %rbx... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.h |
Ptex::v2_4::PtexReader::getFace(int, Ptex::v2_4::PtexReader::Level*, int, Ptex::v2_4::Res) | FaceData* getFace(int levelid, Level* level, int faceid, Res res)
{
FaceData*& face = level->faces[faceid];
if (!face) readFace(levelid, level, faceid, res);
return face;
} | pushq %rbx
movl %esi, %eax
movslq %ecx, %rcx
movq 0x30(%rdx), %rsi
leaq (%rsi,%rcx,8), %rbx
cmpq $0x0, (%rbx)
jne 0xc122
movq (%rdx), %rsi
movq 0x18(%rdx), %r9
movl (%rsi,%rcx,4), %edx
movq (%r9,%rcx,8), %rsi
movl %r8d, %ecx
movl %eax, %r8d
movq %rbx, %r9
callq 0xa15c
movq (%rbx), %rax
popq %rbx
retq
nop
| /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.h |
Ptex::v2_4::PtexHashMap<Ptex::v2_4::PtexReader::ReductionKey, Ptex::v2_4::PtexReader::FaceData*>::tryInsert(Ptex::v2_4::PtexReader::ReductionKey&, Ptex::v2_4::PtexReader::FaceData*, unsigned long&) | Value tryInsert(Key& key, Value value, size_t& newMemUsed)
{
Entry* entries = lockEntriesAndGrowIfNeeded(newMemUsed);
uint32_t mask = _numEntries-1;
uint32_t hash = key.hash();
Value result = 0;
for (uint32_t i = hash;; ++i) {
Entry& e = entries[i & mask];
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, %rsi
callq 0xe2d8
movl 0x8(%rbx), %edx
decl %edx
movq (%r15), %rsi
xorl %ecx, %ecx
movl %esi, %r8d
andl %edx, %r8d
shlq $0x4, %r8
leaq (%rax,%r8), %rdi
cmpq $0x0, 0x8(%rax,%r8)
je 0xc174
movq (%rdi), %r8
cmpq $-0x1, %r8
je 0xc15... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexHashMap.h |
Ptex::v2_4::PtexReader::MetaData::getValue(int, char const*&) | virtual void getValue(int index, const char*& value)
{
if (index < 0 || index >= int(_entries.size())) { value = 0; return; }
Entry* e = getEntry(index);
if (e && e->type == mdt_string) value = (const char*) e->data;
else value = 0;
} | pushq %rbx
movq %rdx, %rbx
testl %esi, %esi
js 0xc5b6
movq 0x48(%rdi), %rax
subq 0x40(%rdi), %rax
shrq $0x3, %rax
cmpl %esi, %eax
jle 0xc5b6
callq 0x9ae2
testq %rax, %rax
je 0xc5b6
cmpl $0x0, 0x8(%rax)
je 0xc5bd
xorl %eax, %eax
movq %rax, (%rbx)
popq %rbx
retq
movq 0x10(%rax), %rax
jmp 0xc5b8
nop
| /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.h |
Ptex::v2_4::PtexReader::MetaData::Entry::clear() | void clear() {
if (isLmd) {
isLmd = 0;
if (lmdData) { delete lmdData; lmdData = 0; }
lmdPos = 0;
lmdZipSize = 0;
}
else {
if (data) { delete [] data; }
}
data = 0;
} | pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x18(%rdi)
jne 0xc854
movb $0x0, 0x18(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xc843
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
movl $0x0, 0x30(%rbx)
jmp 0xc862
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xc862
callq 0x5330
movq $0x0, 0x10... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.h |
void Ptex::v2_4::PtexReader::MetaData::getValue<double>(int, Ptex::v2_4::MetaDataType, double const*&, int&) | void getValue(int index, MetaDataType requestedType, const T*& value, int& count)
{
if (index < 0 || index >= int(_entries.size())) {
value = 0;
count = 0;
return;
}
Entry* e = getEntry(index);
if (e && e->type == requestedType) {
... | pushq %rbp
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
testl %esi, %esi
js 0xca6a
movq 0x48(%rdi), %rax
subq 0x40(%rdi), %rax
shrq $0x3, %rax
cmpl %esi, %eax
jle 0xca6a
movl %edx, %ebp
callq 0x9ae2
testq %rax, %rax
je 0xca6a
cmpl %ebp, 0x8(%rax)
jne 0xca6a
movq 0x10(%rax), %rcx
movq %rcx, (%r14)
movl 0xc(%rax)... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexReader.h |
Ptex::v2_4::PtexHashMap<Ptex::v2_4::PtexReader::ReductionKey, Ptex::v2_4::PtexReader::FaceData*>::deleteContents() | void deleteContents()
{
for (uint32_t i = 0; i < _numEntries; ++i) {
if (_entries[i].value) delete _entries[i].value;
}
delete [] _entries;
for (size_t i = 0; i < _oldEntries.size(); ++i) {
delete [] _oldEntries[i];
}
std::vector<Entry*>().swap... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0xd91a
movl $0x8, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
cmpq $0x0, (%rax,%r14)
je 0xd90b
movq (%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0xd90b
movq (%rdi), %rax
callq *0x8(%rax)
incq %r15
movl 0x8(%rbx), %eax
addq $0x10, %r14
cmp... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexHashMap.h |
Ptex::v2_4::PtexSeparableFilter::applyAcrossEdge(Ptex::v2_4::PtexSeparableKernel&, int, Ptex::v2_4::FaceInfo const&, int) | void PtexSeparableFilter::applyAcrossEdge(PtexSeparableKernel& k,
int faceid, const Ptex::FaceInfo& f, int eid)
{
int afid = f.adjface(eid), aeid = f.adjedge(eid);
const Ptex::FaceInfo* af = &_tx->getFaceInfo(afid);
int rot = eid - aeid + 2;
// adjust uv coord ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r13d
movq %rcx, %r14
movl %edx, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movslq %r8d, %r15
movl 0x4(%rcx,%r15,4), %esi
movzbl 0x2(%rcx), %ebx
leal (%r15,%r15), %ecx
shrl %cl, %ebx
movl %ebx, %ebp
andl $0x3, %ebp
movq %rdi, 0x10(%rsp)... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexSeparableFilter.cpp |
Ptex::v2_4::PtexSeparableFilter::applyToCornerFace(Ptex::v2_4::PtexSeparableKernel&, Ptex::v2_4::FaceInfo const&, int, int, Ptex::v2_4::FaceInfo const&, int) | void PtexSeparableFilter::applyToCornerFace(PtexSeparableKernel& k, const Ptex::FaceInfo& f, int eid,
int cfid, const Ptex::FaceInfo& cf, int ceid)
{
// adjust uv coord and res for face/subface boundary
bool fIsSubface = f.isSubface(), cfIsSubface = cf.isSubface();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, 0x4(%rsp)
movl %ecx, %r12d
movq %rsi, %r14
movq %rdi, %r15
movl 0x40(%rsp), %ebp
movb 0x3(%rdx), %al
andb $0x8, %al
shrb $0x3, %al
movb 0x3(%r9), %r13b
movl %r13d, %ecx
andb $0x8, %cl
shrb $0x3, %cl
cmpb %cl, %al
je 0... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexSeparableFilter.cpp |
Ptex::v2_4::PtexSeparableKernel::splitR(Ptex::v2_4::PtexSeparableKernel&) | void splitR(PtexSeparableKernel& k)
{
// split off right piece of width w into k
int w = u + uw - res.u();
if (w < uw) {
// normal case - split off a portion
// res u v uw vw ku kv
k.set(res, 0, v, w, vw, ku + uw - w, kv);
//... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rdi), %edi
movl 0xc(%rbx), %eax
movslq %eax, %rdx
leal (%rdx,%rdi), %eax
movb (%rbx), %cl
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
shll %cl, %r12d
movl $0xffffffff, %r13d # imm = 0xFF... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexSeparableKernel.h |
Ptex::v2_4::PtexSeparableKernel::flipU() | int u() const { return 1<<(unsigned)ulog2; } | movb (%rdi), %cl
movl $0x1, %eax
shll %cl, %eax
movl 0xc(%rdi), %ecx
movl 0x4(%rdi), %edx
addl %ecx, %edx
subl %edx, %eax
movl %eax, 0x4(%rdi)
movq 0x18(%rdi), %rax
movslq %ecx, %rcx
testl %ecx, %ecx
setne %dl
leaq (%rax,%rcx,4), %rcx
addq $-0x4, %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x1053a... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/Ptexture.h |
void Ptex::v2_4::(anonymous namespace)::Apply<unsigned short, 1>(Ptex::v2_4::PtexSeparableKernel&, float*, void*, int, int) | int u() const { return 1<<(unsigned)ulog2; } | movzbl (%rdi), %ecx
movl 0x8(%rdi), %eax
movl 0x10(%rdi), %r8d
shll %cl, %eax
shll %cl, %r8d
testl %r8d, %r8d
je 0x10c49
pushq %rbx
movslq 0x4(%rdi), %r9
cltq
addq %r9, %rax
leaq (%rdx,%rax,2), %rax
movslq %r8d, %rdx
leaq (%rax,%rdx,2), %rdx
movq 0x18(%rdi), %r8
movq 0x20(%rdi), %r9
movl $0x1, %r10d
shll %cl, %r10d
mov... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/Ptexture.h |
void Ptex::v2_4::(anonymous namespace)::Apply<float, 1>(Ptex::v2_4::PtexSeparableKernel&, float*, void*, int, int) | int u() const { return 1<<(unsigned)ulog2; } | movzbl (%rdi), %ecx
movl 0x8(%rdi), %eax
movl 0x10(%rdi), %r8d
shll %cl, %eax
shll %cl, %r8d
testl %r8d, %r8d
je 0x10d99
movslq 0x4(%rdi), %r9
cltq
addq %r9, %rax
leaq (%rdx,%rax,4), %rax
movslq %r8d, %rdx
leaq (%rax,%rdx,4), %rdx
movq 0x18(%rdi), %r8
movq 0x20(%rdi), %r9
movl $0x1, %r10d
shll %cl, %r10d
movslq 0xc(%rd... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/Ptexture.h |
void Ptex::v2_4::(anonymous namespace)::Apply<Ptex::v2_4::PtexHalf, 2>(Ptex::v2_4::PtexSeparableKernel&, float*, void*, int, int) | int u() const { return 1<<(unsigned)ulog2; } | movb (%rdi), %cl
movl $0x2, %r9d
shll %cl, %r9d
movl 0x8(%rdi), %eax
shll %cl, %eax
movslq 0x10(%rdi), %r8
movslq %r9d, %rcx
imulq %r8, %rcx
testl %ecx, %ecx
je 0x1102b
pushq %r15
pushq %r14
pushq %rbx
movslq 0x4(%rdi), %r8
cltq
addq %r8, %rax
leaq (%rdx,%rax,4), %rax
leaq (%rax,%rcx,2), %rcx
movq 0x20(%rdi), %rdx
movl... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/Ptexture.h |
void Ptex::v2_4::(anonymous namespace)::Apply<Ptex::v2_4::PtexHalf, 3>(Ptex::v2_4::PtexSeparableKernel&, float*, void*, int, int) | int u() const { return 1<<(unsigned)ulog2; } | movb (%rdi), %cl
movl $0x3, %r8d
shll %cl, %r8d
movl 0x8(%rdi), %r9d
shll %cl, %r9d
movl 0x10(%rdi), %eax
testl %eax, %eax
je 0x11469
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq 0x4(%rdi), %rcx
movslq %r9d, %r9
addq %rcx, %r9
leaq (%r9,%r9,2), %rcx
leaq (%rdx,%rcx,2), %rbx
imull %r8d, %eax
... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/Ptexture.h |
void Ptex::v2_4::(anonymous namespace)::Apply<unsigned short, 4>(Ptex::v2_4::PtexSeparableKernel&, float*, void*, int, int) | int u() const { return 1<<(unsigned)ulog2; } | movb (%rdi), %cl
movl $0x4, %r9d
shll %cl, %r9d
movl 0x8(%rdi), %eax
shll %cl, %eax
movslq 0x10(%rdi), %r8
movslq %r9d, %rcx
imulq %r8, %rcx
testl %ecx, %ecx
je 0x11710
pushq %rbx
movslq 0x4(%rdi), %r8
cltq
addq %r8, %rax
leaq (%rdx,%rax,8), %rax
leaq (%rax,%rcx,2), %rcx
movq 0x20(%rdi), %rdx
movl 0xc(%rdi), %r8d
leal ... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/Ptexture.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.