name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
---|---|---|---|
Json::StyledWriter::isMultilineArray(Json::Value const&)
|
bool StyledWriter::isMultilineArray(const Value& value) {
ArrayIndex const size = value.size();
bool isMultiLine = size * 3 >= rightMargin_;
childValues_.clear();
for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
const Value& childValue = value[index];
isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
!childValue.empty());
}
if (!isMultiLine) // check if line length > max line length
{
childValues_.reserve(size);
addChildValues_ = true;
ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
for (ArrayIndex index = 0; index < size; ++index) {
if (hasCommentForValue(value[index])) {
isMultiLine = true;
}
writeValue(value[index]);
lineLength += static_cast<ArrayIndex>(childValues_[index].length());
}
addChildValues_ = false;
isMultiLine = isMultiLine || lineLength >= rightMargin_;
}
return isMultiLine;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8d8820
movq -0x38(%rbp), %rdi
movl %eax, -0x14(%rbp)
imull $0x3, -0x14(%rbp), %eax
cmpl 0x60(%rdi), %eax
setae %al
andb $0x1, %al
movb %al, -0x15(%rbp)
addq $0x8, %rdi
callq 0x85940
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x39(%rbp)
jae 0x8e484c
movb -0x15(%rbp), %al
xorb $-0x1, %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x8e4855
jmp 0x8e48aa
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x8d9220
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8d8990
testb $0x1, %al
jne 0x8e4889
movq -0x28(%rbp), %rdi
callq 0x8d89c0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x3a(%rbp)
jne 0x8e4889
jmp 0x8e4897
movq -0x28(%rbp), %rdi
callq 0x8d8900
xorb $-0x1, %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
andb $0x1, %al
movb %al, -0x15(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8e4837
testb $0x1, -0x15(%rbp)
jne 0x8e4977
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x60550
movq -0x38(%rbp), %rax
movb $0x1, 0x68(%rax)
movl -0x14(%rbp), %eax
subl $0x1, %eax
shll %eax
addl $0x4, %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x8e494c
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x8d9220
movq %rax, %rdi
callq 0x8e4a20
testb $0x1, %al
jne 0x8e4905
jmp 0x8e4909
movb $0x1, -0x15(%rbp)
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x8d9220
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x8e39b0
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movl -0x30(%rbp), %eax
movl %eax, %esi
callq 0x60c90
movq %rax, %rdi
callq 0x3be30
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x8e48e3
movq -0x38(%rbp), %rax
movb $0x0, 0x68(%rax)
movb $0x1, %al
testb $0x1, -0x15(%rbp)
movb %al, -0x3b(%rbp)
jne 0x8e496f
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x60(%rcx), %eax
setae %al
movb %al, -0x3b(%rbp)
movb -0x3b(%rbp), %al
andb $0x1, %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
|
Json::StyledWriter::writeIndent()
|
void StyledWriter::writeIndent() {
if (!document_.empty()) {
char last = document_[document_.length() - 1];
if (last == ' ') // already indented
return;
if (last != '\n') // Comments may add new-line
document_ += '\n';
}
document_ += indentString_;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x20, %rdi
callq 0x3b870
testb $0x1, %al
jne 0x8e4a06
movq -0x18(%rbp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
addq $0x20, %rdi
callq 0x3be30
movq -0x20(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x3b080
movb (%rax), %al
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x20, %eax
jne 0x8e49e9
jmp 0x8e4a1a
movsbl -0x9(%rbp), %eax
cmpl $0xa, %eax
je 0x8e4a04
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movl $0xa, %esi
callq 0x3c010
jmp 0x8e4a06
movq -0x18(%rbp), %rdi
movq %rdi, %rsi
addq $0x40, %rsi
addq $0x20, %rdi
callq 0x3b3a0
addq $0x20, %rsp
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
|
Json::StyledStreamWriter::StyledStreamWriter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
|
StyledStreamWriter::StyledStreamWriter(String indentation)
: document_(nullptr), indentation_(std::move(indentation)),
addChildValues_(), indented_(false) {}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x60530
movq -0x18(%rbp), %rdi
movq $0x0, 0x18(%rdi)
addq $0x20, %rdi
callq 0x3d1f0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
movl $0x4a, 0x40(%rdi)
addq $0x48, %rdi
callq 0x3c420
movq -0x18(%rbp), %rax
movb 0x68(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x68(%rax)
movb 0x68(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0x68(%rax)
addq $0x20, %rsp
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
|
Json::StyledStreamWriter::writeValue(Json::Value const&)
|
void StyledStreamWriter::writeValue(const Value& value) {
switch (value.type()) {
case nullValue:
pushValue("null");
break;
case intValue:
pushValue(valueToString(value.asLargestInt()));
break;
case uintValue:
pushValue(valueToString(value.asLargestUInt()));
break;
case realValue:
pushValue(valueToString(value.asDouble()));
break;
case stringValue: {
// Is NULL possible for value.string_? No.
char const* str;
char const* end;
bool ok = value.getString(&str, &end);
if (ok)
pushValue(valueToQuotedStringN(str, static_cast<size_t>(end - str)));
else
pushValue("");
break;
}
case booleanValue:
pushValue(valueToString(value.asBool()));
break;
case arrayValue:
writeArrayValue(value);
break;
case objectValue: {
Value::Members members(value.getMemberNames());
if (members.empty())
pushValue("{}");
else {
writeWithIndent("{");
indent();
auto it = members.begin();
for (;;) {
const String& name = *it;
const Value& childValue = value[name];
writeCommentBeforeValue(childValue);
writeWithIndent(valueToQuotedString(name.c_str()));
*document_ << " : ";
writeValue(childValue);
if (++it == members.end()) {
writeCommentAfterValueOnSameLine(childValue);
break;
}
*document_ << ",";
writeCommentAfterValueOnSameLine(childValue);
}
unindent();
writeWithIndent("}");
}
} break;
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp # imm = 0x270
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x208(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8d6190
movl %eax, %ecx
movq %rcx, -0x200(%rbp)
subl $0x7, %eax
ja 0x8e54c8
movq -0x200(%rbp), %rax
leaq 0x2d35d9(%rip), %rcx # 0xbb83b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x31(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x3c460
movq -0x210(%rbp), %rdx
leaq 0x27f502(%rip), %rsi # 0xb64300
leaq -0x30(%rbp), %rdi
callq 0x606e0
jmp 0x8e4e09
movq -0x208(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8e5610
jmp 0x8e4e1b
leaq -0x30(%rbp), %rdi
callq 0x3e568
leaq -0x31(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e54c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x8e4e55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3e568
leaq -0x31(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e54d1
movq -0x10(%rbp), %rdi
callq 0x8d7f30
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x218(%rbp)
callq 0x8e2370
movq -0x208(%rbp), %rdi
movq -0x218(%rbp), %rsi
callq 0x8e5610
jmp 0x8e4e94
leaq -0x68(%rbp), %rdi
callq 0x3e568
jmp 0x8e54c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3e568
jmp 0x8e54d1
movq -0x10(%rbp), %rdi
callq 0x8d7f50
movq %rax, %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0x8e2510
movq -0x208(%rbp), %rdi
movq -0x220(%rbp), %rsi
callq 0x8e5610
jmp 0x8e4ef0
leaq -0x88(%rbp), %rdi
callq 0x3e568
jmp 0x8e54c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3e568
jmp 0x8e54d1
movq -0x10(%rbp), %rdi
callq 0x8d7f70
leaq -0xa8(%rbp), %rdi
movq %rdi, -0x228(%rbp)
movl $0x11, %esi
xorl %edx, %edx
callq 0x8e2630
movq -0x208(%rbp), %rdi
movq -0x228(%rbp), %rsi
callq 0x8e5610
jmp 0x8e4f56
leaq -0xa8(%rbp), %rdi
callq 0x3e568
jmp 0x8e54c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x3e568
jmp 0x8e54d1
movq -0x10(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x8d6a20
andb $0x1, %al
movb %al, -0xb9(%rbp)
testb $0x1, -0xb9(%rbp)
je 0x8e5015
movq -0xb0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
subq %rsi, %rdx
leaq -0xe0(%rbp), %rdi
movq %rdi, -0x230(%rbp)
xorl %ecx, %ecx
callq 0x8e2bc0
movq -0x208(%rbp), %rdi
movq -0x230(%rbp), %rsi
callq 0x8e5610
jmp 0x8e4fe7
leaq -0xe0(%rbp), %rdi
callq 0x3e568
jmp 0x8e50aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x3e568
jmp 0x8e54d1
leaq -0x101(%rbp), %rdi
movq %rdi, -0x238(%rbp)
callq 0x3c460
movq -0x238(%rbp), %rdx
leaq 0x2da181(%rip), %rsi # 0xbbf1b7
leaq -0x100(%rbp), %rdi
callq 0x606e0
jmp 0x8e5044
movq -0x208(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x8e5610
jmp 0x8e5059
leaq -0x100(%rbp), %rdi
callq 0x3e568
leaq -0x101(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e50aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x8e5099
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x3e568
leaq -0x101(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e54d1
jmp 0x8e54c8
movq -0x10(%rbp), %rdi
callq 0x8d82d0
movzbl %al, %esi
leaq -0x128(%rbp), %rdi
movq %rdi, -0x240(%rbp)
callq 0x8e2ae0
movq -0x208(%rbp), %rdi
movq -0x240(%rbp), %rsi
callq 0x8e5610
jmp 0x8e50e3
leaq -0x128(%rbp), %rdi
callq 0x3e568
jmp 0x8e54c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x128(%rbp), %rdi
callq 0x3e568
jmp 0x8e54d1
movq -0x208(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8e5660
jmp 0x8e54c8
movq -0x10(%rbp), %rsi
leaq -0x140(%rbp), %rdi
callq 0x8daeb0
leaq -0x140(%rbp), %rdi
callq 0x61d70
testb $0x1, %al
jne 0x8e514b
jmp 0x8e51e3
leaq -0x161(%rbp), %rdi
movq %rdi, -0x248(%rbp)
callq 0x3c460
movq -0x248(%rbp), %rdx
leaq 0x2aa80c(%rip), %rsi # 0xb8f978
leaq -0x160(%rbp), %rdi
callq 0x606e0
jmp 0x8e517a
movq -0x208(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x8e5610
jmp 0x8e518f
leaq -0x160(%rbp), %rdi
callq 0x3e568
leaq -0x161(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e54ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x8e51d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x3e568
leaq -0x161(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e54ba
leaq -0x189(%rbp), %rdi
movq %rdi, -0x250(%rbp)
callq 0x3c460
movq -0x250(%rbp), %rdx
leaq 0x2a3c2d(%rip), %rsi # 0xb88e31
leaq -0x188(%rbp), %rdi
callq 0x606e0
jmp 0x8e5212
movq -0x208(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x8e5a50
jmp 0x8e5227
leaq -0x188(%rbp), %rdi
callq 0x3e568
leaq -0x189(%rbp), %rdi
callq 0x3b0a0
movq -0x208(%rbp), %rdi
callq 0x8e5ab0
jmp 0x8e524d
leaq -0x140(%rbp), %rdi
callq 0x62290
movq %rax, -0x198(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x62330
movq %rax, -0x1a0(%rbp)
movq -0x10(%rbp), %rdi
movq -0x1a0(%rbp), %rsi
callq 0x8da090
movq %rax, -0x258(%rbp)
jmp 0x8e528c
movq -0x208(%rbp), %rdi
movq -0x258(%rbp), %rax
movq %rax, -0x1a8(%rbp)
movq -0x1a8(%rbp), %rsi
callq 0x8e4ba0
jmp 0x8e52af
movq -0x1a0(%rbp), %rdi
callq 0x3cc60
movq %rax, %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x8e2b70
jmp 0x8e52cc
movq -0x208(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x8e5a50
jmp 0x8e52e1
leaq -0x1c8(%rbp), %rdi
callq 0x3e568
movq -0x208(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x296b85(%rip), %rsi # 0xb7be84
callq 0x3d690
jmp 0x8e5306
movq -0x208(%rbp), %rdi
movq -0x1a8(%rbp), %rsi
callq 0x8e4d90
jmp 0x8e531b
leaq -0x198(%rbp), %rdi
callq 0x62730
movq %rax, -0x260(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x622c0
movq -0x260(%rbp), %rdi
movq %rax, -0x1d0(%rbp)
leaq -0x1d0(%rbp), %rsi
callq 0x84870
testb $0x1, %al
jne 0x8e535a
jmp 0x8e53d9
movq -0x208(%rbp), %rdi
movq -0x1a8(%rbp), %rsi
callq 0x8e54e0
jmp 0x8e536f
jmp 0x8e540c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x8e539a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x3e568
leaq -0x189(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e54ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x8e54ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x3e568
jmp 0x8e54ba
movq -0x208(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x2be95e(%rip), %rsi # 0xba3d49
callq 0x3d690
jmp 0x8e53f2
movq -0x208(%rbp), %rdi
movq -0x1a8(%rbp), %rsi
callq 0x8e54e0
jmp 0x8e5407
jmp 0x8e5260
movq -0x208(%rbp), %rdi
callq 0x8e5ae0
jmp 0x8e541a
leaq -0x1f1(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0x3c460
movq -0x268(%rbp), %rdx
leaq 0x2a39c3(%rip), %rsi # 0xb88dfe
leaq -0x1f0(%rbp), %rdi
callq 0x606e0
jmp 0x8e5449
movq -0x208(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0x8e5a50
jmp 0x8e545e
leaq -0x1f0(%rbp), %rdi
callq 0x3e568
leaq -0x1f1(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e54ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x8e549e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x3e568
leaq -0x1f1(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e54ba
leaq -0x140(%rbp), %rdi
callq 0x62750
jmp 0x8e54c8
leaq -0x140(%rbp), %rdi
callq 0x62750
jmp 0x8e54d1
addq $0x270, %rsp # imm = 0x270
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3be20
nopw (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
|
Json::StyledStreamWriter::writeCommentAfterValueOnSameLine(Json::Value const&)
|
void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value& root) {
if (root.hasComment(commentAfterOnSameLine))
*document_ << ' ' << root.getComment(commentAfterOnSameLine);
if (root.hasComment(commentAfter)) {
writeIndent();
*document_ << root.getComment(commentAfter);
}
indented_ = false;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x8db840
testb $0x1, %al
jne 0x8e550f
jmp 0x8e556f
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x20, %esi
callq 0x3be10
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x1, %edx
callq 0x8db870
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x3d3d0
jmp 0x8e554a
leaq -0x30(%rbp), %rdi
callq 0x3e568
jmp 0x8e556f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3e568
jmp 0x8e55fe
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x8db840
testb $0x1, %al
jne 0x8e5583
jmp 0x8e55e5
movq -0x68(%rbp), %rdi
callq 0x8e4d50
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x2, %edx
callq 0x8db870
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x3d3d0
jmp 0x8e55c3
leaq -0x60(%rbp), %rdi
callq 0x3e568
jmp 0x8e55e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3e568
jmp 0x8e55fe
movq -0x68(%rbp), %rax
movb 0x68(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0x68(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3be20
nopw (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
|
Json::StyledStreamWriter::writeArrayValue(Json::Value const&)
|
void StyledStreamWriter::writeArrayValue(const Value& value) {
unsigned size = value.size();
if (size == 0)
pushValue("[]");
else {
bool isArrayMultiLine = isMultilineArray(value);
if (isArrayMultiLine) {
writeWithIndent("[");
indent();
bool hasChildValue = !childValues_.empty();
unsigned index = 0;
for (;;) {
const Value& childValue = value[index];
writeCommentBeforeValue(childValue);
if (hasChildValue)
writeWithIndent(childValues_[index]);
else {
if (!indented_)
writeIndent();
indented_ = true;
writeValue(childValue);
indented_ = false;
}
if (++index == size) {
writeCommentAfterValueOnSameLine(childValue);
break;
}
*document_ << ",";
writeCommentAfterValueOnSameLine(childValue);
}
unindent();
writeWithIndent("]");
} else // output on a single line
{
assert(childValues_.size() == size);
*document_ << "[ ";
for (unsigned index = 0; index < size; ++index) {
if (index > 0)
*document_ << ", ";
*document_ << childValues_[index];
}
*document_ << " ]";
}
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8d8820
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x8e5717
leaq -0x39(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3c460
movq -0xb8(%rbp), %rdx
leaq 0x2d30da(%rip), %rsi # 0xbb878c
leaq -0x38(%rbp), %rdi
callq 0x606e0
jmp 0x8e56bd
movq -0xb0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8e5610
jmp 0x8e56cf
leaq -0x38(%rbp), %rdi
callq 0x3e568
leaq -0x39(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e5a36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8e5709
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3e568
leaq -0x39(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e5a3f
movq -0xb0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8e5b80
andb $0x1, %al
movb %al, -0x4d(%rbp)
testb $0x1, -0x4d(%rbp)
je 0x8e595d
leaq -0x71(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3c460
movq -0xc0(%rbp), %rdx
leaq 0x25b963(%rip), %rsi # 0xb410b7
leaq -0x70(%rbp), %rdi
callq 0x606e0
jmp 0x8e575f
movq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x8e5a50
jmp 0x8e5771
leaq -0x70(%rbp), %rdi
callq 0x3e568
leaq -0x71(%rbp), %rdi
callq 0x3b0a0
movq -0xb0(%rbp), %rdi
callq 0x8e5ab0
movq -0xb0(%rbp), %rdi
callq 0x61d70
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x72(%rbp)
movl $0x0, -0x78(%rbp)
movq -0x10(%rbp), %rdi
movl -0x78(%rbp), %esi
callq 0x8d9220
movq -0xb0(%rbp), %rdi
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rsi
callq 0x8e4ba0
testb $0x1, -0x72(%rbp)
je 0x8e5822
movq -0xb0(%rbp), %rdi
movl -0x78(%rbp), %eax
movl %eax, %esi
callq 0x60c90
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
callq 0x8e5a50
jmp 0x8e586d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8e5814
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3e568
leaq -0x71(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e5a3f
movq -0xb0(%rbp), %rax
movb 0x68(%rax), %al
shrb %al
andb $0x1, %al
testb $0x1, %al
jne 0x8e5840
movq -0xb0(%rbp), %rdi
callq 0x8e4d50
movq -0xb0(%rbp), %rdi
movb 0x68(%rdi), %al
andb $-0x3, %al
orb $0x2, %al
movb %al, 0x68(%rdi)
movq -0x80(%rbp), %rsi
callq 0x8e4d90
movq -0xb0(%rbp), %rax
movb 0x68(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0x68(%rax)
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
cmpl -0x14(%rbp), %eax
jne 0x8e588d
movq -0xb0(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x8e54e0
jmp 0x8e58b9
movq -0xb0(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x2be4aa(%rip), %rsi # 0xba3d49
callq 0x3d690
movq -0xb0(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x8e54e0
jmp 0x8e57a9
movq -0xb0(%rbp), %rdi
callq 0x8e5ae0
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x3c460
movq -0xc8(%rbp), %rdx
leaq 0x2a351c(%rip), %rsi # 0xb88e02
leaq -0xa0(%rbp), %rdi
callq 0x606e0
jmp 0x8e58f4
movq -0xb0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x8e5a50
jmp 0x8e5909
leaq -0xa0(%rbp), %rdi
callq 0x3e568
leaq -0xa1(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e5a34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8e594c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x3e568
leaq -0xa1(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e5a3f
movq -0xb0(%rbp), %rdi
callq 0x60c70
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jne 0x8e5973
jmp 0x8e5992
leaq 0x2d2e15(%rip), %rdi # 0xbb878f
leaq 0x2d2d42(%rip), %rsi # 0xbb86c3
movl $0x2fa, %edx # imm = 0x2FA
leaq 0x2d2ea1(%rip), %rcx # 0xbb882e
callq 0x3b440
movq -0xb0(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x2d2e3f(%rip), %rsi # 0xbb87e3
callq 0x3d690
movl $0x0, -0xa8(%rbp)
movl -0xa8(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x8e5a1d
cmpl $0x0, -0xa8(%rbp)
jbe 0x8e59de
movq -0xb0(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x28b818(%rip), %rsi # 0xb711f1
callq 0x3d690
movq -0xb0(%rbp), %rdi
movq 0x18(%rdi), %rax
movq %rax, -0xd0(%rbp)
movl -0xa8(%rbp), %eax
movl %eax, %esi
callq 0x60c90
movq -0xd0(%rbp), %rdi
movq %rax, %rsi
callq 0x3d3d0
movl -0xa8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa8(%rbp)
jmp 0x8e59b3
movq -0xb0(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x2a8275(%rip), %rsi # 0xb8dca4
callq 0x3d690
jmp 0x8e5a36
addq $0xd0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3be20
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
|
Json::StyledStreamWriter::isMultilineArray(Json::Value const&)
|
bool StyledStreamWriter::isMultilineArray(const Value& value) {
ArrayIndex const size = value.size();
bool isMultiLine = size * 3 >= rightMargin_;
childValues_.clear();
for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
const Value& childValue = value[index];
isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
!childValue.empty());
}
if (!isMultiLine) // check if line length > max line length
{
childValues_.reserve(size);
addChildValues_ = true;
ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
for (ArrayIndex index = 0; index < size; ++index) {
if (hasCommentForValue(value[index])) {
isMultiLine = true;
}
writeValue(value[index]);
lineLength += static_cast<ArrayIndex>(childValues_[index].length());
}
addChildValues_ = false;
isMultiLine = isMultiLine || lineLength >= rightMargin_;
}
return isMultiLine;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8d8820
movq -0x38(%rbp), %rdi
movl %eax, -0x14(%rbp)
imull $0x3, -0x14(%rbp), %eax
cmpl 0x40(%rdi), %eax
setae %al
andb $0x1, %al
movb %al, -0x15(%rbp)
callq 0x85940
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x39(%rbp)
jae 0x8e5bd8
movb -0x15(%rbp), %al
xorb $-0x1, %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x8e5be1
jmp 0x8e5c36
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x8d9220
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8d8990
testb $0x1, %al
jne 0x8e5c15
movq -0x28(%rbp), %rdi
callq 0x8d89c0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x3a(%rbp)
jne 0x8e5c15
jmp 0x8e5c23
movq -0x28(%rbp), %rdi
callq 0x8d8900
xorb $-0x1, %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
andb $0x1, %al
movb %al, -0x15(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8e5bc3
testb $0x1, -0x15(%rbp)
jne 0x8e5d0b
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x60550
movq -0x38(%rbp), %rax
movb 0x68(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x68(%rax)
movl -0x14(%rbp), %eax
subl $0x1, %eax
shll %eax
addl $0x4, %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x8e5cd8
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x8d9220
movq %rax, %rdi
callq 0x8e5d20
testb $0x1, %al
jne 0x8e5c95
jmp 0x8e5c99
movb $0x1, -0x15(%rbp)
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x8d9220
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x8e4d90
movq -0x38(%rbp), %rdi
movl -0x30(%rbp), %eax
movl %eax, %esi
callq 0x60c90
movq %rax, %rdi
callq 0x3be30
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x8e5c73
movq -0x38(%rbp), %rax
movb 0x68(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x68(%rax)
movb $0x1, %al
testb $0x1, -0x15(%rbp)
movb %al, -0x3b(%rbp)
jne 0x8e5d03
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x40(%rcx), %eax
setae %al
movb %al, -0x3b(%rbp)
movb -0x3b(%rbp), %al
andb $0x1, %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
|
Json::BuiltStyledStreamWriter::BuiltStyledStreamWriter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Json::CommentStyle::Enum, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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, bool, unsigned int, Json::PrecisionType)
|
BuiltStyledStreamWriter::BuiltStyledStreamWriter(
String indentation, CommentStyle::Enum cs, String colonSymbol,
String nullSymbol, String endingLineFeedSymbol, bool useSpecialFloats,
bool emitUTF8, unsigned int precision, PrecisionType precisionType)
: rightMargin_(74), indentation_(std::move(indentation)), cs_(cs),
colonSymbol_(std::move(colonSymbol)), nullSymbol_(std::move(nullSymbol)),
endingLineFeedSymbol_(std::move(endingLineFeedSymbol)),
addChildValues_(false), indented_(false),
useSpecialFloats_(useSpecialFloats), emitUTF8_(emitUTF8),
precision_(precision), precisionType_(precisionType) {}
|
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %r9, -0x48(%rbp)
movq %r8, -0x50(%rbp)
movq %rcx, -0x58(%rbp)
movl %edx, %eax
movq -0x58(%rbp), %rdx
movl %eax, -0x64(%rbp)
movq %rsi, %rax
movl -0x64(%rbp), %esi
movq %rax, -0x60(%rbp)
movq %rdi, %r10
movq -0x60(%rbp), %rdi
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movb 0x18(%rbp), %al
movb 0x10(%rbp), %cl
movq %r10, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
andb $0x1, %cl
movb %cl, -0x31(%rbp)
andb $0x1, %al
movb %al, -0x32(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x8e5ee0
movq -0x40(%rbp), %rdi
leaq 0x61144c(%rip), %rax # 0xef7240
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x10, %rdi
callq 0x60530
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
callq 0x3d1f0
movq -0x60(%rbp), %rsi
movq -0x40(%rbp), %rdi
movl $0x4a, 0x48(%rdi)
addq $0x50, %rdi
callq 0x3c420
movq -0x58(%rbp), %rsi
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, 0x70(%rdi)
addq $0x78, %rdi
callq 0x3c420
movq -0x50(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0x98, %rdi
callq 0x3c420
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0xb8, %rdi
callq 0x3c420
movq -0x40(%rbp), %rax
movb 0xd8(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0xd8(%rax)
movb 0xd8(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0xd8(%rax)
movb -0x31(%rbp), %dl
andb $0x1, %dl
movb 0xd8(%rax), %cl
shlb $0x2, %dl
andb $-0x5, %cl
orb %dl, %cl
movb %cl, 0xd8(%rax)
movb -0x32(%rbp), %dl
andb $0x1, %dl
movb 0xd8(%rax), %cl
shlb $0x3, %dl
andb $-0x9, %cl
orb %dl, %cl
movb %cl, 0xd8(%rax)
movl 0x20(%rbp), %ecx
movl %ecx, 0xdc(%rax)
movl 0x28(%rbp), %ecx
movl %ecx, 0xe0(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
|
Json::BuiltStyledStreamWriter::write(Json::Value const&, std::ostream*)
|
int BuiltStyledStreamWriter::write(Value const& root, OStream* sout) {
sout_ = sout;
addChildValues_ = false;
indented_ = true;
indentString_.clear();
writeCommentBeforeValue(root);
if (!indented_)
writeIndent();
indented_ = true;
writeValue(root);
writeCommentAfterValueOnSameLine(root);
*sout_ << endingLineFeedSymbol_;
sout_ = nullptr;
return 0;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
movb 0xd8(%rdi), %al
andb $-0x2, %al
orb $0x0, %al
movb %al, 0xd8(%rdi)
movb 0xd8(%rdi), %al
andb $-0x3, %al
orb $0x2, %al
movb %al, 0xd8(%rdi)
addq $0x28, %rdi
callq 0x3bb80
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8e5fe0
movq -0x20(%rbp), %rax
movb 0xd8(%rax), %al
shrb %al
andb $0x1, %al
testb $0x1, %al
jne 0x8e5f85
movq -0x20(%rbp), %rdi
callq 0x8e61b0
movq -0x20(%rbp), %rdi
movb 0xd8(%rdi), %al
andb $-0x3, %al
orb $0x2, %al
movb %al, 0xd8(%rdi)
movq -0x10(%rbp), %rsi
callq 0x8e6200
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8e6930
movq -0x20(%rbp), %rsi
movq 0x8(%rsi), %rdi
addq $0xb8, %rsi
callq 0x3d3d0
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
|
Json::BuiltStyledStreamWriter::writeCommentBeforeValue(Json::Value const&)
|
void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root) {
if (cs_ == CommentStyle::None)
return;
if (!root.hasComment(commentBefore))
return;
if (!indented_)
writeIndent();
const String& comment = root.getComment(commentBefore);
String::const_iterator iter = comment.begin();
while (iter != comment.end()) {
*sout_ << *iter;
if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
// writeIndent(); // would write extra newline
*sout_ << indentString_;
++iter;
}
indented_ = false;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpl $0x0, 0x70(%rax)
jne 0x8e6006
jmp 0x8e6190
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x8db840
testb $0x1, %al
jne 0x8e601a
jmp 0x8e6190
movq -0x78(%rbp), %rax
movb 0xd8(%rax), %al
shrb %al
andb $0x1, %al
testb $0x1, %al
jne 0x8e6035
movq -0x78(%rbp), %rdi
callq 0x8e61b0
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
xorl %edx, %edx
callq 0x8db870
leaq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3b640
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e220
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1a6110
testb $0x1, %al
jne 0x8e607c
jmp 0x8e6171
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1a6150
movq -0x80(%rbp), %rdi
movsbl (%rax), %esi
callq 0x3be10
jmp 0x8e609f
leaq -0x40(%rbp), %rdi
callq 0x1a6150
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x81(%rbp)
jne 0x8e612b
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x311af0
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e220
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1a6110
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x82(%rbp)
jne 0x8e60f5
jmp 0x8e611f
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x311af0
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1a6150
movsbl (%rax), %eax
cmpl $0x2f, %eax
sete %al
movb %al, -0x82(%rbp)
movb -0x82(%rbp), %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x8e6137
jmp 0x8e6163
movq -0x78(%rbp), %rsi
movq 0x8(%rsi), %rdi
addq $0x28, %rsi
callq 0x3d3d0
jmp 0x8e614a
jmp 0x8e6163
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3e568
jmp 0x8e6199
leaq -0x40(%rbp), %rdi
callq 0x1a6170
jmp 0x8e6059
movq -0x78(%rbp), %rax
movb 0xd8(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0xd8(%rax)
leaq -0x38(%rbp), %rdi
callq 0x3e568
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3be20
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
|
Json::BuiltStyledStreamWriter::writeIndent()
|
void BuiltStyledStreamWriter::writeIndent() {
// blep intended this to look at the so-far-written string
// to determine whether we are already indented, but
// with a stream we cannot do that. So we rely on some saved state.
// The caller checks indented_.
if (!indentation_.empty()) {
// In this case, drop newlines too.
*sout_ << '\n' << indentString_;
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x50, %rdi
callq 0x3b870
testb $0x1, %al
jne 0x8e61f3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0xa, %esi
callq 0x3be10
movq -0x10(%rbp), %rsi
movq %rax, %rdi
addq $0x28, %rsi
callq 0x3d3d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
|
Json::BuiltStyledStreamWriter::writeValue(Json::Value const&)
|
void BuiltStyledStreamWriter::writeValue(Value const& value) {
switch (value.type()) {
case nullValue:
pushValue(nullSymbol_);
break;
case intValue:
pushValue(valueToString(value.asLargestInt()));
break;
case uintValue:
pushValue(valueToString(value.asLargestUInt()));
break;
case realValue:
pushValue(valueToString(value.asDouble(), useSpecialFloats_, precision_,
precisionType_));
break;
case stringValue: {
// Is NULL is possible for value.string_? No.
char const* str;
char const* end;
bool ok = value.getString(&str, &end);
if (ok)
pushValue(
valueToQuotedStringN(str, static_cast<size_t>(end - str), emitUTF8_));
else
pushValue("");
break;
}
case booleanValue:
pushValue(valueToString(value.asBool()));
break;
case arrayValue:
writeArrayValue(value);
break;
case objectValue: {
Value::Members members(value.getMemberNames());
if (members.empty())
pushValue("{}");
else {
writeWithIndent("{");
indent();
auto it = members.begin();
for (;;) {
String const& name = *it;
Value const& childValue = value[name];
writeCommentBeforeValue(childValue);
writeWithIndent(
valueToQuotedStringN(name.data(), name.length(), emitUTF8_));
*sout_ << colonSymbol_;
writeValue(childValue);
if (++it == members.end()) {
writeCommentAfterValueOnSameLine(childValue);
break;
}
*sout_ << ",";
writeCommentAfterValueOnSameLine(childValue);
}
unindent();
writeWithIndent("}");
}
} break;
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8d6190
movl %eax, %ecx
movq %rcx, -0x1d8(%rbp)
subl $0x7, %eax
ja 0x8e6914
movq -0x1d8(%rbp), %rax
leaq 0x2d2189(%rip), %rcx # 0xbb83d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x1e0(%rbp), %rdi
movq %rdi, %rsi
addq $0x98, %rsi
callq 0x8e6aa0
jmp 0x8e6914
movq -0x10(%rbp), %rdi
callq 0x8d7f30
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x8e2370
movq -0x1e0(%rbp), %rdi
movq -0x1e8(%rbp), %rsi
callq 0x8e6aa0
jmp 0x8e629c
leaq -0x30(%rbp), %rdi
callq 0x3e568
jmp 0x8e6914
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3e568
jmp 0x8e691d
movq -0x10(%rbp), %rdi
callq 0x8d7f50
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x8e2510
movq -0x1e0(%rbp), %rdi
movq -0x1f0(%rbp), %rsi
callq 0x8e6aa0
jmp 0x8e62f5
leaq -0x60(%rbp), %rdi
callq 0x3e568
jmp 0x8e6914
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3e568
jmp 0x8e691d
movq -0x10(%rbp), %rdi
callq 0x8d7f70
movq -0x1e0(%rbp), %rax
movzbl 0xd8(%rax), %esi
shrl $0x2, %esi
andl $0x1, %esi
movl 0xdc(%rax), %edx
movl 0xe0(%rax), %ecx
leaq -0x80(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x8e2670
movq -0x1e0(%rbp), %rdi
movq -0x1f8(%rbp), %rsi
callq 0x8e6aa0
jmp 0x8e636b
leaq -0x80(%rbp), %rdi
callq 0x3e568
jmp 0x8e6914
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3e568
jmp 0x8e691d
movq -0x10(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x8d6a20
andb $0x1, %al
movb %al, -0x91(%rbp)
testb $0x1, -0x91(%rbp)
je 0x8e6436
movq -0x1e0(%rbp), %rax
movq -0x88(%rbp), %rsi
movq -0x90(%rbp), %rdx
subq %rsi, %rdx
movzbl 0xd8(%rax), %ecx
shrl $0x3, %ecx
andl $0x1, %ecx
leaq -0xb8(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x8e2bc0
movq -0x1e0(%rbp), %rdi
movq -0x200(%rbp), %rsi
callq 0x8e6aa0
jmp 0x8e6408
leaq -0xb8(%rbp), %rdi
callq 0x3e568
jmp 0x8e64cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x3e568
jmp 0x8e691d
leaq -0xd9(%rbp), %rdi
movq %rdi, -0x208(%rbp)
callq 0x3c460
movq -0x208(%rbp), %rdx
leaq 0x2d8d60(%rip), %rsi # 0xbbf1b7
leaq -0xd8(%rbp), %rdi
callq 0x606e0
jmp 0x8e6465
movq -0x1e0(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x8e6aa0
jmp 0x8e647a
leaq -0xd8(%rbp), %rdi
callq 0x3e568
leaq -0xd9(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e64cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8e64ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x3e568
leaq -0xd9(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e691d
jmp 0x8e6914
movq -0x10(%rbp), %rdi
callq 0x8d82d0
movzbl %al, %esi
leaq -0x100(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x8e2ae0
movq -0x1e0(%rbp), %rdi
movq -0x210(%rbp), %rsi
callq 0x8e6aa0
jmp 0x8e6504
leaq -0x100(%rbp), %rdi
callq 0x3e568
jmp 0x8e6914
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x3e568
jmp 0x8e691d
movq -0x1e0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8e6af0
jmp 0x8e6914
movq -0x10(%rbp), %rsi
leaq -0x118(%rbp), %rdi
callq 0x8daeb0
leaq -0x118(%rbp), %rdi
callq 0x61d70
testb $0x1, %al
jne 0x8e656c
jmp 0x8e6604
leaq -0x139(%rbp), %rdi
movq %rdi, -0x218(%rbp)
callq 0x3c460
movq -0x218(%rbp), %rdx
leaq 0x2a93eb(%rip), %rsi # 0xb8f978
leaq -0x138(%rbp), %rdi
callq 0x606e0
jmp 0x8e659b
movq -0x1e0(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0x8e6aa0
jmp 0x8e65b0
leaq -0x138(%rbp), %rdi
callq 0x3e568
leaq -0x139(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e68f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8e65f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x3e568
leaq -0x139(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e6906
leaq -0x161(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0x3c460
movq -0x220(%rbp), %rdx
leaq 0x2a280c(%rip), %rsi # 0xb88e31
leaq -0x160(%rbp), %rdi
callq 0x606e0
jmp 0x8e6633
movq -0x1e0(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x8e6fb0
jmp 0x8e6648
leaq -0x160(%rbp), %rdi
callq 0x3e568
leaq -0x161(%rbp), %rdi
callq 0x3b0a0
movq -0x1e0(%rbp), %rdi
callq 0x8e7010
jmp 0x8e666e
leaq -0x118(%rbp), %rdi
callq 0x62290
movq %rax, -0x170(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x62330
movq %rax, -0x178(%rbp)
movq -0x10(%rbp), %rdi
movq -0x178(%rbp), %rsi
callq 0x8da090
movq %rax, -0x228(%rbp)
jmp 0x8e66ad
movq -0x1e0(%rbp), %rdi
movq -0x228(%rbp), %rax
movq %rax, -0x180(%rbp)
movq -0x180(%rbp), %rsi
callq 0x8e5fe0
jmp 0x8e66d0
movq -0x178(%rbp), %rdi
callq 0x3b6e0
movq %rax, -0x230(%rbp)
movq -0x178(%rbp), %rdi
callq 0x3be30
movq -0x230(%rbp), %rsi
movq %rax, %rdx
movq -0x1e0(%rbp), %rax
movzbl 0xd8(%rax), %ecx
shrl $0x3, %ecx
andl $0x1, %ecx
leaq -0x1a0(%rbp), %rdi
callq 0x8e2bc0
jmp 0x8e671b
movq -0x1e0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x8e6fb0
jmp 0x8e6730
leaq -0x1a0(%rbp), %rdi
callq 0x3e568
movq -0x1e0(%rbp), %rsi
movq 0x8(%rsi), %rdi
addq $0x78, %rsi
callq 0x3d3d0
jmp 0x8e6752
movq -0x1e0(%rbp), %rdi
movq -0x180(%rbp), %rsi
callq 0x8e6200
jmp 0x8e6767
leaq -0x170(%rbp), %rdi
callq 0x62730
movq %rax, -0x238(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x622c0
movq -0x238(%rbp), %rdi
movq %rax, -0x1a8(%rbp)
leaq -0x1a8(%rbp), %rsi
callq 0x84870
testb $0x1, %al
jne 0x8e67a6
jmp 0x8e6825
movq -0x1e0(%rbp), %rdi
movq -0x180(%rbp), %rsi
callq 0x8e6930
jmp 0x8e67bb
jmp 0x8e6858
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8e67e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x3e568
leaq -0x161(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e6906
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8e6906
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x3e568
jmp 0x8e6906
movq -0x1e0(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x2bd512(%rip), %rsi # 0xba3d49
callq 0x3d690
jmp 0x8e683e
movq -0x1e0(%rbp), %rdi
movq -0x180(%rbp), %rsi
callq 0x8e6930
jmp 0x8e6853
jmp 0x8e6681
movq -0x1e0(%rbp), %rdi
callq 0x8e7040
jmp 0x8e6866
leaq -0x1c9(%rbp), %rdi
movq %rdi, -0x240(%rbp)
callq 0x3c460
movq -0x240(%rbp), %rdx
leaq 0x2a2577(%rip), %rsi # 0xb88dfe
leaq -0x1c8(%rbp), %rdi
callq 0x606e0
jmp 0x8e6895
movq -0x1e0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x8e6fb0
jmp 0x8e68aa
leaq -0x1c8(%rbp), %rdi
callq 0x3e568
leaq -0x1c9(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e68f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8e68ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x3e568
leaq -0x1c9(%rbp), %rdi
callq 0x3b0a0
jmp 0x8e6906
leaq -0x118(%rbp), %rdi
callq 0x62750
jmp 0x8e6914
leaq -0x118(%rbp), %rdi
callq 0x62750
jmp 0x8e691d
addq $0x240, %rsp # imm = 0x240
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3be20
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
|
Json::BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine(Json::Value const&)
|
void BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine(
Value const& root) {
if (cs_ == CommentStyle::None)
return;
if (root.hasComment(commentAfterOnSameLine))
*sout_ << " " + root.getComment(commentAfterOnSameLine);
if (root.hasComment(commentAfter)) {
writeIndent();
*sout_ << root.getComment(commentAfter);
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpl $0x0, 0x70(%rax)
jne 0x8e6959
jmp 0x8e6a8d
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x8db840
testb $0x1, %al
jne 0x8e6970
jmp 0x8e6a0b
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movl $0x1, %edx
callq 0x8db870
movq -0x90(%rbp), %rdx
leaq 0x2960c6(%rip), %rsi # 0xb7ca6f
leaq -0x30(%rbp), %rdi
callq 0x84970
jmp 0x8e69b4
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3d3d0
jmp 0x8e69c6
leaq -0x30(%rbp), %rdi
callq 0x3e568
leaq -0x50(%rbp), %rdi
callq 0x3e568
jmp 0x8e6a0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8e69fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3e568
leaq -0x50(%rbp), %rdi
callq 0x3e568
jmp 0x8e6a96
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x8db840
testb $0x1, %al
jne 0x8e6a1f
jmp 0x8e6a8d
movq -0x88(%rbp), %rdi
callq 0x8e61b0
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movl $0x2, %edx
callq 0x8db870
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x3d3d0
jmp 0x8e6a6b
leaq -0x80(%rbp), %rdi
callq 0x3e568
jmp 0x8e6a8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3e568
jmp 0x8e6a96
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3be20
nop
|
/JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
|
Json::BuiltStyledStreamWriter::isMultilineArray(Json::Value const&)
|
bool BuiltStyledStreamWriter::isMultilineArray(Value const& value) {
ArrayIndex const size = value.size();
bool isMultiLine = size * 3 >= rightMargin_;
childValues_.clear();
for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
Value const& childValue = value[index];
isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
!childValue.empty());
}
if (!isMultiLine) // check if line length > max line length
{
childValues_.reserve(size);
addChildValues_ = true;
ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
for (ArrayIndex index = 0; index < size; ++index) {
if (hasCommentForValue(value[index])) {
isMultiLine = true;
}
writeValue(value[index]);
lineLength += static_cast<ArrayIndex>(childValues_[index].length());
}
addChildValues_ = false;
isMultiLine = isMultiLine || lineLength >= rightMargin_;
}
return isMultiLine;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8d8820
movq -0x38(%rbp), %rdi
movl %eax, -0x14(%rbp)
imull $0x3, -0x14(%rbp), %eax
cmpl 0x48(%rdi), %eax
setae %al
andb $0x1, %al
movb %al, -0x15(%rbp)
addq $0x10, %rdi
callq 0x85940
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x39(%rbp)
jae 0x8e713c
movb -0x15(%rbp), %al
xorb $-0x1, %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x8e7145
jmp 0x8e719a
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x8d9220
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8d8990
testb $0x1, %al
jne 0x8e7179
movq -0x28(%rbp), %rdi
callq 0x8d89c0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x3a(%rbp)
jne 0x8e7179
jmp 0x8e7187
movq -0x28(%rbp), %rdi
callq 0x8d8900
xorb $-0x1, %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
andb $0x1, %al
movb %al, -0x15(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8e7127
testb $0x1, -0x15(%rbp)
jne 0x8e7283
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x60550
movq -0x38(%rbp), %rax
movb 0xd8(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0xd8(%rax)
movl -0x14(%rbp), %eax
subl $0x1, %eax
shll %eax
addl $0x4, %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x8e724a
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x8d9220
movq %rax, %rdi
callq 0x8e7290
testb $0x1, %al
jne 0x8e7203
jmp 0x8e7207
movb $0x1, -0x15(%rbp)
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x8d9220
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x8e6200
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
movl -0x30(%rbp), %eax
movl %eax, %esi
callq 0x60c90
movq %rax, %rdi
callq 0x3be30
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x8e71e1
movq -0x38(%rbp), %rax
movb 0xd8(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0xd8(%rax)
movb $0x1, %al
testb $0x1, -0x15(%rbp)
movb %al, -0x3b(%rbp)
jne 0x8e727b
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x48(%rcx), %eax
setae %al
movb %al, -0x3b(%rbp)
movb -0x3b(%rbp), %al
andb $0x1, %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
|
Json::utf8ToCodepoint(char const*&, char const*)
|
static unsigned int utf8ToCodepoint(const char*& s, const char* e) {
const unsigned int REPLACEMENT_CHARACTER = 0xFFFD;
unsigned int firstByte = static_cast<unsigned char>(*s);
if (firstByte < 0x80)
return firstByte;
if (firstByte < 0xE0) {
if (e - s < 2)
return REPLACEMENT_CHARACTER;
unsigned int calculated =
((firstByte & 0x1F) << 6) | (static_cast<unsigned int>(s[1]) & 0x3F);
s += 1;
// oversized encoded characters are invalid
return calculated < 0x80 ? REPLACEMENT_CHARACTER : calculated;
}
if (firstByte < 0xF0) {
if (e - s < 3)
return REPLACEMENT_CHARACTER;
unsigned int calculated = ((firstByte & 0x0F) << 12) |
((static_cast<unsigned int>(s[1]) & 0x3F) << 6) |
(static_cast<unsigned int>(s[2]) & 0x3F);
s += 2;
// surrogates aren't valid codepoints itself
// shouldn't be UTF-8 encoded
if (calculated >= 0xD800 && calculated <= 0xDFFF)
return REPLACEMENT_CHARACTER;
// oversized encoded characters are invalid
return calculated < 0x800 ? REPLACEMENT_CHARACTER : calculated;
}
if (firstByte < 0xF8) {
if (e - s < 4)
return REPLACEMENT_CHARACTER;
unsigned int calculated = ((firstByte & 0x07) << 18) |
((static_cast<unsigned int>(s[1]) & 0x3F) << 12) |
((static_cast<unsigned int>(s[2]) & 0x3F) << 6) |
(static_cast<unsigned int>(s[3]) & 0x3F);
s += 3;
// oversized encoded characters are invalid
return calculated < 0x10000 ? REPLACEMENT_CHARACTER : calculated;
}
return REPLACEMENT_CHARACTER;
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0xfffd, -0x1c(%rbp) # imm = 0xFFFD
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movl %eax, -0x20(%rbp)
cmpl $0x80, -0x20(%rbp)
jae 0x8e8994
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8e8b59
cmpl $0xe0, -0x20(%rbp)
jae 0x8e8a0b
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
cmpq $0x2, %rax
jge 0x8e89bd
movl $0xfffd, -0x4(%rbp) # imm = 0xFFFD
jmp 0x8e8b59
movl -0x20(%rbp), %eax
andl $0x1f, %eax
shll $0x6, %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl 0x1(%rcx), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
cmpl $0x80, -0x24(%rbp)
jae 0x8e89fa
movl $0xfffd, %eax # imm = 0xFFFD
movl %eax, -0x30(%rbp)
jmp 0x8e8a00
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8e8b59
cmpl $0xf0, -0x20(%rbp)
jae 0x8e8ab7
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
cmpq $0x3, %rax
jge 0x8e8a38
movl $0xfffd, -0x4(%rbp) # imm = 0xFFFD
jmp 0x8e8b59
movl -0x20(%rbp), %eax
andl $0xf, %eax
shll $0xc, %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl 0x1(%rcx), %ecx
andl $0x3f, %ecx
shll $0x6, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl 0x2(%rcx), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
cmpl $0xd800, -0x28(%rbp) # imm = 0xD800
jb 0x8e8a93
cmpl $0xdfff, -0x28(%rbp) # imm = 0xDFFF
ja 0x8e8a93
movl $0xfffd, -0x4(%rbp) # imm = 0xFFFD
jmp 0x8e8b59
cmpl $0x800, -0x28(%rbp) # imm = 0x800
jae 0x8e8aa6
movl $0xfffd, %eax # imm = 0xFFFD
movl %eax, -0x34(%rbp)
jmp 0x8e8aac
movl -0x28(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8e8b59
cmpl $0xf8, -0x20(%rbp)
jae 0x8e8b52
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
cmpq $0x4, %rax
jge 0x8e8ae1
movl $0xfffd, -0x4(%rbp) # imm = 0xFFFD
jmp 0x8e8b59
movl -0x20(%rbp), %eax
andl $0x7, %eax
shll $0x12, %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl 0x1(%rcx), %ecx
andl $0x3f, %ecx
shll $0xc, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl 0x2(%rcx), %ecx
andl $0x3f, %ecx
shll $0x6, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl 0x3(%rcx), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x3, %rcx
movq %rcx, (%rax)
cmpl $0x10000, -0x2c(%rbp) # imm = 0x10000
jae 0x8e8b44
movl $0xfffd, %eax # imm = 0xFFFD
movl %eax, -0x38(%rbp)
jmp 0x8e8b4a
movl -0x2c(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8e8b59
movl $0xfffd, -0x4(%rbp) # imm = 0xFFFD
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp
|
archive_entry_clear
|
struct archive_entry *
archive_entry_clear(struct archive_entry *entry)
{
if (entry == NULL)
return (NULL);
archive_mstring_clean(&entry->ae_fflags_text);
archive_mstring_clean(&entry->ae_gname);
archive_mstring_clean(&entry->ae_hardlink);
archive_mstring_clean(&entry->ae_pathname);
archive_mstring_clean(&entry->ae_sourcepath);
archive_mstring_clean(&entry->ae_symlink);
archive_mstring_clean(&entry->ae_uname);
archive_entry_copy_mac_metadata(entry, NULL, 0);
archive_acl_clear(&entry->acl);
archive_entry_xattr_clear(entry);
archive_entry_sparse_clear(entry);
free(entry->stat);
entry->ae_symlink_type = AE_SYMLINK_TYPE_UNDEFINED;
memset(entry, 0, sizeof(*entry));
return entry;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8e9410
movq $0x0, -0x8(%rbp)
jmp 0x8e94e5
movq -0x10(%rbp), %rdi
addq $0xc8, %rdi
callq 0x9396b0
movq -0x10(%rbp), %rdi
addq $0x140, %rdi # imm = 0x140
callq 0x9396b0
movq -0x10(%rbp), %rdi
addq $0x1a8, %rdi # imm = 0x1A8
callq 0x9396b0
movq -0x10(%rbp), %rdi
addq $0x210, %rdi # imm = 0x210
callq 0x9396b0
movq -0x10(%rbp), %rdi
addq $0x348, %rdi # imm = 0x348
callq 0x9396b0
movq -0x10(%rbp), %rdi
addq $0x278, %rdi # imm = 0x278
callq 0x9396b0
movq -0x10(%rbp), %rdi
addq $0x2e0, %rdi # imm = 0x2E0
callq 0x9396b0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x8e94f0
movq -0x10(%rbp), %rdi
addq $0x490, %rdi # imm = 0x490
callq 0x972ab0
movq -0x10(%rbp), %rdi
callq 0x8ed410
movq -0x10(%rbp), %rdi
callq 0x8eced0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3e548
movq -0x10(%rbp), %rax
movl $0x0, 0x4fc(%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x500, %edx # imm = 0x500
callq 0x3b780
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c
|
archive_entry_clone
|
struct archive_entry *
archive_entry_clone(struct archive_entry *entry)
{
struct archive_entry *entry2;
struct ae_xattr *xp;
struct ae_sparse *sp;
size_t s;
const void *p;
/* Allocate new structure and copy over all of the fields. */
/* TODO: Should we copy the archive over? Or require a new archive
* as an argument? */
entry2 = archive_entry_new2(entry->archive);
if (entry2 == NULL)
return (NULL);
entry2->ae_stat = entry->ae_stat;
entry2->ae_fflags_set = entry->ae_fflags_set;
entry2->ae_fflags_clear = entry->ae_fflags_clear;
/* TODO: XXX If clone can have a different archive, what do we do here if
* character sets are different? XXX */
archive_mstring_copy(&entry2->ae_fflags_text, &entry->ae_fflags_text);
archive_mstring_copy(&entry2->ae_gname, &entry->ae_gname);
archive_mstring_copy(&entry2->ae_hardlink, &entry->ae_hardlink);
archive_mstring_copy(&entry2->ae_pathname, &entry->ae_pathname);
archive_mstring_copy(&entry2->ae_sourcepath, &entry->ae_sourcepath);
archive_mstring_copy(&entry2->ae_symlink, &entry->ae_symlink);
entry2->ae_set = entry->ae_set;
archive_mstring_copy(&entry2->ae_uname, &entry->ae_uname);
/* Copy symlink type */
entry2->ae_symlink_type = entry->ae_symlink_type;
/* Copy encryption status */
entry2->encryption = entry->encryption;
/* Copy digests */
#define copy_digest(_e2, _e, _t) \
memcpy(_e2->digest._t, _e->digest._t, sizeof(_e2->digest._t))
copy_digest(entry2, entry, md5);
copy_digest(entry2, entry, rmd160);
copy_digest(entry2, entry, sha1);
copy_digest(entry2, entry, sha256);
copy_digest(entry2, entry, sha384);
copy_digest(entry2, entry, sha512);
#undef copy_digest
/* Copy ACL data over. */
archive_acl_copy(&entry2->acl, &entry->acl);
/* Copy Mac OS metadata. */
p = archive_entry_mac_metadata(entry, &s);
archive_entry_copy_mac_metadata(entry2, p, s);
/* Copy xattr data over. */
xp = entry->xattr_head;
while (xp != NULL) {
archive_entry_xattr_add_entry(entry2,
xp->name, xp->value, xp->size);
xp = xp->next;
}
/* Copy sparse data over. */
sp = entry->sparse_head;
while (sp != NULL) {
archive_entry_sparse_add_entry(entry2,
sp->offset, sp->length);
sp = sp->next;
}
return (entry2);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x8e9900
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8e95d0
movq $0x0, -0x8(%rbp)
jmp 0x8e98ee
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl $0xa8, %edx
callq 0x3cb70
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x130(%rax)
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x138(%rax)
movq -0x18(%rbp), %rdi
addq $0xc8, %rdi
movq -0x10(%rbp), %rsi
addq $0xc8, %rsi
callq 0x939700
movq -0x18(%rbp), %rdi
addq $0x140, %rdi # imm = 0x140
movq -0x10(%rbp), %rsi
addq $0x140, %rsi # imm = 0x140
callq 0x939700
movq -0x18(%rbp), %rdi
addq $0x1a8, %rdi # imm = 0x1A8
movq -0x10(%rbp), %rsi
addq $0x1a8, %rsi # imm = 0x1A8
callq 0x939700
movq -0x18(%rbp), %rdi
addq $0x210, %rdi # imm = 0x210
movq -0x10(%rbp), %rsi
addq $0x210, %rsi # imm = 0x210
callq 0x939700
movq -0x18(%rbp), %rdi
addq $0x348, %rdi # imm = 0x348
movq -0x10(%rbp), %rsi
addq $0x348, %rsi # imm = 0x348
callq 0x939700
movq -0x18(%rbp), %rdi
addq $0x278, %rdi # imm = 0x278
movq -0x10(%rbp), %rsi
addq $0x278, %rsi # imm = 0x278
callq 0x939700
movq -0x10(%rbp), %rax
movl 0xc0(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc0(%rax)
movq -0x18(%rbp), %rdi
addq $0x2e0, %rdi # imm = 0x2E0
movq -0x10(%rbp), %rsi
addq $0x2e0, %rsi # imm = 0x2E0
callq 0x939700
movq -0x10(%rbp), %rax
movl 0x4fc(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4fc(%rax)
movq -0x10(%rbp), %rax
movb 0x3b0(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3b0(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x3c8(%rcx), %rdx
movq %rdx, 0x3c8(%rax)
movq 0x3d0(%rcx), %rcx
movq %rcx, 0x3d0(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x3d8(%rcx), %rdx
movq %rdx, 0x3d8(%rax)
movq 0x3e0(%rcx), %rdx
movq %rdx, 0x3e0(%rax)
movl 0x3e8(%rcx), %ecx
movl %ecx, 0x3e8(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x3ec(%rcx), %rdx
movq %rdx, 0x3ec(%rax)
movq 0x3f4(%rcx), %rdx
movq %rdx, 0x3f4(%rax)
movl 0x3fc(%rcx), %ecx
movl %ecx, 0x3fc(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x400(%rcx), %rdx
movq %rdx, 0x400(%rax)
movq 0x408(%rcx), %rdx
movq %rdx, 0x408(%rax)
movq 0x410(%rcx), %rdx
movq %rdx, 0x410(%rax)
movq 0x418(%rcx), %rcx
movq %rcx, 0x418(%rax)
movq -0x18(%rbp), %rdi
addq $0x3c8, %rdi # imm = 0x3C8
addq $0x58, %rdi
movq -0x10(%rbp), %rsi
addq $0x3c8, %rsi # imm = 0x3C8
addq $0x58, %rsi
movl $0x30, %edx
callq 0x3cb70
movq -0x18(%rbp), %rdi
addq $0x3c8, %rdi # imm = 0x3C8
addq $0x88, %rdi
movq -0x10(%rbp), %rsi
addq $0x3c8, %rsi # imm = 0x3C8
addq $0x88, %rsi
movl $0x40, %edx
callq 0x3cb70
movq -0x18(%rbp), %rdi
addq $0x490, %rdi # imm = 0x490
movq -0x10(%rbp), %rsi
addq $0x490, %rsi # imm = 0x490
callq 0x972b60
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8e9960
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x8e94f0
movq -0x10(%rbp), %rax
movq 0x4c8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8e98aa
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
callq 0x8ed4a0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x8e9875
movq -0x10(%rbp), %rax
movq 0x4d8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8e98e6
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x8ecf40
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x8e98b9
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c
|
archive_entry_fflags_text
|
const char *
archive_entry_fflags_text(struct archive_entry *entry)
{
const char *f;
char *p;
if (archive_mstring_get_mbs(entry->archive,
&entry->ae_fflags_text, &f) == 0) {
if (f != NULL)
return (f);
} else if (errno == ENOMEM)
__archive_errx(1, "No memory");
if (entry->ae_fflags_set == 0 && entry->ae_fflags_clear == 0)
return (NULL);
p = ae_fflagstostr(entry->ae_fflags_set, entry->ae_fflags_clear);
if (p == NULL)
return (NULL);
archive_mstring_copy_mbs(&entry->ae_fflags_text, p);
free(p);
if (archive_mstring_get_mbs(entry->archive,
&entry->ae_fflags_text, &f) == 0)
return (f);
if (errno == ENOMEM)
__archive_errx(1, "No memory");
return (NULL);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0xc8, %rsi
leaq -0x18(%rbp), %rdx
callq 0x9398a0
cmpl $0x0, %eax
jne 0x8e9cb2
cmpq $0x0, -0x18(%rbp)
je 0x8e9cb0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8e9d92
jmp 0x8e9ccf
callq 0x3e130
cmpl $0xc, (%rax)
jne 0x8e9ccd
movl $0x1, %edi
leaq 0x2cee30(%rip), %rsi # 0xbb8af8
callq 0x940330
jmp 0x8e9ccf
movq -0x10(%rbp), %rax
cmpq $0x0, 0x130(%rax)
jne 0x8e9cf8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x138(%rax)
jne 0x8e9cf8
movq $0x0, -0x8(%rbp)
jmp 0x8e9d92
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rsi
callq 0x8e9da0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8e9d28
movq $0x0, -0x8(%rbp)
jmp 0x8e9d92
movq -0x10(%rbp), %rdi
addq $0xc8, %rdi
movq -0x20(%rbp), %rsi
callq 0x939c10
movq -0x20(%rbp), %rdi
callq 0x3e548
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0xc8, %rsi
leaq -0x18(%rbp), %rdx
callq 0x9398a0
cmpl $0x0, %eax
jne 0x8e9d6f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8e9d92
callq 0x3e130
cmpl $0xc, (%rax)
jne 0x8e9d8a
movl $0x1, %edi
leaq 0x2ced73(%rip), %rsi # 0xbb8af8
callq 0x940330
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c
|
archive_entry_gname
|
const char *
archive_entry_gname(struct archive_entry *entry)
{
const char *p;
if (archive_mstring_get_mbs(entry->archive, &entry->ae_gname, &p) == 0)
return (p);
if (errno == ENOMEM)
__archive_errx(1, "No memory");
return (NULL);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x140, %rsi # imm = 0x140
leaq -0x18(%rbp), %rdx
callq 0x9398a0
cmpl $0x0, %eax
jne 0x8ea016
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8ea039
callq 0x3e130
cmpl $0xc, (%rax)
jne 0x8ea031
movl $0x1, %edi
leaq 0x2ceacc(%rip), %rsi # 0xbb8af8
callq 0x940330
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c
|
archive_entry_copy_hardlink_l
|
int
_archive_entry_copy_hardlink_l(struct archive_entry *entry,
const char *target, size_t len, struct archive_string_conv *sc)
{
int r;
r = archive_mstring_copy_mbs_len_l(&entry->ae_hardlink,
target, len, sc);
if (target != NULL && r == 0)
entry->ae_set |= AE_SET_HARDLINK;
else
entry->ae_set &= ~AE_SET_HARDLINK;
return (r);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1a8, %rdi # imm = 0x1A8
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x939e80
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8eb749
cmpl $0x0, -0x24(%rbp)
jne 0x8eb749
movq -0x8(%rbp), %rax
movl 0xc0(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0xc0(%rax)
jmp 0x8eb75c
movq -0x8(%rbp), %rax
movl 0xc0(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0xc0(%rax)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c
|
archive_entry_update_link_utf8
|
int
archive_entry_update_link_utf8(struct archive_entry *entry, const char *target)
{
int r;
if (entry->ae_set & AE_SET_SYMLINK)
r = archive_mstring_update_utf8(entry->archive,
&entry->ae_symlink, target);
else
r = archive_mstring_update_utf8(entry->archive,
&entry->ae_hardlink, target);
if (r == 0)
return (1);
if (errno == ENOMEM)
__archive_errx(1, "No memory");
return (0);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0xc0(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x8ebcc2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x278, %rsi # imm = 0x278
movq -0x18(%rbp), %rdx
callq 0x939f20
movl %eax, -0x1c(%rbp)
jmp 0x8ebce0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x1a8, %rsi # imm = 0x1A8
movq -0x18(%rbp), %rdx
callq 0x939f20
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x8ebcef
movl $0x1, -0x4(%rbp)
jmp 0x8ebd11
callq 0x3e130
cmpl $0xc, (%rax)
jne 0x8ebd0a
movl $0x1, %edi
leaq 0x2ccdf3(%rip), %rsi # 0xbb8af8
callq 0x940330
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c
|
archive_entry_copy_link_l
|
int
_archive_entry_copy_link_l(struct archive_entry *entry,
const char *target, size_t len, struct archive_string_conv *sc)
{
int r;
if (entry->ae_set & AE_SET_SYMLINK)
r = archive_mstring_copy_mbs_len_l(&entry->ae_symlink,
target, len, sc);
else
r = archive_mstring_copy_mbs_len_l(&entry->ae_hardlink,
target, len, sc);
return (r);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0xc0(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x8ebd6b
movq -0x8(%rbp), %rdi
addq $0x278, %rdi # imm = 0x278
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x939e80
movl %eax, -0x24(%rbp)
jmp 0x8ebd8a
movq -0x8(%rbp), %rdi
addq $0x1a8, %rdi # imm = 0x1A8
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x939e80
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c
|
archive_entry_update_pathname_utf8
|
int
archive_entry_update_pathname_utf8(struct archive_entry *entry, const char *name)
{
if (archive_mstring_update_utf8(entry->archive,
&entry->ae_pathname, name) == 0)
return (1);
if (errno == ENOMEM)
__archive_errx(1, "No memory");
return (0);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x210, %rsi # imm = 0x210
movq -0x18(%rbp), %rdx
callq 0x939f20
cmpl $0x0, %eax
jne 0x8ebfd9
movl $0x1, -0x4(%rbp)
jmp 0x8ebffb
callq 0x3e130
cmpl $0xc, (%rax)
jne 0x8ebff4
movl $0x1, %edi
leaq 0x2ccb09(%rip), %rsi # 0xbb8af8
callq 0x940330
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c
|
archive_entry_update_symlink_utf8
|
int
archive_entry_update_symlink_utf8(struct archive_entry *entry, const char *linkname)
{
if (linkname != NULL)
entry->ae_set |= AE_SET_SYMLINK;
else
entry->ae_set &= ~AE_SET_SYMLINK;
if (archive_mstring_update_utf8(entry->archive,
&entry->ae_symlink, linkname) == 0)
return (1);
if (errno == ENOMEM)
__archive_errx(1, "No memory");
return (0);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8ec40c
movq -0x10(%rbp), %rax
movl 0xc0(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0xc0(%rax)
jmp 0x8ec41f
movq -0x10(%rbp), %rax
movl 0xc0(%rax), %ecx
andl $-0x3, %ecx
movl %ecx, 0xc0(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x278, %rsi # imm = 0x278
movq -0x18(%rbp), %rdx
callq 0x939f20
cmpl $0x0, %eax
jne 0x8ec448
movl $0x1, -0x4(%rbp)
jmp 0x8ec46a
callq 0x3e130
cmpl $0xc, (%rax)
jne 0x8ec463
movl $0x1, %edi
leaq 0x2cc69a(%rip), %rsi # 0xbb8af8
callq 0x940330
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c
|
archive_entry_copy_symlink_l
|
int
_archive_entry_copy_symlink_l(struct archive_entry *entry,
const char *linkname, size_t len, struct archive_string_conv *sc)
{
int r;
r = archive_mstring_copy_mbs_len_l(&entry->ae_symlink,
linkname, len, sc);
if (linkname != NULL && r == 0)
entry->ae_set |= AE_SET_SYMLINK;
else
entry->ae_set &= ~AE_SET_SYMLINK;
return (r);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x278, %rdi # imm = 0x278
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x939e80
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8ec4d9
cmpl $0x0, -0x24(%rbp)
jne 0x8ec4d9
movq -0x8(%rbp), %rax
movl 0xc0(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0xc0(%rax)
jmp 0x8ec4ec
movq -0x8(%rbp), %rax
movl 0xc0(%rax), %ecx
andl $-0x3, %ecx
movl %ecx, 0xc0(%rax)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c
|
archive_entry_update_uname_utf8
|
int
archive_entry_update_uname_utf8(struct archive_entry *entry, const char *name)
{
if (archive_mstring_update_utf8(entry->archive,
&entry->ae_uname, name) == 0)
return (1);
if (errno == ENOMEM)
__archive_errx(1, "No memory");
return (0);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x2e0, %rsi # imm = 0x2E0
movq -0x18(%rbp), %rdx
callq 0x939f20
cmpl $0x0, %eax
jne 0x8ec629
movl $0x1, -0x4(%rbp)
jmp 0x8ec64b
callq 0x3e130
cmpl $0xc, (%rax)
jne 0x8ec644
movl $0x1, %edi
leaq 0x2cc4b9(%rip), %rsi # 0xbb8af8
callq 0x940330
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c
|
archive_entry_digest
|
const unsigned char *
archive_entry_digest(struct archive_entry *entry, int type)
{
switch (type) {
case ARCHIVE_ENTRY_DIGEST_MD5:
return entry->digest.md5;
case ARCHIVE_ENTRY_DIGEST_RMD160:
return entry->digest.rmd160;
case ARCHIVE_ENTRY_DIGEST_SHA1:
return entry->digest.sha1;
case ARCHIVE_ENTRY_DIGEST_SHA256:
return entry->digest.sha256;
case ARCHIVE_ENTRY_DIGEST_SHA384:
return entry->digest.sha384;
case ARCHIVE_ENTRY_DIGEST_SHA512:
return entry->digest.sha512;
default:
return NULL;
}
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x5, %eax
ja 0x8ec7c9
movq -0x20(%rbp), %rax
leaq 0x2cc37e(%rip), %rcx # 0xbb8ac8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
addq $0x3c8, %rax # imm = 0x3C8
movq %rax, -0x8(%rbp)
jmp 0x8ec7d1
movq -0x10(%rbp), %rax
addq $0x3c8, %rax # imm = 0x3C8
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x8ec7d1
movq -0x10(%rbp), %rax
addq $0x3c8, %rax # imm = 0x3C8
addq $0x24, %rax
movq %rax, -0x8(%rbp)
jmp 0x8ec7d1
movq -0x10(%rbp), %rax
addq $0x3c8, %rax # imm = 0x3C8
addq $0x38, %rax
movq %rax, -0x8(%rbp)
jmp 0x8ec7d1
movq -0x10(%rbp), %rax
addq $0x3c8, %rax # imm = 0x3C8
addq $0x58, %rax
movq %rax, -0x8(%rbp)
jmp 0x8ec7d1
movq -0x10(%rbp), %rax
addq $0x3c8, %rax # imm = 0x3C8
addq $0x88, %rax
movq %rax, -0x8(%rbp)
jmp 0x8ec7d1
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c
|
archive_entry_set_digest
|
int
archive_entry_set_digest(struct archive_entry *entry, int type,
const unsigned char *digest)
{
#define copy_digest(_e, _t, _d)\
memcpy(_e->digest._t, _d, sizeof(_e->digest._t))
switch (type) {
case ARCHIVE_ENTRY_DIGEST_MD5:
copy_digest(entry, md5, digest);
break;
case ARCHIVE_ENTRY_DIGEST_RMD160:
copy_digest(entry, rmd160, digest);
break;
case ARCHIVE_ENTRY_DIGEST_SHA1:
copy_digest(entry, sha1, digest);
break;
case ARCHIVE_ENTRY_DIGEST_SHA256:
copy_digest(entry, sha256, digest);
break;
case ARCHIVE_ENTRY_DIGEST_SHA384:
copy_digest(entry, sha384, digest);
break;
case ARCHIVE_ENTRY_DIGEST_SHA512:
copy_digest(entry, sha512, digest);
break;
default:
return ARCHIVE_WARN;
}
return ARCHIVE_OK;
#undef copy_digest
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x5, %eax
ja 0x8ec906
movq -0x28(%rbp), %rax
leaq 0x2cc2ce(%rip), %rcx # 0xbb8ae0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x3c8(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x3d0(%rax)
jmp 0x8ec90f
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x3d8(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x3e0(%rax)
movl 0x10(%rcx), %ecx
movl %ecx, 0x3e8(%rax)
jmp 0x8ec90f
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x3ec(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x3f4(%rax)
movl 0x10(%rcx), %ecx
movl %ecx, 0x3fc(%rax)
jmp 0x8ec90f
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x400(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x408(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x410(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x418(%rax)
jmp 0x8ec90f
movq -0x10(%rbp), %rdi
addq $0x3c8, %rdi # imm = 0x3C8
addq $0x58, %rdi
movq -0x20(%rbp), %rsi
movl $0x30, %edx
callq 0x3cb70
jmp 0x8ec90f
movq -0x10(%rbp), %rdi
addq $0x3c8, %rdi # imm = 0x3C8
addq $0x88, %rdi
movq -0x20(%rbp), %rsi
movl $0x40, %edx
callq 0x3cb70
jmp 0x8ec90f
movl $0xffffffec, -0x4(%rbp) # imm = 0xFFFFFFEC
jmp 0x8ec916
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c
|
archive_entry_acl_next
|
int
archive_entry_acl_next(struct archive_entry *entry, int want_type, int *type,
int *permset, int *tag, int *id, const char **name)
{
int r;
r = archive_acl_next(entry->archive, &entry->acl, want_type, type,
permset, tag, id, name);
if (r == ARCHIVE_FATAL && errno == ENOMEM)
__archive_errx(1, "No memory");
return (r);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x490, %rsi # imm = 0x490
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %r10
movq 0x10(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x9731e0
movl %eax, -0x34(%rbp)
cmpl $-0x1e, -0x34(%rbp)
jne 0x8ecb4e
callq 0x3e130
cmpl $0xc, (%rax)
jne 0x8ecb4e
movl $0x1, %edi
leaq 0x2cbfaf(%rip), %rsi # 0xbb8af8
callq 0x940330
movl -0x34(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c
|
archive_entry_acl_text
|
const char *
archive_entry_acl_text(struct archive_entry *entry, int flags)
{
free(entry->acl.acl_text);
entry->acl.acl_text = NULL;
if (archive_entry_acl_text_compat(&flags) == 0)
entry->acl.acl_text = archive_acl_to_text_l(&entry->acl, NULL,
flags, NULL);
return (entry->acl.acl_text);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x4b8(%rax), %rdi
callq 0x3e548
movq -0x8(%rbp), %rax
movq $0x0, 0x4b8(%rax)
leaq -0xc(%rbp), %rdi
callq 0x8ecd50
cmpl $0x0, %eax
jne 0x8ece24
movq -0x8(%rbp), %rdi
addq $0x490, %rdi # imm = 0x490
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
callq 0x974200
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x4b8(%rax)
movq -0x8(%rbp), %rax
movq 0x4b8(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c
|
archive_entry_acl_text_l
|
int
_archive_entry_acl_text_l(struct archive_entry *entry, int flags,
const char **acl_text, size_t *len, struct archive_string_conv *sc)
{
free(entry->acl.acl_text);
entry->acl.acl_text = NULL;
if (archive_entry_acl_text_compat(&flags) == 0)
entry->acl.acl_text = archive_acl_to_text_l(&entry->acl,
(ssize_t *)len, flags, sc);
*acl_text = entry->acl.acl_text;
return (0);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x4b8(%rax), %rdi
callq 0x3e548
movq -0x8(%rbp), %rax
movq $0x0, 0x4b8(%rax)
leaq -0xc(%rbp), %rdi
callq 0x8ecd50
cmpl $0x0, %eax
jne 0x8eceb1
movq -0x8(%rbp), %rdi
addq $0x490, %rdi # imm = 0x490
movq -0x20(%rbp), %rsi
movl -0xc(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x974200
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x4b8(%rax)
movq -0x8(%rbp), %rax
movq 0x4b8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c
|
archive_entry_sparse_clear
|
void
archive_entry_sparse_clear(struct archive_entry *entry)
{
struct ae_sparse *sp;
while (entry->sparse_head != NULL) {
sp = entry->sparse_head->next;
free(entry->sparse_head);
entry->sparse_head = sp;
}
entry->sparse_tail = NULL;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x4d8(%rax)
je 0x8ecf1d
movq -0x8(%rbp), %rax
movq 0x4d8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x4d8(%rax), %rdi
callq 0x3e548
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x4d8(%rax)
jmp 0x8ecedc
movq -0x8(%rbp), %rax
movq $0x0, 0x4e0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry_sparse.c
|
archive_entry_sparse_add_entry
|
void
archive_entry_sparse_add_entry(struct archive_entry *entry,
la_int64_t offset, la_int64_t length)
{
struct ae_sparse *sp;
if (offset < 0 || length < 0)
/* Invalid value */
return;
if (offset > INT64_MAX - length ||
offset + length > archive_entry_size(entry))
/* A value of "length" parameter is too large. */
return;
if ((sp = entry->sparse_tail) != NULL) {
if (sp->offset + sp->length > offset)
/* Invalid value. */
return;
if (sp->offset + sp->length == offset) {
if (sp->offset + sp->length + length < 0)
/* A value of "length" parameter is
* too large. */
return;
/* Expand existing sparse block size. */
sp->length += length;
return;
}
}
if ((sp = (struct ae_sparse *)malloc(sizeof(*sp))) == NULL)
/* XXX Error XXX */
return;
sp->offset = offset;
sp->length = length;
sp->next = NULL;
if (entry->sparse_head == NULL)
entry->sparse_head = entry->sparse_tail = sp;
else {
/* Add a new sparse block to the tail of list. */
if (entry->sparse_tail != NULL)
entry->sparse_tail->next = sp;
entry->sparse_tail = sp;
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0x8ecf62
cmpq $0x0, -0x18(%rbp)
jge 0x8ecf67
jmp 0x8ed0b2
movq -0x10(%rbp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
subq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jg 0x8ecf9f
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8ea740
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jle 0x8ecfa4
jmp 0x8ed0b2
movq -0x8(%rbp), %rax
movq 0x4e0(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8ed020
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
addq 0x10(%rcx), %rax
cmpq -0x10(%rbp), %rax
jle 0x8ecfd4
jmp 0x8ed0b2
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
addq 0x10(%rcx), %rax
cmpq -0x10(%rbp), %rax
jne 0x8ed01e
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
addq 0x10(%rcx), %rax
addq -0x18(%rbp), %rax
cmpq $0x0, %rax
jge 0x8ed009
jmp 0x8ed0b2
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
jmp 0x8ed0b2
jmp 0x8ed020
movl $0x18, %edi
callq 0x3e578
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x8ed036
jmp 0x8ed0b2
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x4d8(%rax)
jne 0x8ed083
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x4e0(%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0x4d8(%rax)
jmp 0x8ed0b2
movq -0x8(%rbp), %rax
cmpq $0x0, 0x4e0(%rax)
je 0x8ed0a3
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x4e0(%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x4e0(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry_sparse.c
|
archive_entry_sparse_count
|
int
archive_entry_sparse_count(struct archive_entry *entry)
{
struct ae_sparse *sp;
int count = 0;
for (sp = entry->sparse_head; sp != NULL; sp = sp->next)
count++;
/*
* Sanity check if this entry is exactly sparse.
* If amount of sparse blocks is just one and it indicates the whole
* file data, we should remove it and return zero.
*/
if (count == 1) {
sp = entry->sparse_head;
if (sp->offset == 0 &&
sp->length >= archive_entry_size(entry)) {
count = 0;
archive_entry_sparse_clear(entry);
}
}
return (count);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x4d8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8ed0ff
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x8ed0e2
cmpl $0x1, -0x14(%rbp)
jne 0x8ed152
movq -0x8(%rbp), %rax
movq 0x4d8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x8ed150
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8ea740
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jl 0x8ed150
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8eced0
jmp 0x8ed152
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry_sparse.c
|
archive_entry_xattr_add_entry
|
void
archive_entry_xattr_add_entry(struct archive_entry *entry,
const char *name, const void *value, size_t size)
{
struct ae_xattr *xp;
if ((xp = (struct ae_xattr *)malloc(sizeof(struct ae_xattr))) == NULL)
__archive_errx(1, "Out of memory");
if ((xp->name = strdup(name)) == NULL)
__archive_errx(1, "Out of memory");
if ((xp->value = malloc(size)) != NULL) {
memcpy(xp->value, value, size);
xp->size = size;
} else
xp->size = 0;
xp->next = entry->xattr_head;
entry->xattr_head = xp;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x20, %edi
callq 0x3e578
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x8ed4dd
movl $0x1, %edi
leaq 0x272f4d(%rip), %rsi # 0xb60425
callq 0x940330
movq -0x10(%rbp), %rdi
callq 0x3e4e8
movq -0x28(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x8ed505
movl $0x1, %edi
leaq 0x272f25(%rip), %rsi # 0xb60425
callq 0x940330
movq -0x20(%rbp), %rdi
callq 0x3e578
movq -0x28(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
je 0x8ed53f
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3cb70
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x8ed54b
movq -0x28(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x4c8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x4c8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry_xattr.c
|
archive_entry_xattr_next
|
int
archive_entry_xattr_next(struct archive_entry * entry,
const char **name, const void **value, size_t *size)
{
if (entry->xattr_p) {
*name = entry->xattr_p->name;
*value = entry->xattr_p->value;
*size = entry->xattr_p->size;
entry->xattr_p = entry->xattr_p->next;
return (ARCHIVE_OK);
} else {
*name = NULL;
*value = NULL;
*size = (size_t)0;
return (ARCHIVE_WARN);
}
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x4d0(%rax)
je 0x8ed686
movq -0x10(%rbp), %rax
movq 0x4d0(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x4d0(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x4d0(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x4d0(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x4d0(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x8ed6ae
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movl $0xffffffec, -0x4(%rbp) # imm = 0xFFFFFFEC
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry_xattr.c
|
archive_match_path_unmatched_inclusions_next
|
int
archive_match_path_unmatched_inclusions_next(struct archive *_a,
const char **_p)
{
struct archive_match *a;
const void *v;
int r;
archive_check_magic(_a, ARCHIVE_MATCH_MAGIC,
ARCHIVE_STATE_NEW, "archive_match_unmatched_inclusions_next");
a = (struct archive_match *)_a;
r = match_list_unmatched_inclusions_next(a, &(a->inclusions), 1, &v);
*_p = (const char *)v;
return (r);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xcad11c9, %esi # imm = 0xCAD11C9
movl $0x1, %edx
leaq 0x2ca16c(%rip), %rcx # 0xbb90b1
callq 0x9770c0
movl %eax, -0x30(%rbp)
cmpl $-0x1e, -0x30(%rbp)
jne 0x8eef5c
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8eef97
jmp 0x8eef5e
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0xc0, %rsi
movl $0x1, %edx
leaq -0x28(%rbp), %rcx
callq 0x8eefa0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_match.c
|
archive_match_include_time
|
int
archive_match_include_time(struct archive *_a, int flag, time_t sec,
long nsec)
{
int r;
r = validate_time_flag(_a, flag, "archive_match_include_time");
if (r != ARCHIVE_OK)
return (r);
return set_timefilter((struct archive_match *)_a, flag,
sec, nsec, sec, nsec);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x2c9f0e(%rip), %rdx # 0xbb9103
callq 0x8ef240
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x8ef20b
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8ef22a
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
callq 0x8ef350
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_match.c
|
set_timefilter_date
|
static int
set_timefilter_date(struct archive_match *a, int timetype, const char *datestr)
{
time_t t;
if (datestr == NULL || *datestr == '\0') {
archive_set_error(&(a->archive), EINVAL, "date is empty");
return (ARCHIVE_FAILED);
}
t = get_date(a->now, datestr);
if (t == (time_t)-1) {
archive_set_error(&(a->archive), EINVAL, "invalid date string");
return (ARCHIVE_FAILED);
}
return set_timefilter(a, timetype, t, 0, t, 0);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8ef576
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x8ef596
movq -0x10(%rbp), %rdi
movl $0x16, %esi
leaq 0x2c9d7d(%rip), %rdx # 0xbb9303
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe7, -0x4(%rbp) # imm = 0xFFFFFFE7
jmp 0x8ef5f4
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x978f60
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x8ef5d5
movq -0x10(%rbp), %rdi
movl $0x16, %esi
leaq 0x2c9d4c(%rip), %rdx # 0xbb9311
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe7, -0x4(%rbp) # imm = 0xFFFFFFE7
jmp 0x8ef5f4
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x28(%rbp), %r8
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %rcx
callq 0x8ef350
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_match.c
|
match_path_inclusion
|
static int
match_path_inclusion(struct archive_match *a, struct match *m,
int mbs, const void *pn)
{
/* Recursive operation requires only a prefix match. */
int flag = a->recursive_include ?
PATHMATCH_NO_ANCHOR_END :
0;
int r;
if (mbs) {
const char *p;
r = archive_mstring_get_mbs(&(a->archive), &(m->pattern), &p);
if (r == 0)
return (archive_pathmatch(p, (const char *)pn, flag));
} else {
const wchar_t *p;
r = archive_mstring_get_wcs(&(a->archive), &(m->pattern), &p);
if (r == 0)
return (archive_pathmatch_w(p, (const wchar_t *)pn,
flag));
}
if (errno == ENOMEM)
return (error_nomem(a));
return (0);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x94(%rax), %edx
xorl %eax, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x8f04fc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
leaq -0x38(%rbp), %rdx
callq 0x9398a0
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jne 0x8f04fa
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x8f0960
movl %eax, -0x4(%rbp)
jmp 0x8f0550
jmp 0x8f0531
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
leaq -0x40(%rbp), %rdx
callq 0x939a20
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jne 0x8f052f
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x8f0ed0
movl %eax, -0x4(%rbp)
jmp 0x8f0550
jmp 0x8f0531
callq 0x3e130
cmpl $0xc, (%rax)
jne 0x8f0549
movq -0x10(%rbp), %rdi
callq 0x8f0400
movl %eax, -0x4(%rbp)
jmp 0x8f0550
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_match.c
|
_archive_pathmatch_w
|
int
__archive_pathmatch_w(const wchar_t *p, const wchar_t *s, int flags)
{
/* Empty pattern only matches the empty string. */
if (p == NULL || *p == L'\0')
return (s == NULL || *s == L'\0');
else if (s == NULL)
return (0);
/* Leading '^' anchors the start of the pattern. */
if (*p == L'^') {
++p;
flags &= ~PATHMATCH_NO_ANCHOR_START;
}
if (*p == L'/' && *s != L'/')
return (0);
/* Certain patterns anchor implicitly. */
if (*p == L'*' || *p == L'/') {
while (*p == L'/')
++p;
while (*s == L'/')
++s;
return (pm_w(p, s, flags));
}
/* If start is unanchored, try to match start of each path element. */
if (flags & PATHMATCH_NO_ANCHOR_START) {
for ( ; s != NULL; s = wcschr(s, L'/')) {
if (*s == L'/')
s++;
if (pm_w(p, s, flags))
return (1);
}
return (0);
}
/* Default: Match from beginning. */
return (pm_w(p, s, flags));
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8f0ef3
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x8f0f1c
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1d(%rbp)
je 0x8f0f0c
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x8f103f
cmpq $0x0, -0x18(%rbp)
jne 0x8f0f2f
movl $0x0, -0x4(%rbp)
jmp 0x8f103f
jmp 0x8f0f31
movq -0x10(%rbp), %rax
cmpl $0x5e, (%rax)
jne 0x8f0f4f
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
andl $-0x2, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2f, (%rax)
jne 0x8f0f6d
movq -0x18(%rbp), %rax
cmpl $0x2f, (%rax)
je 0x8f0f6d
movl $0x0, -0x4(%rbp)
jmp 0x8f103f
movq -0x10(%rbp), %rax
cmpl $0x2a, (%rax)
je 0x8f0f7f
movq -0x10(%rbp), %rax
cmpl $0x2f, (%rax)
jne 0x8f0fc6
jmp 0x8f0f81
movq -0x10(%rbp), %rax
cmpl $0x2f, (%rax)
jne 0x8f0f98
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x8f0f81
jmp 0x8f0f9a
movq -0x18(%rbp), %rax
cmpl $0x2f, (%rax)
jne 0x8f0fb1
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x8f0f9a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x8f1050
movl %eax, -0x4(%rbp)
jmp 0x8f103f
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x8f102c
jmp 0x8f0fd3
cmpq $0x0, -0x18(%rbp)
je 0x8f1023
movq -0x18(%rbp), %rax
cmpl $0x2f, (%rax)
jne 0x8f0fef
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x8f1050
cmpl $0x0, %eax
je 0x8f100d
movl $0x1, -0x4(%rbp)
jmp 0x8f103f
jmp 0x8f100f
movq -0x18(%rbp), %rdi
movl $0x2f, %esi
callq 0x3dca0
movq %rax, -0x18(%rbp)
jmp 0x8f0fd3
movl $0x0, -0x4(%rbp)
jmp 0x8f103f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x8f1050
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_pathmatch.c
|
pm_w
|
static int
pm_w(const wchar_t *p, const wchar_t *s, int flags)
{
const wchar_t *end;
/*
* Ignore leading './', './/', '././', etc.
*/
if (s[0] == L'.' && s[1] == L'/')
s = pm_slashskip_w(s + 1);
if (p[0] == L'.' && p[1] == L'/')
p = pm_slashskip_w(p + 1);
for (;;) {
switch (*p) {
case L'\0':
if (s[0] == L'/') {
if (flags & PATHMATCH_NO_ANCHOR_END)
return (1);
/* "dir" == "dir/" == "dir/." */
s = pm_slashskip_w(s);
}
return (*s == L'\0');
case L'?':
/* ? always succeeds, unless we hit end of 's' */
if (*s == L'\0')
return (0);
break;
case L'*':
/* "*" == "**" == "***" ... */
while (*p == L'*')
++p;
/* Trailing '*' always succeeds. */
if (*p == L'\0')
return (1);
while (*s) {
if (archive_pathmatch_w(p, s, flags))
return (1);
++s;
}
return (0);
case L'[':
/*
* Find the end of the [...] character class,
* ignoring \] that might occur within the class.
*/
end = p + 1;
while (*end != L'\0' && *end != L']') {
if (*end == L'\\' && end[1] != L'\0')
++end;
++end;
}
if (*end == L']') {
/* We found [...], try to match it. */
if (!pm_list_w(p + 1, end, *s, flags))
return (0);
p = end; /* Jump to trailing ']' char. */
break;
} else
/* No final ']', so just match '['. */
if (*p != *s)
return (0);
break;
case L'\\':
/* Trailing '\\' matches itself. */
if (p[1] == L'\0') {
if (*s != L'\\')
return (0);
} else {
++p;
if (*p != *s)
return (0);
}
break;
case L'/':
if (*s != L'/' && *s != L'\0')
return (0);
/* Note: pattern "/\./" won't match "/";
* pm_slashskip() correctly stops at backslash. */
p = pm_slashskip_w(p);
s = pm_slashskip_w(s);
if (*p == L'\0' && (flags & PATHMATCH_NO_ANCHOR_END))
return (1);
--p; /* Counteract the increment below. */
--s;
break;
case L'$':
/* '$' is special only at end of pattern and only
* if PATHMATCH_NO_ANCHOR_END is specified. */
if (p[1] == L'\0' && (flags & PATHMATCH_NO_ANCHOR_END)){
/* "dir" == "dir/" == "dir/." */
return (*pm_slashskip_w(s) == L'\0');
}
/* Otherwise, '$' is not special. */
/* FALL THROUGH */
default:
if (*p != *s)
return (0);
break;
}
++p;
++s;
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2e, (%rax)
jne 0x8f1087
movq -0x18(%rbp), %rax
cmpl $0x2f, 0x4(%rax)
jne 0x8f1087
movq -0x18(%rbp), %rdi
addq $0x4, %rdi
callq 0x8f15d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2e, (%rax)
jne 0x8f10ab
movq -0x10(%rbp), %rax
cmpl $0x2f, 0x4(%rax)
jne 0x8f10ab
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
callq 0x8f15d0
movq %rax, -0x10(%rbp)
jmp 0x8f10ad
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x8f110f
jmp 0x8f10bc
movl -0x2c(%rbp), %eax
subl $0x24, %eax
je 0x8f1360
jmp 0x8f10ca
movl -0x2c(%rbp), %eax
subl $0x2a, %eax
je 0x8f116d
jmp 0x8f10d8
movl -0x2c(%rbp), %eax
subl $0x2f, %eax
je 0x8f12ee
jmp 0x8f10e6
movl -0x2c(%rbp), %eax
subl $0x3f, %eax
je 0x8f1153
jmp 0x8f10f0
movl -0x2c(%rbp), %eax
subl $0x5b, %eax
je 0x8f11e1
jmp 0x8f10fe
movl -0x2c(%rbp), %eax
subl $0x5c, %eax
je 0x8f12a0
jmp 0x8f1390
movq -0x18(%rbp), %rax
cmpl $0x2f, (%rax)
jne 0x8f113c
movl -0x1c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x8f112f
movl $0x1, -0x4(%rbp)
jmp 0x8f13c6
movq -0x18(%rbp), %rdi
callq 0x8f15d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x8f13c6
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x8f1168
movl $0x0, -0x4(%rbp)
jmp 0x8f13c6
jmp 0x8f13a9
jmp 0x8f116f
movq -0x10(%rbp), %rax
cmpl $0x2a, (%rax)
jne 0x8f1186
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x8f116f
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x8f119b
movl $0x1, -0x4(%rbp)
jmp 0x8f13c6
jmp 0x8f119d
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x8f11d5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x8f0ed0
cmpl $0x0, %eax
je 0x8f11c7
movl $0x1, -0x4(%rbp)
jmp 0x8f13c6
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x8f119d
movl $0x0, -0x4(%rbp)
jmp 0x8f13c6
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x2d(%rbp)
je 0x8f1208
movq -0x28(%rbp), %rax
cmpl $0x5d, (%rax)
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x8f1211
jmp 0x8f123e
movq -0x28(%rbp), %rax
cmpl $0x5c, (%rax)
jne 0x8f1230
movq -0x28(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x8f1230
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0x8f11ed
movq -0x28(%rbp), %rax
cmpl $0x5d, (%rax)
jne 0x8f127f
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movl -0x1c(%rbp), %ecx
callq 0x8f1640
cmpl $0x0, %eax
jne 0x8f1272
movl $0x0, -0x4(%rbp)
jmp 0x8f13c6
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x8f13a9
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x8f1299
movl $0x0, -0x4(%rbp)
jmp 0x8f13c6
jmp 0x8f129b
jmp 0x8f13a9
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x8f12c1
movq -0x18(%rbp), %rax
cmpl $0x5c, (%rax)
je 0x8f12bf
movl $0x0, -0x4(%rbp)
jmp 0x8f13c6
jmp 0x8f12e9
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x8f12e7
movl $0x0, -0x4(%rbp)
jmp 0x8f13c6
jmp 0x8f12e9
jmp 0x8f13a9
movq -0x18(%rbp), %rax
cmpl $0x2f, (%rax)
je 0x8f130c
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x8f130c
movl $0x0, -0x4(%rbp)
jmp 0x8f13c6
movq -0x10(%rbp), %rdi
callq 0x8f15d0
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8f15d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x8f1346
movl -0x1c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x8f1346
movl $0x1, -0x4(%rbp)
jmp 0x8f13c6
movq -0x10(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x8f13a9
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x8f138e
movl -0x1c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x8f138e
movq -0x18(%rbp), %rdi
callq 0x8f15d0
cmpl $0x0, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x8f13c6
jmp 0x8f1390
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x8f13a7
movl $0x0, -0x4(%rbp)
jmp 0x8f13c6
jmp 0x8f13a9
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x8f10ad
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_pathmatch.c
|
pm_list
|
static int
pm_list(const char *start, const char *end, const char c, int flags)
{
const char *p = start;
char rangeStart = '\0', nextRangeStart;
int match = 1, nomatch = 0;
/* This will be used soon... */
(void)flags; /* UNUSED */
/* If this is a negated class, return success for nomatch. */
if ((*p == '!' || *p == '^') && p < end) {
match = 0;
nomatch = 1;
++p;
}
while (p < end) {
nextRangeStart = '\0';
switch (*p) {
case '-':
/* Trailing or initial '-' is not special. */
if ((rangeStart == '\0') || (p == end - 1)) {
if (*p == c)
return (match);
} else {
char rangeEnd = *++p;
if (rangeEnd == '\\')
rangeEnd = *++p;
if ((rangeStart <= c) && (c <= rangeEnd))
return (match);
}
break;
case '\\':
++p;
/* Fall through */
default:
if (*p == c)
return (match);
nextRangeStart = *p; /* Possible start of range. */
}
rangeStart = nextRangeStart;
++p;
}
return (nomatch);
}
|
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movl $0x1, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x21, %eax
je 0x8f1496
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5e, %eax
jne 0x8f14ba
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x8f14ba
movl $0x0, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x8f14bc
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x8f15c0
movb $0x0, -0x2a(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x3c(%rbp)
subl $0x2d, %eax
je 0x8f14f0
jmp 0x8f14df
movl -0x3c(%rbp), %eax
subl $0x5c, %eax
je 0x8f157d
jmp 0x8f1589
movsbl -0x29(%rbp), %eax
cmpl $0x0, %eax
je 0x8f150a
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jne 0x8f1526
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x8f1524
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8f15c6
jmp 0x8f157b
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb 0x1(%rax), %al
movb %al, -0x35(%rbp)
movsbl -0x35(%rbp), %eax
cmpl $0x5c, %eax
jne 0x8f1559
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb 0x1(%rax), %al
movb %al, -0x35(%rbp)
movsbl -0x29(%rbp), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jg 0x8f1579
movsbl -0x19(%rbp), %eax
movsbl -0x35(%rbp), %ecx
cmpl %ecx, %eax
jg 0x8f1579
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8f15c6
jmp 0x8f157b
jmp 0x8f15a9
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x8f15a0
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8f15c6
movq -0x28(%rbp), %rax
movb (%rax), %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x8f14bc
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_pathmatch.c
|
pm_slashskip_w
|
static const wchar_t *
pm_slashskip_w(const wchar_t *s) {
while ((*s == L'/')
|| (s[0] == L'.' && s[1] == L'/')
|| (s[0] == L'.' && s[1] == L'\0'))
++s;
return (s);
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x2f, (%rcx)
movb %al, -0x9(%rbp)
je 0x8f1620
movq -0x8(%rbp), %rax
cmpl $0x2e, (%rax)
jne 0x8f15fe
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x2f, 0x4(%rcx)
movb %al, -0x9(%rbp)
je 0x8f1620
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x2e, (%rcx)
movb %al, -0xa(%rbp)
jne 0x8f161a
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
sete %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x8f1629
jmp 0x8f1637
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x8f15d8
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_pathmatch.c
|
_archive_rb_tree_find_node
|
struct archive_rb_node *
__archive_rb_tree_find_node(struct archive_rb_tree *rbt, const void *key)
{
archive_rbto_compare_key_fn compare_key = rbt->rbt_ops->rbto_compare_key;
struct archive_rb_node *parent = rbt->rbt_root;
while (!RB_SENTINEL_P(parent)) {
const signed int diff = (*compare_key)(parent, key);
if (diff == 0)
return parent;
parent = parent->rb_nodes[diff > 0];
}
return NULL;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8f181b
jmp 0x8f185a
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x8f183c
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f1862
movq -0x28(%rbp), %rax
cmpl $0x0, -0x2c(%rbp)
setg %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x8f180b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_rb.c
|
_archive_rb_tree_find_node_geq
|
struct archive_rb_node *
__archive_rb_tree_find_node_geq(struct archive_rb_tree *rbt, const void *key)
{
archive_rbto_compare_key_fn compare_key = rbt->rbt_ops->rbto_compare_key;
struct archive_rb_node *parent = rbt->rbt_root;
struct archive_rb_node *last = NULL;
while (!RB_SENTINEL_P(parent)) {
const signed int diff = (*compare_key)(parent, key);
if (diff == 0)
return parent;
if (diff < 0)
last = parent;
parent = parent->rb_nodes[diff > 0];
}
return last;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8f18b3
jmp 0x8f1900
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x8f18d4
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f1908
cmpl $0x0, -0x34(%rbp)
jge 0x8f18e2
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, -0x34(%rbp)
setg %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x8f18a3
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_rb.c
|
_archive_rb_tree_find_node_leq
|
struct archive_rb_node *
__archive_rb_tree_find_node_leq(struct archive_rb_tree *rbt, const void *key)
{
archive_rbto_compare_key_fn compare_key = rbt->rbt_ops->rbto_compare_key;
struct archive_rb_node *parent = rbt->rbt_root;
struct archive_rb_node *last = NULL;
while (!RB_SENTINEL_P(parent)) {
const signed int diff = (*compare_key)(parent, key);
if (diff == 0)
return parent;
if (diff > 0)
last = parent;
parent = parent->rb_nodes[diff > 0];
}
return last;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8f1963
jmp 0x8f19b0
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x8f1984
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f19b8
cmpl $0x0, -0x34(%rbp)
jle 0x8f1992
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, -0x34(%rbp)
setg %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x8f1953
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_rb.c
|
_archive_rb_tree_insert_node
|
int
__archive_rb_tree_insert_node(struct archive_rb_tree *rbt,
struct archive_rb_node *self)
{
archive_rbto_compare_nodes_fn compare_nodes = rbt->rbt_ops->rbto_compare_nodes;
struct archive_rb_node *parent, *tmp;
unsigned int position;
int rebalance;
tmp = rbt->rbt_root;
/*
* This is a hack. Because rbt->rbt_root is just a
* struct archive_rb_node *, just like rb_node->rb_nodes[RB_DIR_LEFT],
* we can use this fact to avoid a lot of tests for root and know
* that even at root, updating
* RB_FATHER(rb_node)->rb_nodes[RB_POSITION(rb_node)] will
* update rbt->rbt_root.
*/
parent = (struct archive_rb_node *)(void *)&rbt->rbt_root;
position = RB_DIR_LEFT;
/*
* Find out where to place this new leaf.
*/
while (!RB_SENTINEL_P(tmp)) {
const signed int diff = (*compare_nodes)(tmp, self);
if (diff == 0) {
/*
* Node already exists; don't insert.
*/
return F;
}
parent = tmp;
position = (diff > 0);
tmp = parent->rb_nodes[position];
}
/*
* Initialize the node and insert as a leaf into the tree.
*/
RB_SET_FATHER(self, parent);
RB_SET_POSITION(self, position);
if (parent == (struct archive_rb_node *)(void *)&rbt->rbt_root) {
RB_MARK_BLACK(self); /* root is always black */
rebalance = F;
} else {
/*
* All new nodes are colored red. We only need to rebalance
* if our parent is also red.
*/
RB_MARK_RED(self);
rebalance = RB_RED_P(parent);
}
self->rb_left = parent->rb_nodes[position];
self->rb_right = parent->rb_nodes[position];
parent->rb_nodes[position] = self;
/*
* Rebalance tree after insertion
*/
if (rebalance)
__archive_rb_tree_insert_rebalance(rbt, self);
return T;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
cmpq $0x0, -0x30(%rbp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8f1a19
jmp 0x8f1a64
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0x8f1a3c
movl $0x0, -0x4(%rbp)
jmp 0x8f1b58
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x3c(%rbp)
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
jmp 0x8f1a09
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x3, %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpl $0x0, -0x34(%rbp)
je 0x8f1a97
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
orq $0x2, %rcx
movq %rcx, 0x10(%rax)
jmp 0x8f1aa7
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
andq $-0x3, %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jne 0x8f1acd
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
andq $-0x2, %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x38(%rbp)
jmp 0x8f1b0a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
orq $0x1, %rcx
movq %rcx, 0x10(%rax)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x3d(%rbp)
je 0x8f1aff
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
setne %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
cmpl $0x0, -0x38(%rbp)
je 0x8f1b51
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8f1b70
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_rb.c
|
_archive_rb_tree_prune_node
|
static void
__archive_rb_tree_prune_node(struct archive_rb_tree *rbt,
struct archive_rb_node *self, int rebalance)
{
const unsigned int which = RB_POSITION(self);
struct archive_rb_node *father = RB_FATHER(self);
/*
* Since we are childless, we know that self->rb_left is pointing
* to the sentinel node.
*/
father->rb_nodes[which] = self->rb_left;
/*
* Rebalance if requested.
*/
if (rebalance)
__archive_rb_tree_removal_rebalance(rbt, father, which);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
andq $0x2, %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
andq $-0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
cmpl $0x0, -0x14(%rbp)
je 0x8f1e28
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x8f2400
addq $0x20, %rsp
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_rb.c
|
_archive_rb_tree_prune_blackred_branch
|
static void
__archive_rb_tree_prune_blackred_branch(
struct archive_rb_node *self, unsigned int which)
{
struct archive_rb_node *father = RB_FATHER(self);
struct archive_rb_node *son = self->rb_nodes[which];
/*
* Remove ourselves from the tree and give our former child our
* properties (position, color, root).
*/
RB_COPY_PROPERTIES(son, self);
father->rb_nodes[RB_POSITION(son)] = son;
RB_SET_FATHER(son, father);
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
andq $-0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x10(%rax), %rcx
andq $0x3, %rcx
movq -0x20(%rbp), %rax
xorq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdi
andq $0x2, %rdi
xorl %ecx, %ecx
movl $0x1, %esi
cmpq $0x0, %rdi
cmovnel %esi, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x3, %rax
orq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_rb.c
|
_archive_rb_tree_iterate
|
struct archive_rb_node *
__archive_rb_tree_iterate(struct archive_rb_tree *rbt,
struct archive_rb_node *self, const unsigned int direction)
{
const unsigned int other = direction ^ RB_DIR_OTHER;
if (self == NULL) {
self = rbt->rbt_root;
if (RB_SENTINEL_P(self))
return NULL;
while (!RB_SENTINEL_P(self->rb_nodes[direction]))
self = self->rb_nodes[direction];
return self;
}
/*
* We can't go any further in this direction. We proceed up in the
* opposite direction until our parent is in direction we want to go.
*/
if (RB_SENTINEL_P(self->rb_nodes[direction])) {
while (!RB_ROOT_P(rbt, self)) {
if (other == (unsigned int)RB_POSITION(self))
return RB_FATHER(self);
self = RB_FATHER(self);
}
return NULL;
}
/*
* Advance down one in current direction and go down as far as possible
* in the opposite direction.
*/
self = self->rb_nodes[direction];
while (!RB_SENTINEL_P(self->rb_nodes[other]))
self = self->rb_nodes[other];
return self;
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
xorl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8f1f35
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8f1efe
movq $0x0, -0x8(%rbp)
jmp 0x8f1fe9
jmp 0x8f1f00
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8f1f17
jmp 0x8f1f28
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x8f1f00
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f1fe9
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
jne 0x8f1faa
jmp 0x8f1f45
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8f1f5b
jmp 0x8f1fa0
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rsi
andq $0x2, %rsi
xorl %ecx, %ecx
movl $0x1, %edx
cmpq $0x0, %rsi
cmovnel %edx, %ecx
cmpl %ecx, %eax
jne 0x8f1f8e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
andq $-0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x8f1fe9
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
andq $-0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x8f1f45
movq $0x0, -0x8(%rbp)
jmp 0x8f1fe9
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8f1fd0
jmp 0x8f1fe1
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x8f1fb9
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_rb.c
|
_archive_rb_tree_swap_prune_and_rebalance
|
static void
__archive_rb_tree_swap_prune_and_rebalance(struct archive_rb_tree *rbt,
struct archive_rb_node *self, struct archive_rb_node *standin)
{
const unsigned int standin_which = RB_POSITION(standin);
unsigned int standin_other = standin_which ^ RB_DIR_OTHER;
struct archive_rb_node *standin_son;
struct archive_rb_node *standin_father = RB_FATHER(standin);
int rebalance = RB_BLACK_P(standin);
if (standin_father == self) {
/*
* As a child of self, any children would be opposite of
* our parent.
*/
standin_son = standin->rb_nodes[standin_which];
} else {
/*
* Since we aren't a child of self, any children would be
* on the same side as our parent.
*/
standin_son = standin->rb_nodes[standin_other];
}
if (RB_RED_P(standin_son)) {
/*
* We know we have a red child so if we flip it to black
* we don't have to rebalance.
*/
RB_MARK_BLACK(standin_son);
rebalance = F;
if (standin_father != self) {
/*
* Change the son's parentage to point to his grandpa.
*/
RB_SET_FATHER(standin_son, standin_father);
RB_SET_POSITION(standin_son, standin_which);
}
}
if (standin_father == self) {
/*
* If we are about to delete the standin's father, then when
* we call rebalance, we need to use ourselves as our father.
* Otherwise remember our original father. Also, since we are
* our standin's father we only need to reparent the standin's
* brother.
*
* | R --> S |
* | Q S --> Q T |
* | t --> |
*
* Have our son/standin adopt his brother as his new son.
*/
standin_father = standin;
} else {
/*
* | R --> S . |
* | / \ | T --> / \ | / |
* | ..... | S --> ..... | T |
*
* Sever standin's connection to his father.
*/
standin_father->rb_nodes[standin_which] = standin_son;
/*
* Adopt the far son.
*/
standin->rb_nodes[standin_other] = self->rb_nodes[standin_other];
RB_SET_FATHER(standin->rb_nodes[standin_other], standin);
/*
* Use standin_other because we need to preserve standin_which
* for the removal_rebalance.
*/
standin_other = standin_which;
}
/*
* Move the only remaining son to our standin. If our standin is our
* son, this will be the only son needed to be moved.
*/
standin->rb_nodes[standin_other] = self->rb_nodes[standin_other];
RB_SET_FATHER(standin->rb_nodes[standin_other], standin);
/*
* Now copy the result of self to standin and then replace
* self with standin in the tree.
*/
RB_COPY_PROPERTIES(standin, self);
RB_SET_FATHER(standin, RB_FATHER(self));
RB_FATHER(standin)->rb_nodes[RB_POSITION(standin)] = standin;
if (rebalance)
__archive_rb_tree_removal_rebalance(rbt, standin_father, standin_which);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
andq $0x2, %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
xorl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
andq $-0x4, %rax
movq %rax, -0x30(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x35(%rbp)
je 0x8f205c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x8f2082
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x8f2091
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8f2110
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x8f2110
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
andq $-0x2, %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x8f210e
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x3, %rax
orq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpl $0x0, -0x1c(%rbp)
je 0x8f20fe
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
orq $0x2, %rcx
movq %rcx, 0x10(%rax)
jmp 0x8f210e
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
andq $-0x3, %rcx
movq %rcx, 0x10(%rax)
jmp 0x8f2110
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x8f2124
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x8f2178
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %edx
movq (%rax,%rdx,8), %rax
movq 0x10(%rax), %rax
andq $0x3, %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %edx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %edx
movq (%rax,%rdx,8), %rax
movq 0x10(%rax), %rax
andq $0x3, %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %edx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
xorq 0x10(%rax), %rcx
andq $0x3, %rcx
movq -0x18(%rbp), %rax
xorq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
andq $-0x4, %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x3, %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
andq $-0x4, %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdi
andq $0x2, %rdi
xorl %ecx, %ecx
movl $0x1, %esi
cmpq $0x0, %rdi
cmovnel %esi, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
cmpl $0x0, -0x34(%rbp)
je 0x8f2241
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x8f2400
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_rb.c
|
_archive_rb_tree_reparent_nodes
|
static void
__archive_rb_tree_reparent_nodes(
struct archive_rb_node *old_father, const unsigned int which)
{
const unsigned int other = which ^ RB_DIR_OTHER;
struct archive_rb_node * const grandpa = RB_FATHER(old_father);
struct archive_rb_node * const old_child = old_father->rb_nodes[which];
struct archive_rb_node * const new_father = old_child;
struct archive_rb_node * const new_child = old_father;
if (new_father == NULL)
return;
/*
* Exchange descendant linkages.
*/
grandpa->rb_nodes[RB_POSITION(old_father)] = new_father;
new_child->rb_nodes[which] = old_child->rb_nodes[other];
new_father->rb_nodes[other] = new_child;
/*
* Update ancestor linkages
*/
RB_SET_FATHER(new_father, grandpa);
RB_SET_FATHER(new_child, new_father);
/*
* Exchange properties between new_father and new_child. The only
* change is that new_child's position is now on the other side.
*/
RB_SWAP_PROPERTIES(new_father, new_child);
RB_SET_POSITION(new_child, other);
/*
* Make sure to reparent the new child to ourself.
*/
if (!RB_SENTINEL_P(new_child->rb_nodes[which])) {
RB_SET_FATHER(new_child->rb_nodes[which], new_child);
RB_SET_POSITION(new_child->rb_nodes[which], which);
}
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
xorl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
andq $-0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8f229f
jmp 0x8f23f0
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rdi
andq $0x2, %rdi
xorl %ecx, %ecx
movl $0x1, %esi
cmpq $0x0, %rdi
cmovnel %esi, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rax
movl -0x10(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x3, %rax
orq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x3, %rax
orq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
xorq 0x10(%rcx), %rax
andq $0x3, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
xorq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
xorq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
cmpl $0x0, -0x10(%rbp)
je 0x8f2373
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
orq $0x2, %rcx
movq %rcx, 0x10(%rax)
jmp 0x8f2383
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
andq $-0x3, %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x8f23f0
movq -0x30(%rbp), %rcx
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %edx
movq (%rax,%rdx,8), %rax
movq 0x10(%rax), %rax
andq $0x3, %rax
orq %rax, %rcx
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %edx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x10(%rax)
cmpl $0x0, -0xc(%rbp)
je 0x8f23d9
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rcx
orq $0x2, %rcx
movq %rcx, 0x10(%rax)
jmp 0x8f23f0
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rcx
andq $-0x3, %rcx
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_rb.c
|
_archive_rb_tree_removal_rebalance
|
static void
__archive_rb_tree_removal_rebalance(struct archive_rb_tree *rbt,
struct archive_rb_node *parent, unsigned int which)
{
while (RB_BLACK_P(parent->rb_nodes[which])) {
unsigned int other = which ^ RB_DIR_OTHER;
struct archive_rb_node *brother = parent->rb_nodes[other];
if (brother == NULL)
return;/* The tree may be broken. */
/*
* For cases 1, 2a, and 2b, our brother's children must
* be black and our father must be black
*/
if (RB_BLACK_P(parent)
&& RB_BLACK_P(brother->rb_left)
&& RB_BLACK_P(brother->rb_right)) {
if (RB_RED_P(brother)) {
/*
* Case 1: Our brother is red, swap its
* position (and colors) with our parent.
* This should now be case 2b (unless C or E
* has a red child which is case 3; thus no
* explicit branch to case 2b).
*
* B -> D
* A d -> b E
* C E -> A C
*/
__archive_rb_tree_reparent_nodes(parent, other);
brother = parent->rb_nodes[other];
if (brother == NULL)
return;/* The tree may be broken. */
} else {
/*
* Both our parent and brother are black.
* Change our brother to red, advance up rank
* and go through the loop again.
*
* B -> *B
* *A D -> A d
* C E -> C E
*/
RB_MARK_RED(brother);
if (RB_ROOT_P(rbt, parent))
return; /* root == parent == black */
which = RB_POSITION(parent);
parent = RB_FATHER(parent);
continue;
}
}
/*
* Avoid an else here so that case 2a above can hit either
* case 2b, 3, or 4.
*/
if (RB_RED_P(parent)
&& RB_BLACK_P(brother)
&& RB_BLACK_P(brother->rb_left)
&& RB_BLACK_P(brother->rb_right)) {
/*
* We are black, our father is red, our brother and
* both nephews are black. Simply invert/exchange the
* colors of our father and brother (to black and red
* respectively).
*
* | f --> F |
* | * B --> * b |
* | N N --> N N |
*/
RB_MARK_BLACK(parent);
RB_MARK_RED(brother);
break; /* We're done! */
} else {
/*
* Our brother must be black and have at least one
* red child (it may have two).
*/
if (RB_BLACK_P(brother->rb_nodes[other])) {
/*
* Case 3: our brother is black, our near
* nephew is red, and our far nephew is black.
* Swap our brother with our near nephew.
* This result in a tree that matches case 4.
* (Our father could be red or black).
*
* | F --> F |
* | x B --> x B |
* | n --> n |
*/
__archive_rb_tree_reparent_nodes(brother, which);
brother = parent->rb_nodes[other];
}
/*
* Case 4: our brother is black and our far nephew
* is red. Swap our father and brother locations and
* change our far nephew to black. (these can be
* done in either order so we change the color first).
* The result is a valid red-black tree and is a
* terminal case. (again we don't care about the
* father's color)
*
* If the father is red, we will get a red-black-black
* tree:
* | f -> f --> b |
* | B -> B --> F N |
* | n -> N --> |
*
* If the father is black, we will get an all black
* tree:
* | F -> F --> B |
* | B -> B --> F N |
* | n -> N --> |
*
* If we had two red nephews, then after the swap,
* our former father would have a red grandson.
*/
if (brother->rb_nodes[other] == NULL)
return;/* The tree may be broken. */
RB_MARK_BLACK(brother->rb_nodes[other]);
__archive_rb_tree_reparent_nodes(parent, other);
break; /* We're done! */
}
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %eax
movl %eax, %edx
movb $0x1, %al
cmpq $0x0, (%rcx,%rdx,8)
movb %al, -0x21(%rbp)
je 0x8f2445
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x8f2451
jmp 0x8f267f
movl -0x14(%rbp), %eax
xorl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8f2475
jmp 0x8f267f
cmpq $0x0, -0x10(%rbp)
je 0x8f2492
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x8f2572
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x8f24b5
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x8f2572
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x8f24da
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x8f2572
cmpq $0x0, -0x20(%rbp)
je 0x8f251c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x8f251c
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x8f2250
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8f251a
jmp 0x8f267f
jmp 0x8f2570
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
orq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x8f253e
jmp 0x8f267f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
andq $0x2, %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
andq $-0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x8f2413
jmp 0x8f2572
cmpq $0x0, -0x10(%rbp)
je 0x8f260a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x8f260a
cmpq $0x0, -0x20(%rbp)
je 0x8f25a8
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x8f260a
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x8f25c7
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x8f260a
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x8f25e8
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x8f260a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
andq $-0x2, %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
orq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x8f267f
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x8f2631
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x8f264c
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8f2250
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
jne 0x8f265c
jmp 0x8f267f
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rcx
andq $-0x2, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x8f2250
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_rb.c
|
archive_read_extract_set_skip_file
|
void
archive_read_extract_set_skip_file(struct archive *_a, la_int64_t d,
la_int64_t i)
{
struct archive_read *a = (struct archive_read *)_a;
if (ARCHIVE_OK != __archive_check_magic(_a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_ANY, "archive_read_extract_set_skip_file"))
return;
a->skip_file_set = 1;
a->skip_file_dev = d;
a->skip_file_ino = i;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x7fff, %edx # imm = 0x7FFF
leaq 0x2c6ca7(%rip), %rcx # 0xbb93f8
callq 0x9770c0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x8f2760
jmp 0x8f278c
movq -0x20(%rbp), %rax
movl $0x1, 0x98(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0xa8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
archive_read_open1
|
int
archive_read_open1(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
struct archive_read_filter *filter, *tmp;
int slot, e = ARCHIVE_OK;
archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
"archive_read_open");
archive_clear_error(&a->archive);
if (a->client.reader == NULL) {
archive_set_error(&a->archive, EINVAL,
"No reader function provided to archive_read_open");
a->archive.state = ARCHIVE_STATE_FATAL;
return (ARCHIVE_FATAL);
}
/* Open data source. */
if (a->client.opener != NULL) {
e = (a->client.opener)(&a->archive, a->client.dataset[0].data);
if (e != 0) {
/* If the open failed, call the closer to clean up. */
read_client_close_proxy(a);
return (e);
}
}
filter = calloc(1, sizeof(*filter));
if (filter == NULL)
return (ARCHIVE_FATAL);
filter->bidder = NULL;
filter->upstream = NULL;
filter->archive = a;
filter->data = a->client.dataset[0].data;
filter->vtable = &none_reader_vtable;
filter->name = "none";
filter->code = ARCHIVE_FILTER_NONE;
filter->can_skip = 1;
filter->can_seek = 1;
a->client.dataset[0].begin_position = 0;
if (!a->filter || !a->bypass_filter_bidding)
{
a->filter = filter;
/* Build out the input pipeline. */
e = choose_filters(a);
if (e < ARCHIVE_WARN) {
a->archive.state = ARCHIVE_STATE_FATAL;
return (ARCHIVE_FATAL);
}
}
else
{
/* Need to add "NONE" type filter at the end of the filter chain */
tmp = a->filter;
while (tmp->upstream)
tmp = tmp->upstream;
tmp->upstream = filter;
}
if (!a->format)
{
slot = choose_format(a);
if (slot < 0) {
close_filters(a);
a->archive.state = ARCHIVE_STATE_FATAL;
return (ARCHIVE_FATAL);
}
a->format = &(a->formats[slot]);
}
a->archive.state = ARCHIVE_STATE_HEADER;
/* Ensure libarchive starts from the first node in a multivolume set */
client_switch_proxy(a->filter, 0);
return (e);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
leaq 0x2c6baa(%rip), %rcx # 0xbb955a
callq 0x9770c0
movl %eax, -0x34(%rbp)
cmpl $-0x1e, -0x34(%rbp)
jne 0x8f29ca
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f2c1a
jmp 0x8f29cc
movq -0x18(%rbp), %rdi
callq 0x9401c0
movq -0x18(%rbp), %rax
cmpq $0x0, 0xb8(%rax)
jne 0x8f2a11
movq -0x18(%rbp), %rdi
movl $0x16, %esi
leaq 0x2c6b48(%rip), %rdx # 0xbb953b
movb $0x0, %al
callq 0x9401f0
movq -0x18(%rbp), %rax
movl $0x8000, 0x4(%rax) # imm = 0x8000
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f2c1a
movq -0x18(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
je 0x8f2a5e
movq -0x18(%rbp), %rax
movq 0xb0(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0xf0(%rcx), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x8f2a5c
movq -0x18(%rbp), %rdi
callq 0x8f3190
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8f2c1a
jmp 0x8f2a5e
movl $0x1, %edi
movl $0x90, %esi
callq 0x3e570
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8f2a84
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f2c1a
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0xf0(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
leaq 0x604c0e(%rip), %rcx # 0xef76d8
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
leaq 0x2d55db(%rip), %rcx # 0xbc80b4
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x3c(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x40(%rax)
movq -0x18(%rbp), %rax
movq 0xf0(%rax), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x278(%rax)
je 0x8f2b2b
movq -0x18(%rbp), %rax
cmpl $0x0, 0x280(%rax)
jne 0x8f2b65
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x278(%rax)
movq -0x18(%rbp), %rdi
callq 0x8f3230
movl %eax, -0x30(%rbp)
cmpl $-0x14, -0x30(%rbp)
jge 0x8f2b63
movq -0x18(%rbp), %rax
movl $0x8000, 0x4(%rax) # imm = 0x8000
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f2c1a
jmp 0x8f2b99
movq -0x18(%rbp), %rax
movq 0x278(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x8f2b8d
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x8f2b74
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x818(%rax)
jne 0x8f2bf7
movq -0x18(%rbp), %rdi
callq 0x8f33f0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x8f2bd6
movq -0x18(%rbp), %rdi
callq 0x8f3540
movq -0x18(%rbp), %rax
movl $0x8000, 0x4(%rax) # imm = 0x8000
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f2c1a
movq -0x18(%rbp), %rcx
addq $0x298, %rcx # imm = 0x298
movslq -0x2c(%rbp), %rax
imulq $0x58, %rax, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x818(%rax)
movq -0x18(%rbp), %rax
movl $0x2, 0x4(%rax)
movq -0x18(%rbp), %rax
movq 0x278(%rax), %rdi
xorl %esi, %esi
callq 0x8f35f0
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
archive_read_open2
|
int
archive_read_open2(struct archive *a, void *client_data,
archive_open_callback *client_opener,
archive_read_callback *client_reader,
archive_skip_callback *client_skipper,
archive_close_callback *client_closer)
{
/* Old archive_read_open2() is just a thin shell around
* archive_read_open1. */
archive_read_set_callback_data(a, client_data);
archive_read_set_open_callback(a, client_opener);
archive_read_set_read_callback(a, client_reader);
archive_read_set_skip_callback(a, client_skipper);
archive_read_set_close_callback(a, client_closer);
return archive_read_open1(a);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8f2950
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8f2800
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8f2870
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8f2ca0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x8f28e0
movq -0x8(%rbp), %rdi
callq 0x8f2980
addq $0x30, %rsp
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
read_client_close_proxy
|
static int
read_client_close_proxy(struct archive_read *a)
{
int r = ARCHIVE_OK, r2;
unsigned int i;
if (a->client.closer == NULL)
return (r);
for (i = 0; i < a->client.nodes; i++)
{
r2 = (a->client.closer)
((struct archive *)a, a->client.dataset[i].data);
if (r > r2)
r = r2;
}
return (r);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
jne 0x8f31b9
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8f321d
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xe0(%rcx), %eax
jae 0x8f3217
movq -0x10(%rbp), %rax
movq 0xd0(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0xf0(%rcx), %rcx
movl -0x1c(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq 0x10(%rcx), %rsi
callq *%rax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x8f320a
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x8f320c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8f31c0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
choose_format
|
static int
choose_format(struct archive_read *a)
{
int slots;
int i;
int bid, best_bid;
int best_bid_slot;
slots = sizeof(a->formats) / sizeof(a->formats[0]);
best_bid = -1;
best_bid_slot = -1;
/* Set up a->format for convenience of bidders. */
a->format = &(a->formats[0]);
for (i = 0; i < slots; i++, a->format++) {
if (a->format->bid) {
bid = (a->format->bid)(a, best_bid);
if (bid == ARCHIVE_FATAL)
return (ARCHIVE_FATAL);
if (a->filter->position != 0)
__archive_read_seek(a, 0, SEEK_SET);
if ((bid > best_bid) || (best_bid_slot < 0)) {
best_bid = bid;
best_bid_slot = i;
}
}
}
/*
* There were no bidders; this is a serious programmer error
* and demands a quick and definitive abort.
*/
if (best_bid_slot < 0) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"No formats registered");
return (ARCHIVE_FATAL);
}
/*
* There were bidders, but no non-zero bids; this means we
* can't support this stream.
*/
if (best_bid < 1) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Unrecognized archive format");
return (ARCHIVE_FATAL);
}
return (best_bid_slot);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x10, -0x14(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rcx
addq $0x298, %rcx # imm = 0x298
movq -0x10(%rbp), %rax
movq %rcx, 0x818(%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8f34db
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x8f34b5
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $-0x1e, -0x1c(%rbp)
jne 0x8f3479
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f352d
movq -0x10(%rbp), %rax
movq 0x278(%rax), %rax
cmpq $0x0, (%rax)
je 0x8f3499
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x8f4b10
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x8f34a7
cmpl $0x0, -0x24(%rbp)
jge 0x8f34b3
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x8f34b5
jmp 0x8f34b7
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rcx
addq $0x58, %rcx
movq %rcx, 0x818(%rax)
jmp 0x8f342e
cmpl $0x0, -0x24(%rbp)
jge 0x8f3501
movq -0x10(%rbp), %rdi
movl $0x54, %esi
leaq 0x2c6318(%rip), %rdx # 0xbb9809
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f352d
cmpl $0x1, -0x20(%rbp)
jge 0x8f3527
movq -0x10(%rbp), %rdi
movl $0x54, %esi
leaq 0x2c6308(%rip), %rdx # 0xbb981f
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f352d
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
close_filters
|
static int
close_filters(struct archive_read *a)
{
struct archive_read_filter *f = a->filter;
int r = ARCHIVE_OK;
/* Close each filter in the pipeline. */
while (f != NULL) {
struct archive_read_filter *t = f->upstream;
if (!f->closed && f->vtable != NULL) {
int r1 = (f->vtable->close)(f);
f->closed = 1;
if (r1 < r)
r = r1;
}
free(f->buffer);
f->buffer = NULL;
f = t;
}
return r;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x278(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8f35e0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x89(%rax)
jne 0x8f35bd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x8f35bd
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movb $0x1, 0x89(%rax)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8f35bb
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x8f35bd
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x3e548
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x8f3562
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
client_switch_proxy
|
static int
client_switch_proxy(struct archive_read_filter *self, unsigned int iindex)
{
int r1 = ARCHIVE_OK, r2 = ARCHIVE_OK;
void *data2 = NULL;
/* Don't do anything if already in the specified data node */
if (self->archive->client.cursor == iindex)
return (ARCHIVE_OK);
self->archive->client.cursor = iindex;
data2 = self->archive->client.dataset[self->archive->client.cursor].data;
if (self->archive->client.switcher != NULL)
{
r1 = r2 = (self->archive->client.switcher)
((struct archive *)self->archive, self->data, data2);
self->data = data2;
}
else
{
/* Attempt to call close and open instead */
if (self->archive->client.closer != NULL)
r1 = (self->archive->client.closer)
((struct archive *)self->archive, self->data);
self->data = data2;
r2 = client_open_proxy(self);
}
return (r1 < r2) ? r1 : r2;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0xe4(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x8f3634
movl $0x0, -0x4(%rbp)
jmp 0x8f3726
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl %ecx, 0xe4(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0xf0(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movl 0xe4(%rcx), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0xd8(%rax)
je 0x8f36bc
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0xd8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rsi
movq -0x28(%rbp), %rdx
callq *%rax
movl %eax, -0x1c(%rbp)
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x8f370a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0xd0(%rax)
je 0x8f36f2
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0xd0(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rsi
callq *%rax
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0x8f5a00
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x8f371a
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x8f3720
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
archive_read_has_encrypted_entries
|
int
archive_read_has_encrypted_entries(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
int format_supports_encryption = archive_read_format_capabilities(_a)
& (ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_DATA | ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_METADATA);
if (!_a || !format_supports_encryption) {
/* Format in general doesn't support encryption */
return ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED;
}
/* A reader potentially has read enough data now. */
if (a->format && a->format->has_encrypted_entries) {
return (a->format->has_encrypted_entries)(a);
}
/* For any other reason we cannot say how many entries are there. */
return ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8f3880
andl $0x3, %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8f3820
cmpl $0x0, -0x1c(%rbp)
jne 0x8f3829
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x8f386a
movq -0x18(%rbp), %rax
cmpq $0x0, 0x818(%rax)
je 0x8f3863
movq -0x18(%rbp), %rax
movq 0x818(%rax), %rax
cmpq $0x0, 0x50(%rax)
je 0x8f3863
movq -0x18(%rbp), %rax
movq 0x818(%rax), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x8f386a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
archive_read_data
|
la_ssize_t
archive_read_data(struct archive *_a, void *buff, size_t s)
{
struct archive *a = (struct archive *)_a;
char *dest;
const void *read_buf;
size_t bytes_read;
size_t len;
int r;
bytes_read = 0;
dest = (char *)buff;
while (s > 0) {
if (a->read_data_offset == a->read_data_output_offset &&
a->read_data_remaining == 0) {
read_buf = a->read_data_block;
a->read_data_is_posix_read = 1;
a->read_data_requested = s;
r = archive_read_data_block(a, &read_buf,
&a->read_data_remaining, &a->read_data_offset);
a->read_data_block = read_buf;
if (r == ARCHIVE_EOF)
return (bytes_read);
/*
* Error codes are all negative, so the status
* return here cannot be confused with a valid
* byte count. (ARCHIVE_OK is zero.)
*/
if (r < ARCHIVE_OK)
return (r);
}
if (a->read_data_offset < a->read_data_output_offset) {
archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT,
"Encountered out-of-order sparse blocks");
return (ARCHIVE_RETRY);
}
/* Compute the amount of zero padding needed. */
if (a->read_data_output_offset + (int64_t)s <
a->read_data_offset) {
len = s;
} else if (a->read_data_output_offset <
a->read_data_offset) {
len = (size_t)(a->read_data_offset -
a->read_data_output_offset);
} else
len = 0;
/* Add zeroes. */
memset(dest, 0, len);
s -= len;
a->read_data_output_offset += len;
dest += len;
bytes_read += len;
/* Copy data if there is any space left. */
if (s > 0) {
len = a->read_data_remaining;
if (len > s)
len = s;
if (len) {
memcpy(dest, a->read_data_block, len);
s -= len;
a->read_data_block += len;
a->read_data_remaining -= len;
a->read_data_output_offset += len;
a->read_data_offset += len;
dest += len;
bytes_read += len;
}
}
}
a->read_data_is_posix_read = 0;
a->read_data_requested = 0;
return (bytes_read);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x8f3b46
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x70(%rcx), %rax
jne 0x8f39c2
movq -0x28(%rbp), %rax
cmpq $0x0, 0x78(%rax)
jne 0x8f39c2
movq -0x28(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movb $0x1, 0x80(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x28(%rbp), %rdi
movq -0x28(%rbp), %rdx
addq $0x78, %rdx
movq -0x28(%rbp), %rcx
addq $0x68, %rcx
leaq -0x38(%rbp), %rsi
callq 0x940c10
movl %eax, -0x4c(%rbp)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x60(%rax)
cmpl $0x1, -0x4c(%rbp)
jne 0x8f39ad
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f3b68
cmpl $0x0, -0x4c(%rbp)
jge 0x8f39c0
movslq -0x4c(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f3b68
jmp 0x8f39c2
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x70(%rcx), %rax
jge 0x8f39f8
movq -0x28(%rbp), %rdi
movl $0x54, %esi
leaq 0x2c5ba5(%rip), %rdx # 0xbb9589
movb $0x0, %al
callq 0x9401f0
movq $-0xa, -0x8(%rbp)
jmp 0x8f3b68
movq -0x28(%rbp), %rax
movq 0x70(%rax), %rax
addq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x68(%rcx), %rax
jge 0x8f3a18
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x8f3a4a
movq -0x28(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x68(%rcx), %rax
jge 0x8f3a40
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x28(%rbp), %rcx
subq 0x70(%rcx), %rax
movq %rax, -0x48(%rbp)
jmp 0x8f3a48
movq $0x0, -0x48(%rbp)
jmp 0x8f3a4a
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rdx
xorl %esi, %esi
callq 0x3b780
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x70(%rax), %rcx
movq %rcx, 0x70(%rax)
movq -0x48(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x8f3b41
movq -0x28(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x8f3ab9
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x8f3b3f
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x60(%rax), %rsi
movq -0x48(%rbp), %rdx
callq 0x3cb70
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x60(%rax), %rcx
movq %rcx, 0x60(%rax)
movq -0x48(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x78(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x78(%rax)
movq -0x48(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x70(%rax), %rcx
movq %rcx, 0x70(%rax)
movq -0x48(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x68(%rax), %rcx
movq %rcx, 0x68(%rax)
movq -0x48(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x8f3b41
jmp 0x8f391c
movq -0x28(%rbp), %rax
movb $0x0, 0x80(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x88(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
archive_read_data_skip
|
int
archive_read_data_skip(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
int r;
const void *buff;
size_t size;
int64_t offset;
archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_DATA,
"archive_read_data_skip");
if (a->format->read_data_skip != NULL)
r = (a->format->read_data_skip)(a);
else {
while ((r = archive_read_data_block(&a->archive,
&buff, &size, &offset))
== ARCHIVE_OK)
;
}
if (r == ARCHIVE_EOF)
r = ARCHIVE_OK;
a->archive.state = ARCHIVE_STATE_HEADER;
return (r);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x4, %edx
leaq 0x2c59a7(%rip), %rcx # 0xbb95b0
callq 0x9770c0
movl %eax, -0x3c(%rbp)
cmpl $-0x1e, -0x3c(%rbp)
jne 0x8f3c20
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f3c8f
jmp 0x8f3c22
movq -0x18(%rbp), %rax
movq 0x818(%rax), %rax
cmpq $0x0, 0x30(%rax)
je 0x8f3c4e
movq -0x18(%rbp), %rax
movq 0x818(%rax), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movl %eax, -0x1c(%rbp)
jmp 0x8f3c71
jmp 0x8f3c50
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x940c10
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jne 0x8f3c6f
jmp 0x8f3c50
jmp 0x8f3c71
cmpl $0x1, -0x1c(%rbp)
jne 0x8f3c7e
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl $0x2, 0x4(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
archive_seek_data
|
la_int64_t
archive_seek_data(struct archive *_a, int64_t offset, int whence)
{
struct archive_read *a = (struct archive_read *)_a;
archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_DATA,
"archive_seek_data_block");
if (a->format->seek_data == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
"Internal error: "
"No format_seek_data_block function registered");
return (ARCHIVE_FATAL);
}
return (a->format->seek_data)(a, offset, whence);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x4, %edx
leaq 0x2c58f7(%rip), %rcx # 0xbb95c7
callq 0x9770c0
movl %eax, -0x2c(%rbp)
cmpl $-0x1e, -0x2c(%rbp)
jne 0x8f3ce8
movq $-0x1e, -0x8(%rbp)
jmp 0x8f3d3d
jmp 0x8f3cea
movq -0x28(%rbp), %rax
movq 0x818(%rax), %rax
cmpq $0x0, 0x38(%rax)
jne 0x8f3d1d
movq -0x28(%rbp), %rdi
movl $0x16, %esi
leaq 0x2c58d3(%rip), %rdx # 0xbb95df
movb $0x0, %al
callq 0x9401f0
movq $-0x1e, -0x8(%rbp)
jmp 0x8f3d3d
movq -0x28(%rbp), %rax
movq 0x818(%rax), %rax
movq 0x38(%rax), %rax
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
_archive_read_free_filters
|
void
__archive_read_free_filters(struct archive_read *a)
{
/* Make sure filters are closed and their buffers are freed */
close_filters(a);
while (a->filter != NULL) {
struct archive_read_filter *t = a->filter->upstream;
free(a->filter);
a->filter = t;
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f3540
movq -0x8(%rbp), %rax
cmpq $0x0, 0x278(%rax)
je 0x8f3da7
movq -0x8(%rbp), %rax
movq 0x278(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x278(%rax), %rdi
callq 0x3e548
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x278(%rax)
jmp 0x8f3d65
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
_archive_read_filter_ahead
|
const void *
__archive_read_filter_ahead(struct archive_read_filter *filter,
size_t min, ssize_t *avail)
{
ssize_t bytes_read;
size_t tocopy;
if (filter->fatal) {
if (avail)
*avail = ARCHIVE_FATAL;
return (NULL);
}
/*
* Keep pulling more data until we can satisfy the request.
*/
for (;;) {
/*
* If we can satisfy from the copy buffer (and the
* copy buffer isn't empty), we're done. In particular,
* note that min == 0 is a perfectly well-defined
* request.
*/
if (filter->avail >= min && filter->avail > 0) {
if (avail != NULL)
*avail = filter->avail;
return (filter->next);
}
/*
* We can satisfy directly from client buffer if everything
* currently in the copy buffer is still in the client buffer.
*/
if (filter->client_total >= filter->client_avail + filter->avail
&& filter->client_avail + filter->avail >= min) {
/* "Roll back" to client buffer. */
filter->client_avail += filter->avail;
filter->client_next -= filter->avail;
/* Copy buffer is now empty. */
filter->avail = 0;
filter->next = filter->buffer;
/* Return data from client buffer. */
if (avail != NULL)
*avail = filter->client_avail;
return (filter->client_next);
}
/* Move data forward in copy buffer if necessary. */
if (filter->next > filter->buffer &&
filter->next + min > filter->buffer + filter->buffer_size) {
if (filter->avail > 0)
memmove(filter->buffer, filter->next,
filter->avail);
filter->next = filter->buffer;
}
/* If we've used up the client data, get more. */
if (filter->client_avail <= 0) {
if (filter->end_of_file) {
if (avail != NULL)
*avail = 0;
return (NULL);
}
bytes_read = (filter->vtable->read)(filter,
&filter->client_buff);
if (bytes_read < 0) { /* Read error. */
filter->client_total = filter->client_avail = 0;
filter->client_next =
filter->client_buff = NULL;
filter->fatal = 1;
if (avail != NULL)
*avail = ARCHIVE_FATAL;
return (NULL);
}
if (bytes_read == 0) {
/* Check for another client object first */
if (filter->archive->client.cursor !=
filter->archive->client.nodes - 1) {
if (client_switch_proxy(filter,
filter->archive->client.cursor + 1)
== ARCHIVE_OK)
continue;
}
/* Premature end-of-file. */
filter->client_total = filter->client_avail = 0;
filter->client_next =
filter->client_buff = NULL;
filter->end_of_file = 1;
/* Return whatever we do have. */
if (avail != NULL)
*avail = filter->avail;
return (NULL);
}
filter->client_total = bytes_read;
filter->client_avail = filter->client_total;
filter->client_next = filter->client_buff;
} else {
/*
* We can't satisfy the request from the copy
* buffer or the existing client data, so we
* need to copy more client data over to the
* copy buffer.
*/
/* Ensure the buffer is big enough. */
if (min > filter->buffer_size) {
size_t s, t;
char *p;
/* Double the buffer; watch for overflow. */
s = t = filter->buffer_size;
if (s == 0)
s = min;
while (s < min) {
t *= 2;
if (t <= s) { /* Integer overflow! */
archive_set_error(
&filter->archive->archive,
ENOMEM,
"Unable to allocate copy"
" buffer");
filter->fatal = 1;
if (avail != NULL)
*avail = ARCHIVE_FATAL;
return (NULL);
}
s = t;
}
/* Now s >= min, so allocate a new buffer. */
p = (char *)malloc(s);
if (p == NULL) {
archive_set_error(
&filter->archive->archive,
ENOMEM,
"Unable to allocate copy buffer");
filter->fatal = 1;
if (avail != NULL)
*avail = ARCHIVE_FATAL;
return (NULL);
}
/* Move data into newly-enlarged buffer. */
if (filter->avail > 0)
memmove(p, filter->next, filter->avail);
free(filter->buffer);
filter->next = filter->buffer = p;
filter->buffer_size = s;
}
/* We can add client data to copy buffer. */
/* First estimate: copy to fill rest of buffer. */
tocopy = (filter->buffer + filter->buffer_size)
- (filter->next + filter->avail);
/* Don't waste time buffering more than we need to. */
if (tocopy + filter->avail > min)
tocopy = min - filter->avail;
/* Don't copy more than is available. */
if (tocopy > filter->client_avail)
tocopy = filter->client_avail;
memcpy(filter->next + filter->avail,
filter->client_next, tocopy);
/* Remove this data from client buffer. */
filter->client_next += tocopy;
filter->client_avail -= tocopy;
/* add it to copy buffer. */
filter->avail += tocopy;
}
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x8a(%rax)
je 0x8f41e0
cmpq $0x0, -0x20(%rbp)
je 0x8f41d3
movq -0x20(%rbp), %rax
movq $-0x1e, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x8f4701
jmp 0x8f41e2
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
cmpq -0x18(%rbp), %rax
jb 0x8f4222
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jbe 0x8f4222
cmpq $0x0, -0x20(%rbp)
je 0x8f4211
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f4701
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x80(%rcx), %rcx
movq -0x10(%rbp), %rdx
addq 0x60(%rdx), %rcx
cmpq %rcx, %rax
jb 0x8f42db
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x60(%rcx), %rax
cmpq -0x18(%rbp), %rax
jb 0x8f42db
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x80(%rax), %rcx
movq %rcx, 0x80(%rax)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rcx
xorl %edx, %edx
subq %rsi, %rdx
addq %rdx, %rcx
movq %rcx, 0x78(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x8f42ca
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f4701
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jbe 0x8f4346
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rcx
movq -0x10(%rbp), %rdx
addq 0x50(%rdx), %rcx
cmpq %rcx, %rax
jbe 0x8f4346
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jbe 0x8f4336
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdx
callq 0x3b370
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x80(%rax)
ja 0x8f44ee
movq -0x10(%rbp), %rax
cmpb $0x0, 0x88(%rax)
je 0x8f4384
cmpq $0x0, -0x20(%rbp)
je 0x8f4377
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x8f4701
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x68, %rsi
callq *%rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x8f4405
movq -0x10(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x8a(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x8f43f8
movq -0x20(%rbp), %rax
movq $-0x1e, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x8f4701
cmpq $0x0, -0x28(%rbp)
jne 0x8f44ba
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0xe4(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movl 0xe0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x8f4459
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0xe4(%rax), %esi
addl $0x1, %esi
callq 0x8f35f0
cmpl $0x0, %eax
jne 0x8f4457
jmp 0x8f41e2
jmp 0x8f4459
movq -0x10(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x88(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x8f44ad
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x8f4701
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x78(%rax)
jmp 0x8f46fc
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jbe 0x8f4639
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x8f451f
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x8f4521
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x8f458f
movq -0x40(%rbp), %rax
shlq %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
ja 0x8f4585
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0xc, %esi
leaq 0x2c5187(%rip), %rdx # 0xbb96db
movb $0x0, %al
callq 0x9401f0
movq -0x10(%rbp), %rax
movb $0x1, 0x8a(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x8f4578
movq -0x20(%rbp), %rax
movq $-0x1e, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x8f4701
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x8f4521
movq -0x38(%rbp), %rdi
callq 0x3e578
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x8f45e8
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0xc, %esi
leaq 0x2c5124(%rip), %rdx # 0xbb96db
movb $0x0, %al
callq 0x9401f0
movq -0x10(%rbp), %rax
movb $0x1, 0x8a(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x8f45db
movq -0x20(%rbp), %rax
movq $-0x1e, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x8f4701
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jbe 0x8f460c
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdx
callq 0x3b370
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x3e548
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x50(%rcx), %rax
movq -0x10(%rbp), %rcx
movq 0x58(%rcx), %rcx
movq -0x10(%rbp), %rdx
addq 0x60(%rdx), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
addq 0x60(%rcx), %rax
cmpq -0x18(%rbp), %rax
jbe 0x8f4682
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq 0x60(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x80(%rcx), %rax
jbe 0x8f46a2
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x10(%rbp), %rax
addq 0x60(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rsi
movq -0x30(%rbp), %rdx
callq 0x3cb70
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x78(%rax), %rcx
movq %rcx, 0x78(%rax)
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x80(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x60(%rax), %rcx
movq %rcx, 0x60(%rax)
jmp 0x8f41e2
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
_archive_read_filter_consume
|
int64_t
__archive_read_filter_consume(struct archive_read_filter * filter,
int64_t request)
{
int64_t skipped;
if (request < 0)
return ARCHIVE_FATAL;
if (request == 0)
return 0;
skipped = advance_file_pointer(filter, request);
if (skipped == request)
return (skipped);
/* We hit EOF before we satisfied the skip request. */
if (skipped < 0) /* Map error code to 0 for error message below. */
skipped = 0;
archive_set_error(&filter->archive->archive,
ARCHIVE_ERRNO_MISC,
"Truncated input file (needed %jd bytes, only %jd available)",
(intmax_t)request, (intmax_t)skipped);
return (ARCHIVE_FATAL);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x8f4761
movq $-0x1e, -0x8(%rbp)
jmp 0x8f47d1
cmpq $0x0, -0x18(%rbp)
jne 0x8f4772
movq $0x0, -0x8(%rbp)
jmp 0x8f47d1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8f47e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x8f4797
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f47d1
cmpq $0x0, -0x20(%rbp)
jge 0x8f47a6
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x2c4f38(%rip), %rdx # 0xbb96fa
movb $0x0, %al
callq 0x9401f0
movq $-0x1e, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
advance_file_pointer
|
static int64_t
advance_file_pointer(struct archive_read_filter *filter, int64_t request)
{
int64_t bytes_skipped, total_bytes_skipped = 0;
ssize_t bytes_read;
size_t min;
if (filter->fatal)
return (-1);
/* Use up the copy buffer first. */
if (filter->avail > 0) {
min = (size_t)minimum(request, (int64_t)filter->avail);
filter->next += min;
filter->avail -= min;
request -= min;
filter->position += min;
total_bytes_skipped += min;
}
/* Then use up the client buffer. */
if (filter->client_avail > 0) {
min = (size_t)minimum(request, (int64_t)filter->client_avail);
filter->client_next += min;
filter->client_avail -= min;
request -= min;
filter->position += min;
total_bytes_skipped += min;
}
if (request == 0)
return (total_bytes_skipped);
/* If there's an optimized skip function, use it. */
if (filter->can_skip != 0) {
bytes_skipped = client_skip_proxy(filter, request);
if (bytes_skipped < 0) { /* error */
filter->fatal = 1;
return (bytes_skipped);
}
filter->position += bytes_skipped;
total_bytes_skipped += bytes_skipped;
request -= bytes_skipped;
if (request == 0)
return (total_bytes_skipped);
}
/* Use ordinary reads as necessary to complete the request. */
for (;;) {
bytes_read = (filter->vtable->read)(filter, &filter->client_buff);
if (bytes_read < 0) {
filter->client_buff = NULL;
filter->fatal = 1;
return (bytes_read);
}
if (bytes_read == 0) {
if (filter->archive->client.cursor !=
filter->archive->client.nodes - 1) {
if (client_switch_proxy(filter,
filter->archive->client.cursor + 1)
== ARCHIVE_OK)
continue;
}
filter->client_buff = NULL;
filter->end_of_file = 1;
return (total_bytes_skipped);
}
if (bytes_read >= request) {
filter->client_next =
((const char *)filter->client_buff) + request;
filter->client_avail = (size_t)(bytes_read - request);
filter->client_total = bytes_read;
total_bytes_skipped += request;
filter->position += request;
return (total_bytes_skipped);
}
filter->position += bytes_read;
total_bytes_skipped += bytes_read;
request -= bytes_read;
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x8a(%rax)
je 0x8f4812
movq $-0x1, -0x8(%rbp)
jmp 0x8f4b05
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jbe 0x8f4895
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x60(%rcx), %rax
jge 0x8f4835
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x8f4841
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x58(%rax), %rcx
movq %rcx, 0x58(%rax)
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x60(%rax)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x80(%rax)
jbe 0x8f492b
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x80(%rcx), %rax
jge 0x8f48c2
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x8f48d1
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x78(%rax), %rcx
movq %rcx, 0x78(%rax)
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x80(%rax)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8f493f
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f4b05
movq -0x10(%rbp), %rax
cmpl $0x0, 0x3c(%rax)
je 0x8f49b8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8f5a60
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x8f4979
movq -0x10(%rbp), %rax
movb $0x1, 0x8a(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f4b05
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8f49b6
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f4b05
jmp 0x8f49b8
jmp 0x8f49ba
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x68, %rsi
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0x8f4a02
movq -0x10(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x8a(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f4b05
cmpq $0x0, -0x30(%rbp)
jne 0x8f4a76
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0xe4(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movl 0xe0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x8f4a52
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0xe4(%rax), %esi
addl $0x1, %esi
callq 0x8f35f0
cmpl $0x0, %eax
jne 0x8f4a50
jmp 0x8f49ba
jmp 0x8f4a52
movq -0x10(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x88(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f4b05
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jl 0x8f4ad7
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
addq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x30(%rbp), %rcx
subq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x18(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f4b05
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x8f49ba
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
_archive_read_filter_seek
|
int64_t
__archive_read_filter_seek(struct archive_read_filter *filter, int64_t offset,
int whence)
{
struct archive_read_client *client;
int64_t r;
unsigned int cursor;
if (filter->closed || filter->fatal)
return (ARCHIVE_FATAL);
if (filter->can_seek == 0)
return (ARCHIVE_FAILED);
client = &(filter->archive->client);
switch (whence) {
case SEEK_CUR:
/* Adjust the offset and use SEEK_SET instead */
offset += filter->position;
__LA_FALLTHROUGH;
case SEEK_SET:
cursor = 0;
while (1)
{
if (client->dataset[cursor].begin_position < 0 ||
client->dataset[cursor].total_size < 0 ||
client->dataset[cursor].begin_position +
client->dataset[cursor].total_size - 1 > offset ||
cursor + 1 >= client->nodes)
break;
r = client->dataset[cursor].begin_position +
client->dataset[cursor].total_size;
client->dataset[++cursor].begin_position = r;
}
while (1) {
r = client_switch_proxy(filter, cursor);
if (r != ARCHIVE_OK)
return r;
if ((r = client_seek_proxy(filter, 0, SEEK_END)) < 0)
return r;
client->dataset[cursor].total_size = r;
if (client->dataset[cursor].begin_position +
client->dataset[cursor].total_size - 1 > offset ||
cursor + 1 >= client->nodes)
break;
r = client->dataset[cursor].begin_position +
client->dataset[cursor].total_size;
client->dataset[++cursor].begin_position = r;
}
offset -= client->dataset[cursor].begin_position;
if (offset < 0
|| offset > client->dataset[cursor].total_size)
return ARCHIVE_FATAL;
if ((r = client_seek_proxy(filter, offset, SEEK_SET)) < 0)
return r;
break;
case SEEK_END:
cursor = 0;
while (1) {
if (client->dataset[cursor].begin_position < 0 ||
client->dataset[cursor].total_size < 0 ||
cursor + 1 >= client->nodes)
break;
r = client->dataset[cursor].begin_position +
client->dataset[cursor].total_size;
client->dataset[++cursor].begin_position = r;
}
while (1) {
r = client_switch_proxy(filter, cursor);
if (r != ARCHIVE_OK)
return r;
if ((r = client_seek_proxy(filter, 0, SEEK_END)) < 0)
return r;
client->dataset[cursor].total_size = r;
r = client->dataset[cursor].begin_position +
client->dataset[cursor].total_size;
if (cursor + 1 >= client->nodes)
break;
client->dataset[++cursor].begin_position = r;
}
while (1) {
if (r + offset >=
client->dataset[cursor].begin_position)
break;
offset += client->dataset[cursor].total_size;
if (cursor == 0)
break;
cursor--;
r = client->dataset[cursor].begin_position +
client->dataset[cursor].total_size;
}
offset = (r + offset) - client->dataset[cursor].begin_position;
if ((r = client_switch_proxy(filter, cursor)) != ARCHIVE_OK)
return r;
r = client_seek_proxy(filter, offset, SEEK_SET);
if (r < ARCHIVE_OK)
return r;
break;
default:
return (ARCHIVE_FATAL);
}
r += client->dataset[cursor].begin_position;
if (r >= 0) {
/*
* Ouch. Clearing the buffer like this hurts, especially
* at bid time. A lot of our efficiency at bid time comes
* from having bidders reuse the data we've already read.
*
* TODO: If the seek request is in data we already
* have, then don't call the seek callback.
*
* TODO: Zip seeks to end-of-file at bid time. If
* other formats also start doing this, we may need to
* find a way for clients to fudge the seek offset to
* a block boundary.
*
* Hmmm... If whence was SEEK_END, we know the file
* size is (r - offset). Can we use that to simplify
* the TODO items above?
*/
filter->avail = filter->client_avail = 0;
filter->next = filter->buffer;
filter->position = r;
filter->end_of_file = 0;
}
return r;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x89(%rax), %eax
cmpl $0x0, %eax
jne 0x8f4b73
movq -0x10(%rbp), %rax
movsbl 0x8a(%rax), %eax
cmpl $0x0, %eax
je 0x8f4b80
movq $-0x1e, -0x8(%rbp)
jmp 0x8f510b
movq -0x10(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jne 0x8f4b97
movq $-0x19, -0x8(%rbp)
jmp 0x8f510b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
addq $0xb0, %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
testl %eax, %eax
je 0x8f4bdf
jmp 0x8f4bb5
movl -0x38(%rbp), %eax
subl $0x1, %eax
je 0x8f4bd0
jmp 0x8f4bbf
movl -0x38(%rbp), %eax
subl $0x2, %eax
je 0x8f4e33
jmp 0x8f5094
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jl 0x8f4c5b
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
jl 0x8f4c5b
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x40(%rcx), %rcx
movl -0x34(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
addq 0x8(%rcx), %rax
subq $0x1, %rax
cmpq -0x18(%rbp), %rax
jg 0x8f4c5b
movl -0x34(%rbp), %eax
addl $0x1, %eax
movq -0x28(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jb 0x8f4c5d
jmp 0x8f4cb2
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x40(%rcx), %rcx
movl -0x34(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %edx
addl $0x1, %edx
movl %edx, -0x34(%rbp)
movl %edx, %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
jmp 0x8f4be6
jmp 0x8f4cb4
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x8f35f0
cltq
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x8f4cda
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f510b
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x8f5120
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jge 0x8f4d03
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f510b
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x40(%rcx), %rcx
movl -0x34(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
addq 0x8(%rcx), %rax
subq $0x1, %rax
cmpq -0x18(%rbp), %rax
jg 0x8f4d61
movl -0x34(%rbp), %eax
addl $0x1, %eax
movq -0x28(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jb 0x8f4d63
jmp 0x8f4db8
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x40(%rcx), %rcx
movl -0x34(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %edx
addl $0x1, %edx
movl %edx, -0x34(%rbp)
movl %edx, %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
jmp 0x8f4cb4
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x8f4dfb
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x40(%rcx), %rcx
movl -0x34(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jle 0x8f4e08
movq $-0x1e, -0x8(%rbp)
jmp 0x8f510b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x8f5120
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jge 0x8f4e2e
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f510b
jmp 0x8f509e
movl $0x0, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jl 0x8f4e7a
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
jl 0x8f4e7a
movl -0x34(%rbp), %eax
addl $0x1, %eax
movq -0x28(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jb 0x8f4e7c
jmp 0x8f4ed1
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x40(%rcx), %rcx
movl -0x34(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %edx
addl $0x1, %edx
movl %edx, -0x34(%rbp)
movl %edx, %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
jmp 0x8f4e3a
jmp 0x8f4ed3
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x8f35f0
cltq
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x8f4ef9
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f510b
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x8f5120
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jge 0x8f4f22
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f510b
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x40(%rcx), %rcx
movl -0x34(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movq -0x28(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jb 0x8f4f7c
jmp 0x8f4fa2
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %edx
addl $0x1, %edx
movl %edx, -0x34(%rbp)
movl %edx, %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
jmp 0x8f4ed3
jmp 0x8f4fa4
movq -0x30(%rbp), %rax
addq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x40(%rcx), %rcx
movl -0x34(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jl 0x8f4fc5
jmp 0x8f5028
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x8f4feb
jmp 0x8f5028
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x40(%rcx), %rcx
movl -0x34(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x30(%rbp)
jmp 0x8f4fa4
movq -0x30(%rbp), %rax
addq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x40(%rcx), %rcx
movl -0x34(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
subq (%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x8f35f0
cltq
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x8f506e
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f510b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x8f5120
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0x8f5092
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f510b
jmp 0x8f509e
movq $-0x1e, -0x8(%rbp)
jmp 0x8f510b
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x34(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jl 0x8f5103
movq -0x10(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x88(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
archive_read_close
|
static int
_archive_read_close(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
int r = ARCHIVE_OK, r1 = ARCHIVE_OK;
archive_check_magic(&a->archive, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_read_close");
if (a->archive.state == ARCHIVE_STATE_CLOSED)
return (ARCHIVE_OK);
archive_clear_error(&a->archive);
a->archive.state = ARCHIVE_STATE_CLOSED;
/* TODO: Clean up the formatters. */
/* Release the filter objects. */
r1 = close_filters(a);
if (r1 < r)
r = r1;
return (r);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0xffff, %edx # imm = 0xFFFF
leaq 0x2c455f(%rip), %rcx # 0xbb9736
callq 0x9770c0
movl %eax, -0x24(%rbp)
cmpl $-0x1e, -0x24(%rbp)
jne 0x8f51ee
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f5237
jmp 0x8f51f0
movq -0x18(%rbp), %rax
cmpl $0x20, 0x4(%rax)
jne 0x8f5203
movl $0x0, -0x4(%rbp)
jmp 0x8f5237
movq -0x18(%rbp), %rdi
callq 0x9401c0
movq -0x18(%rbp), %rax
movl $0x20, 0x4(%rax)
movq -0x18(%rbp), %rdi
callq 0x8f3540
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x8f5231
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
archive_read_free
|
static int
_archive_read_free(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
struct archive_read_passphrase *p;
int i, n;
int slots;
int r = ARCHIVE_OK;
if (_a == NULL)
return (ARCHIVE_OK);
archive_check_magic(_a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_read_free");
if (a->archive.state != ARCHIVE_STATE_CLOSED
&& a->archive.state != ARCHIVE_STATE_FATAL)
r = archive_read_close(&a->archive);
/* Call cleanup functions registered by optional components. */
if (a->cleanup_archive_extract != NULL)
r = (a->cleanup_archive_extract)(a);
/* Cleanup format-specific data. */
slots = sizeof(a->formats) / sizeof(a->formats[0]);
for (i = 0; i < slots; i++) {
a->format = &(a->formats[i]);
if (a->formats[i].cleanup)
(a->formats[i].cleanup)(a);
}
/* Free the filters */
__archive_read_free_filters(a);
/* Release the bidder objects. */
n = sizeof(a->bidders)/sizeof(a->bidders[0]);
for (i = 0; i < n; i++) {
if (a->bidders[i].vtable == NULL ||
a->bidders[i].vtable->free == NULL)
continue;
(a->bidders[i].vtable->free)(&a->bidders[i]);
}
/* Release passphrase list. */
p = a->passphrases.first;
while (p != NULL) {
struct archive_read_passphrase *np = p->next;
/* A passphrase should be cleaned. */
memset(p->passphrase, 0, strlen(p->passphrase));
free(p->passphrase);
free(p);
p = np;
}
archive_string_free(&a->archive.error_string);
archive_entry_free(a->entry);
a->archive.magic = 0;
__archive_clean(&a->archive);
free(a->client.dataset);
free(a);
return (r);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8f526e
movl $0x0, -0x4(%rbp)
jmp 0x8f54be
jmp 0x8f5270
movq -0x10(%rbp), %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0xffff, %edx # imm = 0xFFFF
leaq 0x2c44c4(%rip), %rcx # 0xbb9749
callq 0x9770c0
movl %eax, -0x34(%rbp)
cmpl $-0x1e, -0x34(%rbp)
jne 0x8f529f
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f54be
jmp 0x8f52a1
movq -0x18(%rbp), %rax
cmpl $0x20, 0x4(%rax)
je 0x8f52c4
movq -0x18(%rbp), %rax
cmpl $0x8000, 0x4(%rax) # imm = 0x8000
je 0x8f52c4
movq -0x18(%rbp), %rdi
callq 0x9409b0
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x828(%rax)
je 0x8f52e6
movq -0x18(%rbp), %rax
movq 0x828(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movl %eax, -0x30(%rbp)
movl $0x10, -0x2c(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x8f5365
movq -0x18(%rbp), %rcx
addq $0x298, %rcx # imm = 0x298
movslq -0x24(%rbp), %rax
imulq $0x58, %rax, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x818(%rax)
movq -0x18(%rbp), %rax
addq $0x298, %rax # imm = 0x298
movslq -0x24(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x40(%rax)
je 0x8f5358
movq -0x18(%rbp), %rax
addq $0x298, %rax # imm = 0x298
movslq -0x24(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
jmp 0x8f535a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8f52f4
movq -0x18(%rbp), %rdi
callq 0x8f3d50
movl $0x10, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x8f5409
movq -0x18(%rbp), %rax
addq $0xf8, %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x8f53c4
movq -0x18(%rbp), %rax
addq $0xf8, %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0x8f53c6
jmp 0x8f53fb
movq -0x18(%rbp), %rax
addq $0xf8, %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rdi
addq $0xf8, %rdi
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rdi
callq *%rax
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8f537c
movq -0x18(%rbp), %rax
movq 0x830(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8f546f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x3b8f0
movq -0x48(%rbp), %rdi
movq %rax, %rdx
xorl %esi, %esi
callq 0x3b780
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x3e548
movq -0x20(%rbp), %rdi
callq 0x3e548
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x8f5418
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x938460
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x8e9990
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rdi
callq 0x940040
movq -0x18(%rbp), %rax
movq 0xf0(%rax), %rdi
callq 0x3e548
movq -0x18(%rbp), %rdi
callq 0x3e548
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
archive_read_next_header
|
static int
_archive_read_next_header(struct archive *_a, struct archive_entry **entryp)
{
int ret;
struct archive_read *a = (struct archive_read *)_a;
*entryp = NULL;
ret = _archive_read_next_header2(_a, a->entry);
*entryp = a->entry;
return ret;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rsi
callq 0x8f5530
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
archive_read_next_header2
|
static int
_archive_read_next_header2(struct archive *_a, struct archive_entry *entry)
{
struct archive_read *a = (struct archive_read *)_a;
int r1 = ARCHIVE_OK, r2;
archive_check_magic(_a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
"archive_read_next_header");
archive_entry_clear(entry);
archive_clear_error(&a->archive);
/*
* If client didn't consume entire data, skip any remainder
* (This is especially important for GNU incremental directories.)
*/
if (a->archive.state == ARCHIVE_STATE_DATA) {
r1 = archive_read_data_skip(&a->archive);
if (r1 == ARCHIVE_EOF)
archive_set_error(&a->archive, EIO,
"Premature end-of-file.");
if (r1 == ARCHIVE_EOF || r1 == ARCHIVE_FATAL) {
a->archive.state = ARCHIVE_STATE_FATAL;
return (ARCHIVE_FATAL);
}
}
/* Record start-of-header offset in uncompressed stream. */
a->header_position = a->filter->position;
++_a->file_count;
r2 = (a->format->read_header)(a, entry);
/*
* EOF and FATAL are persistent at this layer. By
* modifying the state, we guarantee that future calls to
* read a header or read data will fail.
*/
switch (r2) {
case ARCHIVE_EOF:
a->archive.state = ARCHIVE_STATE_EOF;
--_a->file_count;/* Revert a file counter. */
break;
case ARCHIVE_OK:
a->archive.state = ARCHIVE_STATE_DATA;
break;
case ARCHIVE_WARN:
a->archive.state = ARCHIVE_STATE_DATA;
break;
case ARCHIVE_RETRY:
break;
case ARCHIVE_FATAL:
a->archive.state = ARCHIVE_STATE_FATAL;
break;
}
__archive_reset_read_data(&a->archive);
a->data_start_node = a->client.cursor;
/* EOF always wins; otherwise return the worst error. */
return (r2 < r1 || r2 == ARCHIVE_EOF) ? r2 : r1;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x6, %edx
leaq 0x2c41f7(%rip), %rcx # 0xbb975b
callq 0x9770c0
movl %eax, -0x2c(%rbp)
cmpl $-0x1e, -0x2c(%rbp)
jne 0x8f557e
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f56c8
jmp 0x8f5580
movq -0x18(%rbp), %rdi
callq 0x8e93f0
movq -0x20(%rbp), %rdi
callq 0x9401c0
movq -0x20(%rbp), %rax
cmpl $0x4, 0x4(%rax)
jne 0x8f55ea
movq -0x20(%rbp), %rdi
callq 0x8f3be0
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jne 0x8f55c5
movq -0x20(%rbp), %rdi
movl $0x5, %esi
leaq 0x2c41b6(%rip), %rdx # 0xbb9774
movb $0x0, %al
callq 0x9401f0
cmpl $0x1, -0x24(%rbp)
je 0x8f55d1
cmpl $-0x1e, -0x24(%rbp)
jne 0x8f55e8
movq -0x20(%rbp), %rax
movl $0x8000, 0x4(%rax) # imm = 0x8000
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f56c8
jmp 0x8f55ea
movq -0x20(%rbp), %rax
movq 0x278(%rax), %rcx
movq (%rcx), %rcx
movq %rcx, 0x288(%rax)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
incl %ecx
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rdi
movq 0x818(%rdi), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
addl $0x1e, %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x1f, %eax
ja 0x8f5689
movq -0x38(%rbp), %rax
leaq 0x2c3d39(%rip), %rcx # 0xbb9378
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movl $0x10, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
jmp 0x8f5689
movq -0x20(%rbp), %rax
movl $0x4, 0x4(%rax)
jmp 0x8f5689
movq -0x20(%rbp), %rax
movl $0x4, 0x4(%rax)
jmp 0x8f5689
jmp 0x8f5689
movq -0x20(%rbp), %rax
movl $0x8000, 0x4(%rax) # imm = 0x8000
movq -0x20(%rbp), %rdi
callq 0x8f3b80
movq -0x20(%rbp), %rax
movl 0xe4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x290(%rax)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jl 0x8f56b4
cmpl $0x1, -0x28(%rbp)
jne 0x8f56bc
movl -0x28(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x8f56c2
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
archive_read_data_block
|
static int
_archive_read_data_block(struct archive *_a,
const void **buff, size_t *size, int64_t *offset)
{
struct archive_read *a = (struct archive_read *)_a;
archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_DATA,
"archive_read_data_block");
if (a->format->read_data == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
"Internal error: "
"No format->read_data function registered");
return (ARCHIVE_FATAL);
}
return (a->format->read_data)(a, buff, size, offset);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x4, %edx
leaq 0x2c4076(%rip), %rcx # 0xbb978b
callq 0x9770c0
movl %eax, -0x34(%rbp)
cmpl $-0x1e, -0x34(%rbp)
jne 0x8f572c
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f5784
jmp 0x8f572e
movq -0x30(%rbp), %rax
movq 0x818(%rax), %rax
cmpq $0x0, 0x28(%rax)
jne 0x8f5760
movq -0x30(%rbp), %rdi
movl $0x16, %esi
leaq 0x2c4053(%rip), %rdx # 0xbb97a3
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f5784
movq -0x30(%rbp), %rax
movq 0x818(%rax), %rax
movq 0x28(%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
get_filter
|
static struct archive_read_filter *
get_filter(struct archive *_a, int n)
{
struct archive_read *a = (struct archive_read *)_a;
struct archive_read_filter *f = a->filter;
/* We use n == -1 for 'the last filter', which is always the
* client proxy. */
if (n == -1 && f != NULL) {
struct archive_read_filter *last = f;
f = f->upstream;
while (f != NULL) {
last = f;
f = f->upstream;
}
return (last);
}
if (n < 0)
return NULL;
while (n > 0 && f != NULL) {
f = f->upstream;
--n;
}
return (f);
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x278(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x8f593a
cmpq $0x0, -0x28(%rbp)
je 0x8f593a
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8f5930
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x8f5913
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f598a
cmpl $0x0, -0x14(%rbp)
jge 0x8f594a
movq $0x0, -0x8(%rbp)
jmp 0x8f598a
jmp 0x8f594c
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x31(%rbp)
jle 0x8f5962
cmpq $0x0, -0x28(%rbp)
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x8f596b
jmp 0x8f5982
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8f594c
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
client_open_proxy
|
static int
client_open_proxy(struct archive_read_filter *self)
{
int r = ARCHIVE_OK;
if (self->archive->client.opener != NULL)
r = (self->archive->client.opener)(
(struct archive *)self->archive, self->data);
return (r);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0xb0(%rax)
je 0x8f5a49
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0xb0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rsi
callq *%rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
client_skip_proxy
|
static int64_t
client_skip_proxy(struct archive_read_filter *self, int64_t request)
{
if (request < 0)
__archive_errx(1, "Negative skip requested.");
if (request == 0)
return 0;
if (self->archive->client.skipper != NULL) {
/* Seek requests over 1GiB are broken down into
* multiple seeks. This avoids overflows when the
* requests get passed through 32-bit arguments. */
int64_t skip_limit = (int64_t)1 << 30;
int64_t total = 0;
for (;;) {
int64_t get, ask = request;
if (ask > skip_limit)
ask = skip_limit;
get = (self->archive->client.skipper)
(&self->archive->archive, self->data, ask);
total += get;
if (get == 0 || get == request)
return (total);
if (get > request)
return ARCHIVE_FATAL;
request -= get;
}
} else if (self->archive->client.seeker != NULL
&& request > 64 * 1024) {
/* If the client provided a seeker but not a skipper,
* we can use the seeker to skip forward.
*
* Note: This isn't always a good idea. The client
* skipper is allowed to skip by less than requested
* if it needs to maintain block alignment. The
* seeker is not allowed to play such games, so using
* the seeker here may be a performance loss compared
* to just reading and discarding. That's why we
* only do this for skips of over 64k.
*/
int64_t before = self->position;
int64_t after = (self->archive->client.seeker)
(&self->archive->archive, self->data, request, SEEK_CUR);
if (after != before + request)
return ARCHIVE_FATAL;
return after - before;
}
return 0;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x8f5a88
movl $0x1, %edi
leaq 0x2c3db8(%rip), %rsi # 0xbb983b
callq 0x940330
cmpq $0x0, -0x18(%rbp)
jne 0x8f5a9c
movq $0x0, -0x8(%rbp)
jmp 0x8f5be2
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0xc0(%rax)
je 0x8f5b5a
movq $0x40000000, -0x20(%rbp) # imm = 0x40000000
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jle 0x8f5adc
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0xc0(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rsi
movq -0x38(%rbp), %rdx
callq *%rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x8f5b22
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x8f5b2f
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f5be2
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jle 0x8f5b46
movq $-0x1e, -0x8(%rbp)
jmp 0x8f5be2
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x8f5ac2
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0xc8(%rax)
je 0x8f5bd8
cmpq $0x10000, -0x18(%rbp) # imm = 0x10000
jle 0x8f5bd8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0xc8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rsi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq *%rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
addq -0x18(%rbp), %rcx
cmpq %rcx, %rax
je 0x8f5bca
movq $-0x1e, -0x8(%rbp)
jmp 0x8f5be2
movq -0x48(%rbp), %rax
subq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f5be2
jmp 0x8f5bda
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c
|
archive_read_disk_entry_setup_path
|
const char *
archive_read_disk_entry_setup_path(struct archive_read_disk *a,
struct archive_entry *entry, int *fd)
{
const char *path;
path = archive_entry_sourcepath(entry);
if (path == NULL || (a->tree != NULL &&
a->tree_enter_working_dir(a->tree) != 0))
path = archive_entry_pathname(entry);
if (path == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Couldn't determine path");
} else if (fd != NULL && *fd < 0 && a->tree != NULL &&
(a->follow_symlinks || archive_entry_filetype(entry) != AE_IFLNK)) {
*fd = a->open_on_current_dir(a->tree, path,
O_RDONLY | O_NONBLOCK);
}
return (path);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8ea780
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8f5c63
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x8f5c70
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xa0(%rcx), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x8f5c70
movq -0x10(%rbp), %rdi
callq 0x8ea480
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8f5c90
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x2c3c05(%rip), %rdx # 0xbb988c
movb $0x0, %al
callq 0x9401f0
jmp 0x8f5cf9
cmpq $0x0, -0x18(%rbp)
je 0x8f5cf7
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x8f5cf7
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x8f5cf7
movq -0x8(%rbp), %rax
movsbl 0x99(%rax), %eax
cmpl $0x0, %eax
jne 0x8f5cce
movq -0x10(%rbp), %rdi
callq 0x8e9c10
cmpl $0xa000, %eax # imm = 0xA000
je 0x8f5cf7
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xa0(%rcx), %rdi
movq -0x20(%rbp), %rsi
movl $0x800, %edx # imm = 0x800
callq *%rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x8f5cf9
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_entry_from_file.c
|
archive_read_disk_entry_from_file
|
int
archive_read_disk_entry_from_file(struct archive *_a,
struct archive_entry *entry,
int fd,
const struct stat *st)
{
struct archive_read_disk *a = (struct archive_read_disk *)_a;
const char *path, *name;
struct stat s;
int initial_fd = fd;
int r, r1;
archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC, ARCHIVE_STATE_ANY,
"archive_read_disk_entry_from_file");
archive_clear_error(_a);
path = archive_entry_sourcepath(entry);
if (path == NULL)
path = archive_entry_pathname(entry);
if (a->tree == NULL) {
if (st == NULL) {
#if HAVE_FSTAT
if (fd >= 0) {
if (fstat(fd, &s) != 0) {
archive_set_error(&a->archive, errno,
"Can't fstat");
return (ARCHIVE_FAILED);
}
} else
#endif
#if HAVE_LSTAT
if (!a->follow_symlinks) {
if (lstat(path, &s) != 0) {
archive_set_error(&a->archive, errno,
"Can't lstat %s", path);
return (ARCHIVE_FAILED);
}
} else
#endif
if (la_stat(path, &s) != 0) {
archive_set_error(&a->archive, errno,
"Can't stat %s", path);
return (ARCHIVE_FAILED);
}
st = &s;
}
archive_entry_copy_stat(entry, st);
}
/* Lookup uname/gname */
name = archive_read_disk_uname(_a, archive_entry_uid(entry));
if (name != NULL)
archive_entry_copy_uname(entry, name);
name = archive_read_disk_gname(_a, archive_entry_gid(entry));
if (name != NULL)
archive_entry_copy_gname(entry, name);
#ifdef HAVE_STRUCT_STAT_ST_FLAGS
/* On FreeBSD, we get flags for free with the stat. */
/* TODO: Does this belong in copy_stat()? */
if ((a->flags & ARCHIVE_READDISK_NO_FFLAGS) == 0 && st->st_flags != 0)
archive_entry_set_fflags(entry, st->st_flags, 0);
#endif
#if (defined(FS_IOC_GETFLAGS) && defined(HAVE_WORKING_FS_IOC_GETFLAGS)) || \
(defined(EXT2_IOC_GETFLAGS) && defined(HAVE_WORKING_EXT2_IOC_GETFLAGS))
/* Linux requires an extra ioctl to pull the flags. Although
* this is an extra step, it has a nice side-effect: We get an
* open file descriptor which we can use in the subsequent lookups. */
if ((a->flags & ARCHIVE_READDISK_NO_FFLAGS) == 0 &&
(S_ISREG(st->st_mode) || S_ISDIR(st->st_mode))) {
if (fd < 0) {
if (a->tree != NULL)
fd = a->open_on_current_dir(a->tree, path,
O_RDONLY | O_NONBLOCK | O_CLOEXEC);
else
fd = open(path, O_RDONLY | O_NONBLOCK |
O_CLOEXEC);
__archive_ensure_cloexec_flag(fd);
}
if (fd >= 0) {
int stflags;
r = ioctl(fd,
#if defined(FS_IOC_GETFLAGS)
FS_IOC_GETFLAGS,
#else
EXT2_IOC_GETFLAGS,
#endif
&stflags);
if (r == 0 && stflags != 0)
archive_entry_set_fflags(entry, stflags, 0);
}
}
#endif
#if defined(HAVE_READLINK) || defined(HAVE_READLINKAT)
if (S_ISLNK(st->st_mode)) {
size_t linkbuffer_len = st->st_size;
char *linkbuffer;
int lnklen;
linkbuffer = malloc(linkbuffer_len + 1);
if (linkbuffer == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Couldn't read link data");
return (ARCHIVE_FAILED);
}
if (a->tree != NULL) {
#ifdef HAVE_READLINKAT
lnklen = readlinkat(a->tree_current_dir_fd(a->tree),
path, linkbuffer, linkbuffer_len);
#else
if (a->tree_enter_working_dir(a->tree) != 0) {
archive_set_error(&a->archive, errno,
"Couldn't read link data");
free(linkbuffer);
return (ARCHIVE_FAILED);
}
lnklen = readlink(path, linkbuffer, linkbuffer_len);
#endif /* HAVE_READLINKAT */
} else
lnklen = readlink(path, linkbuffer, linkbuffer_len);
if (lnklen < 0) {
archive_set_error(&a->archive, errno,
"Couldn't read link data");
free(linkbuffer);
return (ARCHIVE_FAILED);
}
linkbuffer[lnklen] = '\0';
archive_entry_set_symlink(entry, linkbuffer);
free(linkbuffer);
}
#endif /* HAVE_READLINK || HAVE_READLINKAT */
r = 0;
if ((a->flags & ARCHIVE_READDISK_NO_ACL) == 0)
r = archive_read_disk_entry_setup_acls(a, entry, &fd);
if ((a->flags & ARCHIVE_READDISK_NO_XATTR) == 0) {
r1 = setup_xattrs(a, entry, &fd);
if (r1 < r)
r = r1;
}
if (a->flags & ARCHIVE_READDISK_MAC_COPYFILE) {
r1 = setup_mac_metadata(a, entry, &fd);
if (r1 < r)
r = r1;
}
if ((a->flags & ARCHIVE_READDISK_NO_SPARSE) == 0) {
r1 = setup_sparse(a, entry, &fd);
if (r1 < r)
r = r1;
}
/* If we opened the file earlier in this function, close it. */
if (initial_fd != fd)
close(fd);
return (r);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xd4(%rbp)
movq -0x10(%rbp), %rdi
movl $0xbadb0c5, %esi # imm = 0xBADB0C5
movl $0x7fff, %edx # imm = 0x7FFF
leaq 0x2c3b54(%rip), %rcx # 0xbb98a4
callq 0x9770c0
movl %eax, -0xe0(%rbp)
cmpl $-0x1e, -0xe0(%rbp)
jne 0x8f5d70
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f6289
jmp 0x8f5d72
movq -0x10(%rbp), %rdi
callq 0x9401c0
movq -0x18(%rbp), %rdi
callq 0x8ea780
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x8f5d9c
movq -0x18(%rbp), %rdi
callq 0x8ea480
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
jne 0x8f5ece
cmpq $0x0, -0x28(%rbp)
jne 0x8f5ec1
cmpl $0x0, -0x1c(%rbp)
jl 0x8f5e0b
movl -0x1c(%rbp), %edi
leaq -0xd0(%rbp), %rsi
callq 0x3c240
cmpl $0x0, %eax
je 0x8f5e06
movq -0x30(%rbp), %rax
movq %rax, -0x108(%rbp)
callq 0x3e130
movq -0x108(%rbp), %rdi
movl (%rax), %esi
leaq 0x2c3ad3(%rip), %rdx # 0xbb98c6
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe7, -0x4(%rbp) # imm = 0xFFFFFFE7
jmp 0x8f6289
jmp 0x8f5eb6
movq -0x30(%rbp), %rax
cmpb $0x0, 0x99(%rax)
jne 0x8f5e66
movq -0x38(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x3b610
cmpl $0x0, %eax
je 0x8f5e64
movq -0x30(%rbp), %rax
movq %rax, -0x110(%rbp)
callq 0x3e130
movq -0x110(%rbp), %rdi
movl (%rax), %esi
movq -0x38(%rbp), %rcx
leaq 0x2c3a81(%rip), %rdx # 0xbb98d2
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe7, -0x4(%rbp) # imm = 0xFFFFFFE7
jmp 0x8f6289
jmp 0x8f5eb4
movq -0x38(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x3b240
cmpl $0x0, %eax
je 0x8f5eb2
movq -0x30(%rbp), %rax
movq %rax, -0x118(%rbp)
callq 0x3e130
movq -0x118(%rbp), %rdi
movl (%rax), %esi
movq -0x38(%rbp), %rcx
leaq 0x2c3a42(%rip), %rdx # 0xbb98e1
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe7, -0x4(%rbp) # imm = 0xFFFFFFE7
jmp 0x8f6289
jmp 0x8f5eb4
jmp 0x8f5eb6
leaq -0xd0(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x978330
movq -0x10(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8eaa60
movq -0x120(%rbp), %rdi
movq %rax, %rsi
callq 0x8f6a80
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x8f5f09
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x8ec590
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8e9fc0
movq -0x128(%rbp), %rdi
movq %rax, %rsi
callq 0x8f69f0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x8f5f44
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x8eb340
movq -0x30(%rbp), %rax
movl 0xc0(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x8f6025
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
andl $0xf000, %eax # imm = 0xF000
cmpl $0x8000, %eax # imm = 0x8000
je 0x8f5f84
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
andl $0xf000, %eax # imm = 0xF000
cmpl $0x4000, %eax # imm = 0x4000
jne 0x8f6025
cmpl $0x0, -0x1c(%rbp)
jge 0x8f5fd9
movq -0x30(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x8f5fbe
movq -0x30(%rbp), %rax
movq 0xa8(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0xa0(%rcx), %rdi
movq -0x38(%rbp), %rsi
movl $0x80800, %edx # imm = 0x80800
callq *%rax
movl %eax, -0x1c(%rbp)
jmp 0x8f5fd1
movq -0x38(%rbp), %rdi
movl $0x80800, %esi # imm = 0x80800
movb $0x0, %al
callq 0x3d280
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x940570
cmpl $0x0, -0x1c(%rbp)
jl 0x8f6023
movl -0x1c(%rbp), %edi
movl $0x80086601, %esi # imm = 0x80086601
leaq -0xe4(%rbp), %rdx
movb $0x0, %al
callq 0x3b2f0
movl %eax, -0xd8(%rbp)
cmpl $0x0, -0xd8(%rbp)
jne 0x8f6021
cmpl $0x0, -0xe4(%rbp)
je 0x8f6021
movq -0x18(%rbp), %rdi
movslq -0xe4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8eacf0
jmp 0x8f6023
jmp 0x8f6025
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
andl $0xf000, %eax # imm = 0xF000
cmpl $0xa000, %eax # imm = 0xA000
jne 0x8f6169
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0xf0(%rbp)
movq -0xf0(%rbp), %rdi
addq $0x1, %rdi
callq 0x3e578
movq %rax, -0xf8(%rbp)
cmpq $0x0, -0xf8(%rbp)
jne 0x8f608f
movq -0x30(%rbp), %rdi
movl $0xc, %esi
leaq 0x2c3873(%rip), %rdx # 0xbb98ef
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe7, -0x4(%rbp) # imm = 0xFFFFFFE7
jmp 0x8f6289
movq -0x30(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x8f60d6
movq -0x30(%rbp), %rax
movq 0xb0(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0xa0(%rcx), %rdi
callq *%rax
movl %eax, %edi
movq -0x38(%rbp), %rsi
movq -0xf8(%rbp), %rdx
movq -0xf0(%rbp), %rcx
callq 0x3d920
movl %eax, -0xfc(%rbp)
jmp 0x8f60f3
movq -0x38(%rbp), %rdi
movq -0xf8(%rbp), %rsi
movq -0xf0(%rbp), %rdx
callq 0x3b730
movl %eax, -0xfc(%rbp)
cmpl $0x0, -0xfc(%rbp)
jge 0x8f613b
movq -0x30(%rbp), %rax
movq %rax, -0x130(%rbp)
callq 0x3e130
movq -0x130(%rbp), %rdi
movl (%rax), %esi
leaq 0x2c37d3(%rip), %rdx # 0xbb98ef
movb $0x0, %al
callq 0x9401f0
movq -0xf8(%rbp), %rdi
callq 0x3e548
movl $0xffffffe7, -0x4(%rbp) # imm = 0xFFFFFFE7
jmp 0x8f6289
movq -0xf8(%rbp), %rax
movslq -0xfc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rdi
movq -0xf8(%rbp), %rsi
callq 0x8ec240
movq -0xf8(%rbp), %rdi
callq 0x3e548
movl $0x0, -0xd8(%rbp)
movq -0x30(%rbp), %rax
movl 0xc0(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
jne 0x8f619c
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x8f5bf0
movl %eax, -0xd8(%rbp)
movq -0x30(%rbp), %rax
movl 0xc0(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x8f61e1
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x8f62a0
movl %eax, -0xdc(%rbp)
movl -0xdc(%rbp), %eax
cmpl -0xd8(%rbp), %eax
jge 0x8f61df
movl -0xdc(%rbp), %eax
movl %eax, -0xd8(%rbp)
jmp 0x8f61e1
movq -0x30(%rbp), %rax
movl 0xc0(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x8f6226
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x8f62c0
movl %eax, -0xdc(%rbp)
movl -0xdc(%rbp), %eax
cmpl -0xd8(%rbp), %eax
jge 0x8f6224
movl -0xdc(%rbp), %eax
movl %eax, -0xd8(%rbp)
jmp 0x8f6226
movq -0x30(%rbp), %rax
movl 0xc0(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x8f626d
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x8f62e0
movl %eax, -0xdc(%rbp)
movl -0xdc(%rbp), %eax
cmpl -0xd8(%rbp), %eax
jge 0x8f626b
movl -0xdc(%rbp), %eax
movl %eax, -0xd8(%rbp)
jmp 0x8f626d
movl -0xd4(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x8f6280
movl -0x1c(%rbp), %edi
callq 0x3ce50
movl -0xd8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_entry_from_file.c
|
setup_xattrs
|
static int
setup_xattrs(struct archive_read_disk *a,
struct archive_entry *entry, int *fd)
{
char *list, *p;
const char *path;
ssize_t list_size;
path = NULL;
if (*fd < 0) {
path = archive_read_disk_entry_setup_path(a, entry, fd);
if (path == NULL)
return (ARCHIVE_WARN);
}
if (*fd >= 0) {
#if ARCHIVE_XATTR_LINUX
list_size = flistxattr(*fd, NULL, 0);
#elif ARCHIVE_XATTR_DARWIN
list_size = flistxattr(*fd, NULL, 0, 0);
#elif ARCHIVE_XATTR_AIX
list_size = flistea(*fd, NULL, 0);
#endif
} else if (!a->follow_symlinks) {
#if ARCHIVE_XATTR_LINUX
list_size = llistxattr(path, NULL, 0);
#elif ARCHIVE_XATTR_DARWIN
list_size = listxattr(path, NULL, 0, XATTR_NOFOLLOW);
#elif ARCHIVE_XATTR_AIX
list_size = llistea(path, NULL, 0);
#endif
} else {
#if ARCHIVE_XATTR_LINUX
list_size = listxattr(path, NULL, 0);
#elif ARCHIVE_XATTR_DARWIN
list_size = listxattr(path, NULL, 0, 0);
#elif ARCHIVE_XATTR_AIX
list_size = listea(path, NULL, 0);
#endif
}
if (list_size == -1) {
if (errno == ENOTSUP || errno == ENOSYS)
return (ARCHIVE_OK);
archive_set_error(&a->archive, errno,
"Couldn't list extended attributes");
return (ARCHIVE_WARN);
}
if (list_size == 0)
return (ARCHIVE_OK);
if ((list = malloc(list_size)) == NULL) {
archive_set_error(&a->archive, errno, "Out of memory");
return (ARCHIVE_FATAL);
}
if (*fd >= 0) {
#if ARCHIVE_XATTR_LINUX
list_size = flistxattr(*fd, list, list_size);
#elif ARCHIVE_XATTR_DARWIN
list_size = flistxattr(*fd, list, list_size, 0);
#elif ARCHIVE_XATTR_AIX
list_size = flistea(*fd, list, list_size);
#endif
} else if (!a->follow_symlinks) {
#if ARCHIVE_XATTR_LINUX
list_size = llistxattr(path, list, list_size);
#elif ARCHIVE_XATTR_DARWIN
list_size = listxattr(path, list, list_size, XATTR_NOFOLLOW);
#elif ARCHIVE_XATTR_AIX
list_size = llistea(path, list, list_size);
#endif
} else {
#if ARCHIVE_XATTR_LINUX
list_size = listxattr(path, list, list_size);
#elif ARCHIVE_XATTR_DARWIN
list_size = listxattr(path, list, list_size, 0);
#elif ARCHIVE_XATTR_AIX
list_size = listea(path, list, list_size);
#endif
}
if (list_size == -1) {
archive_set_error(&a->archive, errno,
"Couldn't retrieve extended attributes");
free(list);
return (ARCHIVE_WARN);
}
for (p = list; (p - list) < list_size; p += strlen(p) + 1) {
#if ARCHIVE_XATTR_LINUX
/* Linux: skip POSIX.1e ACL extended attributes */
if (strncmp(p, "system.", 7) == 0 &&
(strcmp(p + 7, "posix_acl_access") == 0 ||
strcmp(p + 7, "posix_acl_default") == 0))
continue;
if (strncmp(p, "trusted.SGI_", 12) == 0 &&
(strcmp(p + 12, "ACL_DEFAULT") == 0 ||
strcmp(p + 12, "ACL_FILE") == 0))
continue;
/* Linux: xfsroot namespace is obsolete and unsupported */
if (strncmp(p, "xfsroot.", 8) == 0)
continue;
#endif
setup_xattr(a, entry, p, *fd, path);
}
free(list);
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_entry_from_file.c
|
setup_mac_metadata
|
static int
setup_mac_metadata(struct archive_read_disk *a,
struct archive_entry *entry, int *fd)
{
int tempfd = -1;
int copyfile_flags = COPYFILE_NOFOLLOW | COPYFILE_ACL | COPYFILE_XATTR;
struct stat copyfile_stat;
int ret = ARCHIVE_OK;
void *buff = NULL;
int have_attrs;
const char *name, *tempdir;
struct archive_string tempfile;
(void)fd; /* UNUSED */
name = archive_read_disk_entry_setup_path(a, entry, NULL);
if (name == NULL)
return (ARCHIVE_WARN);
/* Short-circuit if there's nothing to do. */
have_attrs = copyfile(name, NULL, 0, copyfile_flags | COPYFILE_CHECK);
if (have_attrs == -1) {
archive_set_error(&a->archive, errno,
"Could not check extended attributes");
return (ARCHIVE_WARN);
}
if (have_attrs == 0)
return (ARCHIVE_OK);
tempdir = NULL;
if (issetugid() == 0)
tempdir = getenv("TMPDIR");
if (tempdir == NULL)
tempdir = _PATH_TMP;
archive_string_init(&tempfile);
archive_strcpy(&tempfile, tempdir);
archive_strcat(&tempfile, "tar.md.XXXXXX");
tempfd = mkstemp(tempfile.s);
if (tempfd < 0) {
archive_set_error(&a->archive, errno,
"Could not open extended attribute file");
ret = ARCHIVE_WARN;
goto cleanup;
}
__archive_ensure_cloexec_flag(tempfd);
/* XXX I wish copyfile() could pack directly to a memory
* buffer; that would avoid the temp file here. For that
* matter, it would be nice if fcopyfile() actually worked,
* that would reduce the many open/close races here. */
if (copyfile(name, tempfile.s, 0, copyfile_flags | COPYFILE_PACK)) {
archive_set_error(&a->archive, errno,
"Could not pack extended attributes");
ret = ARCHIVE_WARN;
goto cleanup;
}
if (fstat(tempfd, ©file_stat)) {
archive_set_error(&a->archive, errno,
"Could not check size of extended attributes");
ret = ARCHIVE_WARN;
goto cleanup;
}
buff = malloc(copyfile_stat.st_size);
if (buff == NULL) {
archive_set_error(&a->archive, errno,
"Could not allocate memory for extended attributes");
ret = ARCHIVE_WARN;
goto cleanup;
}
if (copyfile_stat.st_size != read(tempfd, buff, copyfile_stat.st_size)) {
archive_set_error(&a->archive, errno,
"Could not read extended attributes into memory");
ret = ARCHIVE_WARN;
goto cleanup;
}
archive_entry_copy_mac_metadata(entry, buff, copyfile_stat.st_size);
cleanup:
if (tempfd >= 0) {
close(tempfd);
unlink(tempfile.s);
}
archive_string_free(&tempfile);
free(buff);
return (ret);
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_entry_from_file.c
|
setup_sparse_fiemap
|
static int
setup_sparse_fiemap(struct archive_read_disk *a,
struct archive_entry *entry, int *fd)
{
char buff[4096];
struct fiemap *fm;
struct fiemap_extent *fe;
int64_t size;
int count, do_fiemap, iters;
int exit_sts = ARCHIVE_OK;
const char *path;
if (archive_entry_filetype(entry) != AE_IFREG
|| archive_entry_size(entry) <= 0
|| archive_entry_hardlink(entry) != NULL)
return (ARCHIVE_OK);
if (*fd < 0) {
path = archive_read_disk_entry_setup_path(a, entry, NULL);
if (path == NULL)
return (ARCHIVE_FAILED);
if (a->tree != NULL)
*fd = a->open_on_current_dir(a->tree, path,
O_RDONLY | O_NONBLOCK | O_CLOEXEC);
else
*fd = open(path, O_RDONLY | O_NONBLOCK | O_CLOEXEC);
if (*fd < 0) {
archive_set_error(&a->archive, errno,
"Can't open `%s'", path);
return (ARCHIVE_FAILED);
}
__archive_ensure_cloexec_flag(*fd);
}
/* Initialize buffer to avoid the error valgrind complains about. */
memset(buff, 0, sizeof(buff));
count = (sizeof(buff) - sizeof(*fm))/sizeof(*fe);
fm = (struct fiemap *)buff;
fm->fm_start = 0;
fm->fm_length = ~0ULL;;
fm->fm_flags = FIEMAP_FLAG_SYNC;
fm->fm_extent_count = count;
do_fiemap = 1;
size = archive_entry_size(entry);
for (iters = 0; ; ++iters) {
int i, r;
r = ioctl(*fd, FS_IOC_FIEMAP, fm);
if (r < 0) {
/* When something error happens, it is better we
* should return ARCHIVE_OK because an earlier
* version(<2.6.28) cannot perform FS_IOC_FIEMAP. */
goto exit_setup_sparse_fiemap;
}
if (fm->fm_mapped_extents == 0) {
if (iters == 0) {
/* Fully sparse file; insert a zero-length "data" entry */
archive_entry_sparse_add_entry(entry, 0, 0);
}
break;
}
fe = fm->fm_extents;
for (i = 0; i < (int)fm->fm_mapped_extents; i++, fe++) {
if (!(fe->fe_flags & FIEMAP_EXTENT_UNWRITTEN)) {
/* The fe_length of the last block does not
* adjust itself to its size files. */
int64_t length = fe->fe_length;
if (fe->fe_logical + length > (uint64_t)size)
length -= fe->fe_logical + length - size;
if (fe->fe_logical == 0 && length == size) {
/* This is not sparse. */
do_fiemap = 0;
break;
}
if (length > 0)
archive_entry_sparse_add_entry(entry,
fe->fe_logical, length);
}
if (fe->fe_flags & FIEMAP_EXTENT_LAST)
do_fiemap = 0;
}
if (do_fiemap) {
fe = fm->fm_extents + fm->fm_mapped_extents -1;
fm->fm_start = fe->fe_logical + fe->fe_length;
} else
break;
}
exit_setup_sparse_fiemap:
return (exit_sts);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x1070, %rsp # imm = 0x1070
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x1048(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8e9c10
cmpl $0x8000, %eax # imm = 0x8000
jne 0x8f666f
movq -0x18(%rbp), %rdi
callq 0x8ea740
cmpq $0x0, %rax
jle 0x8f666f
movq -0x18(%rbp), %rdi
callq 0x8ea180
cmpq $0x0, %rax
je 0x8f667b
movl $0x0, -0x4(%rbp)
jmp 0x8f69e3
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x8f675b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8f5c10
movq %rax, -0x1050(%rbp)
cmpq $0x0, -0x1050(%rbp)
jne 0x8f66b6
movl $0xffffffe7, -0x4(%rbp) # imm = 0xFFFFFFE7
jmp 0x8f69e3
movq -0x10(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x8f66f2
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0xa0(%rcx), %rdi
movq -0x1050(%rbp), %rsi
movl $0x80800, %edx # imm = 0x80800
callq *%rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x8f670d
movq -0x1050(%rbp), %rdi
movl $0x80800, %esi # imm = 0x80800
movb $0x0, %al
callq 0x3d280
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x8f6750
movq -0x10(%rbp), %rax
movq %rax, -0x1068(%rbp)
callq 0x3e130
movq -0x1068(%rbp), %rdi
movl (%rax), %esi
movq -0x1050(%rbp), %rcx
leaq 0x2c31ca(%rip), %rdx # 0xbb9907
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe7, -0x4(%rbp) # imm = 0xFFFFFFE7
jmp 0x8f69e3
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x940570
leaq -0x1020(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx # imm = 0x1000
callq 0x3b780
movl $0x48, -0x103c(%rbp)
leaq -0x1020(%rbp), %rax
movq %rax, -0x1028(%rbp)
movq -0x1028(%rbp), %rax
movq $0x0, (%rax)
movq -0x1028(%rbp), %rax
movq $-0x1, 0x8(%rax)
movq -0x1028(%rbp), %rax
movl $0x1, 0x10(%rax)
movl -0x103c(%rbp), %ecx
movq -0x1028(%rbp), %rax
movl %ecx, 0x18(%rax)
movl $0x1, -0x1040(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8ea740
movq %rax, -0x1038(%rbp)
movl $0x0, -0x1044(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
movq -0x1028(%rbp), %rdx
movl $0xc020660b, %esi # imm = 0xC020660B
movb $0x0, %al
callq 0x3b2f0
movl %eax, -0x1058(%rbp)
cmpl $0x0, -0x1058(%rbp)
jge 0x8f6812
jmp 0x8f69da
movq -0x1028(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x8f683d
cmpl $0x0, -0x1044(%rbp)
jne 0x8f6838
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x8ecf40
jmp 0x8f69d8
movq -0x1028(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x1030(%rbp)
movl $0x0, -0x1054(%rbp)
movl -0x1054(%rbp), %eax
movq -0x1028(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x8f696f
movq -0x1030(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x800, %eax # imm = 0x800
cmpl $0x0, %eax
jne 0x8f692b
movq -0x1030(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x1060(%rbp)
movq -0x1030(%rbp), %rax
movq (%rax), %rax
addq -0x1060(%rbp), %rax
cmpq -0x1038(%rbp), %rax
jbe 0x8f68dc
movq -0x1030(%rbp), %rax
movq (%rax), %rcx
addq -0x1060(%rbp), %rcx
subq -0x1038(%rbp), %rcx
movq -0x1060(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x1060(%rbp)
movq -0x1030(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x8f6905
movq -0x1060(%rbp), %rax
cmpq -0x1038(%rbp), %rax
jne 0x8f6905
movl $0x0, -0x1040(%rbp)
jmp 0x8f696f
cmpq $0x0, -0x1060(%rbp)
jle 0x8f6929
movq -0x18(%rbp), %rdi
movq -0x1030(%rbp), %rax
movq (%rax), %rsi
movq -0x1060(%rbp), %rdx
callq 0x8ecf40
jmp 0x8f692b
movq -0x1030(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x8f6947
movl $0x0, -0x1040(%rbp)
jmp 0x8f6949
movl -0x1054(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1054(%rbp)
movq -0x1030(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x1030(%rbp)
jmp 0x8f6859
cmpl $0x0, -0x1040(%rbp)
je 0x8f69c0
movq -0x1028(%rbp), %rax
addq $0x20, %rax
movq -0x1028(%rbp), %rcx
movl 0x14(%rcx), %ecx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
addq $-0x38, %rax
movq %rax, -0x1030(%rbp)
movq -0x1030(%rbp), %rax
movq (%rax), %rcx
movq -0x1030(%rbp), %rax
addq 0x10(%rax), %rcx
movq -0x1028(%rbp), %rax
movq %rcx, (%rax)
jmp 0x8f69c2
jmp 0x8f69d8
jmp 0x8f69c4
movl -0x1044(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1044(%rbp)
jmp 0x8f67e5
jmp 0x8f69da
movl -0x1048(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1070, %rsp # imm = 0x1070
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_entry_from_file.c
|
archive_read_disk_gname
|
const char *
archive_read_disk_gname(struct archive *_a, la_int64_t gid)
{
struct archive_read_disk *a = (struct archive_read_disk *)_a;
if (ARCHIVE_OK != __archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
ARCHIVE_STATE_ANY, "archive_read_disk_gname"))
return (NULL);
if (a->lookup_gname == NULL)
return (NULL);
return ((*a->lookup_gname)(a->lookup_gname_data, gid));
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0xbadb0c5, %esi # imm = 0xBADB0C5
movl $0x7fff, %edx # imm = 0x7FFF
leaq 0x2c2fc3(%rip), %rcx # 0xbb99e0
callq 0x9770c0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x8f6a34
movq $0x0, -0x8(%rbp)
jmp 0x8f6a6c
movq -0x20(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
jne 0x8f6a4c
movq $0x0, -0x8(%rbp)
jmp 0x8f6a6c
movq -0x20(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0xd8(%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c
|
archive_read_disk_set_gname_lookup
|
int
archive_read_disk_set_gname_lookup(struct archive *_a,
void *private_data,
const char * (*lookup_gname)(void *private, la_int64_t gid),
void (*cleanup_gname)(void *private))
{
struct archive_read_disk *a = (struct archive_read_disk *)_a;
archive_check_magic(&a->archive, ARCHIVE_READ_DISK_MAGIC,
ARCHIVE_STATE_ANY, "archive_read_disk_set_gname_lookup");
if (a->cleanup_gname != NULL && a->lookup_gname_data != NULL)
(a->cleanup_gname)(a->lookup_gname_data);
a->lookup_gname = lookup_gname;
a->cleanup_gname = cleanup_gname;
a->lookup_gname_data = private_data;
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl $0xbadb0c5, %esi # imm = 0xBADB0C5
movl $0x7fff, %edx # imm = 0x7FFF
leaq 0x2c2ecb(%rip), %rcx # 0xbb9a10
callq 0x9770c0
movl %eax, -0x34(%rbp)
cmpl $-0x1e, -0x34(%rbp)
jne 0x8f6b5c
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f6bc6
jmp 0x8f6b5e
movq -0x30(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x8f6b92
movq -0x30(%rbp), %rax
cmpq $0x0, 0xd8(%rax)
je 0x8f6b92
movq -0x30(%rbp), %rax
movq 0xd0(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0xd8(%rcx), %rdi
callq *%rax
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0xc8(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0xd0(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0xd8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c
|
open_on_current_dir
|
static int
open_on_current_dir(struct tree *t, const char *path, int flags)
{
#ifdef HAVE_OPENAT
return (openat(tree_current_dir_fd(t), path, flags));
#else
if (tree_enter_working_dir(t) != 0)
return (-1);
return (open(path, flags));
#endif
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f6de0
movl %eax, %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movb $0x0, %al
callq 0x3b4b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c
|
archive_read_disk_open
|
static int
_archive_read_disk_open(struct archive *_a, const char *pathname)
{
struct archive_read_disk *a = (struct archive_read_disk *)_a;
if (a->tree != NULL)
a->tree = tree_reopen(a->tree, pathname,
a->flags & ARCHIVE_READDISK_RESTORE_ATIME);
else
a->tree = tree_open(pathname, a->symlink_mode,
a->flags & ARCHIVE_READDISK_RESTORE_ATIME);
if (a->tree == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate tar data");
a->archive.state = ARCHIVE_STATE_FATAL;
return (ARCHIVE_FATAL);
}
a->archive.state = ARCHIVE_STATE_HEADER;
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x8f7877
movq -0x20(%rbp), %rax
movq 0xa0(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movl 0xc0(%rax), %edx
andl $0x1, %edx
callq 0x8fa720
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0xa0(%rax)
jmp 0x8f78a6
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movsbl 0x98(%rax), %esi
movq -0x20(%rbp), %rax
movl 0xc0(%rax), %edx
andl $0x1, %edx
callq 0x8fa8c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
jne 0x8f78df
movq -0x20(%rbp), %rdi
movl $0xc, %esi
leaq 0x2c23fd(%rip), %rdx # 0xbb9cc1
movb $0x0, %al
callq 0x9401f0
movq -0x20(%rbp), %rax
movl $0x8000, 0x4(%rax) # imm = 0x8000
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f78f1
movq -0x20(%rbp), %rax
movl $0x2, 0x4(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c
|
archive_read_free
|
static int
_archive_read_free(struct archive *_a)
{
struct archive_read_disk *a = (struct archive_read_disk *)_a;
int r;
if (_a == NULL)
return (ARCHIVE_OK);
archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_read_free");
if (a->archive.state != ARCHIVE_STATE_CLOSED)
r = _archive_read_close(&a->archive);
else
r = ARCHIVE_OK;
tree_free(a->tree);
if (a->cleanup_gname != NULL && a->lookup_gname_data != NULL)
(a->cleanup_gname)(a->lookup_gname_data);
if (a->cleanup_uname != NULL && a->lookup_uname_data != NULL)
(a->cleanup_uname)(a->lookup_uname_data);
archive_string_free(&a->archive.error_string);
archive_entry_free(a->entry);
a->archive.magic = 0;
__archive_clean(&a->archive);
free(a);
return (r);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8f7bf7
movl $0x0, -0x4(%rbp)
jmp 0x8f7d00
jmp 0x8f7bf9
movq -0x10(%rbp), %rdi
movl $0xbadb0c5, %esi # imm = 0xBADB0C5
movl $0xffff, %edx # imm = 0xFFFF
leaq 0x2c1b3b(%rip), %rcx # 0xbb9749
callq 0x9770c0
movl %eax, -0x20(%rbp)
cmpl $-0x1e, -0x20(%rbp)
jne 0x8f7c28
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f7d00
jmp 0x8f7c2a
movq -0x18(%rbp), %rax
cmpl $0x20, 0x4(%rax)
je 0x8f7c42
movq -0x18(%rbp), %rdi
callq 0x8f7b50
movl %eax, -0x1c(%rbp)
jmp 0x8f7c49
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0xa0(%rax), %rdi
callq 0x8f8840
movq -0x18(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x8f7c8d
movq -0x18(%rbp), %rax
cmpq $0x0, 0xd8(%rax)
je 0x8f7c8d
movq -0x18(%rbp), %rax
movq 0xd0(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0xd8(%rcx), %rdi
callq *%rax
movq -0x18(%rbp), %rax
cmpq $0x0, 0xe8(%rax)
je 0x8f7cc1
movq -0x18(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
je 0x8f7cc1
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0xf0(%rcx), %rdi
callq *%rax
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x938460
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x8e9990
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rdi
callq 0x940040
movq -0x18(%rbp), %rdi
callq 0x3e548
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c
|
archive_read_next_header
|
static int
_archive_read_next_header(struct archive *_a, struct archive_entry **entryp)
{
int ret;
struct archive_read_disk *a = (struct archive_read_disk *)_a;
*entryp = NULL;
ret = _archive_read_next_header2(_a, a->entry);
*entryp = a->entry;
return ret;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rsi
callq 0x8f7d70
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c
|
archive_read_next_header2
|
static int
_archive_read_next_header2(struct archive *_a, struct archive_entry *entry)
{
struct archive_read_disk *a = (struct archive_read_disk *)_a;
struct tree *t;
int r;
archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
"archive_read_next_header2");
t = a->tree;
if (t->entry_fd >= 0) {
close_and_restore_time(t->entry_fd, t, &t->restore_time);
t->entry_fd = -1;
}
archive_entry_clear(entry);
for (;;) {
r = next_entry(a, t, entry);
if (t->entry_fd >= 0) {
close(t->entry_fd);
t->entry_fd = -1;
}
if (r == ARCHIVE_RETRY) {
archive_entry_clear(entry);
continue;
}
break;
}
/* Return to the initial directory. */
tree_enter_initial_dir(t);
/*
* EOF and FATAL are persistent at this layer. By
* modifying the state, we guarantee that future calls to
* read a header or read data will fail.
*/
switch (r) {
case ARCHIVE_EOF:
a->archive.state = ARCHIVE_STATE_EOF;
break;
case ARCHIVE_OK:
case ARCHIVE_WARN:
/* Overwrite the sourcepath based on the initial directory. */
archive_entry_copy_sourcepath(entry, tree_current_path(t));
t->entry_total = 0;
if (archive_entry_filetype(entry) == AE_IFREG) {
t->nlink = archive_entry_nlink(entry);
t->entry_remaining_bytes = archive_entry_size(entry);
t->entry_eof = (t->entry_remaining_bytes == 0)? 1: 0;
if (!t->entry_eof &&
setup_sparse(a, entry) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
} else {
t->entry_remaining_bytes = 0;
t->entry_eof = 1;
}
a->archive.state = ARCHIVE_STATE_DATA;
break;
case ARCHIVE_RETRY:
break;
case ARCHIVE_FATAL:
a->archive.state = ARCHIVE_STATE_FATAL;
break;
}
__archive_reset_read_data(&a->archive);
return (r);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0xbadb0c5, %esi # imm = 0xBADB0C5
movl $0x6, %edx
leaq 0x2c1e81(%rip), %rcx # 0xbb9c1e
callq 0x9770c0
movl %eax, -0x30(%rbp)
cmpl $-0x1e, -0x30(%rbp)
jne 0x8f7db7
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f7f98
jmp 0x8f7db9
movq -0x20(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x208(%rax)
jl 0x8f7e01
movq -0x28(%rbp), %rax
movl 0x208(%rax), %edi
movq -0x28(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq $0x198, %rdx # imm = 0x198
callq 0x8f8610
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x208(%rax) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rdi
callq 0x8e93f0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x8f88e0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x208(%rax)
jl 0x8f7e48
movq -0x28(%rbp), %rax
movl 0x208(%rax), %edi
callq 0x3ce50
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x208(%rax) # imm = 0xFFFFFFFF
cmpl $-0xa, -0x2c(%rbp)
jne 0x8f7e59
movq -0x18(%rbp), %rdi
callq 0x8e93f0
jmp 0x8f7e0a
jmp 0x8f7e5b
movq -0x28(%rbp), %rdi
callq 0x8f9170
movl -0x2c(%rbp), %eax
addl $0x1e, %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x1f, %eax
ja 0x8f7f89
movq -0x38(%rbp), %rax
leaq 0x2c1ac4(%rip), %rcx # 0xbb9948
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movl $0x10, 0x4(%rax)
jmp 0x8f7f89
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8f91e0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x8ec1e0
movq -0x28(%rbp), %rax
movq $0x0, 0x218(%rax)
movq -0x18(%rbp), %rdi
callq 0x8e9c10
cmpl $0x8000, %eax # imm = 0x8000
jne 0x8f7f52
movq -0x18(%rbp), %rdi
callq 0x8ea460
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x194(%rax)
movq -0x18(%rbp), %rdi
callq 0x8ea740
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x210(%rax)
movq -0x28(%rbp), %rax
movq 0x210(%rax), %rdx
xorl %ecx, %ecx
movl $0x1, %eax
cmpq $0x0, %rdx
cmovel %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x20c(%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x20c(%rax)
jne 0x8f7f50
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8f9200
cmpl $0x0, %eax
je 0x8f7f50
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x8f7f98
jmp 0x8f7f6f
movq -0x28(%rbp), %rax
movq $0x0, 0x210(%rax)
movq -0x28(%rbp), %rax
movl $0x1, 0x20c(%rax)
movq -0x20(%rbp), %rax
movl $0x4, 0x4(%rax)
jmp 0x8f7f89
jmp 0x8f7f89
movq -0x20(%rbp), %rax
movl $0x8000, 0x4(%rax) # imm = 0x8000
movq -0x20(%rbp), %rdi
callq 0x8f3b80
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c
|
tree_close
|
static void
tree_close(struct tree *t)
{
if (t == NULL)
return;
if (t->entry_fd >= 0) {
close_and_restore_time(t->entry_fd, t, &t->restore_time);
t->entry_fd = -1;
}
/* Close the handle of readdir(). */
if (t->d != INVALID_DIR_HANDLE) {
closedir(t->d);
t->d = INVALID_DIR_HANDLE;
}
/* Release anything remaining in the stack. */
while (t->stack != NULL) {
if (t->stack->flags & isDirLink)
close(t->stack->symlink_parent_fd);
tree_pop(t);
}
if (t->working_dir_fd >= 0) {
close(t->working_dir_fd);
t->working_dir_fd = -1;
}
if (t->initial_dir_fd >= 0) {
close(t->initial_dir_fd);
t->initial_dir_fd = -1;
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8f8528
jmp 0x8f85ff
movq -0x8(%rbp), %rax
cmpl $0x0, 0x208(%rax)
jl 0x8f8561
movq -0x8(%rbp), %rax
movl 0x208(%rax), %edi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x198, %rdx # imm = 0x198
callq 0x8f8610
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x208(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x8f8585
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3d5f0
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x8f8587
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x8f85bd
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x48(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x8f85b2
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x50(%rax), %edi
callq 0x3ce50
movq -0x8(%rbp), %rdi
callq 0x8f8760
jmp 0x8f8587
movq -0x8(%rbp), %rax
cmpl $0x0, 0x68(%rax)
jl 0x8f85de
movq -0x8(%rbp), %rax
movl 0x68(%rax), %edi
callq 0x3ce50
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x68(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jl 0x8f85ff
movq -0x8(%rbp), %rax
movl 0x64(%rax), %edi
callq 0x3ce50
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x64(%rax) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c
|
process_add_entry
|
static int
process_add_entry(struct archive_read *a, struct mtree *mtree,
struct mtree_option **global, const char *line, ssize_t line_len,
struct mtree_entry **last_entry, int is_form_d)
{
struct mtree_entry *entry;
struct mtree_option *iter;
const char *next, *eq, *name, *end;
size_t name_len, len;
int r, i;
if ((entry = malloc(sizeof(*entry))) == NULL) {
archive_set_error(&a->archive, errno, "Can't allocate memory");
return (ARCHIVE_FATAL);
}
entry->next = NULL;
entry->options = NULL;
entry->name = NULL;
entry->used = 0;
entry->full = 0;
/* Add this entry to list. */
if (*last_entry == NULL)
mtree->entries = entry;
else
(*last_entry)->next = entry;
*last_entry = entry;
if (is_form_d) {
/* Filename is last item on line. */
/* Adjust line_len to trim trailing whitespace */
while (line_len > 0) {
char last_character = line[line_len - 1];
if (last_character == '\r'
|| last_character == '\n'
|| last_character == '\t'
|| last_character == ' ') {
line_len--;
} else {
break;
}
}
/* Name starts after the last whitespace separator */
name = line;
for (i = 0; i < line_len; i++) {
if (line[i] == '\r'
|| line[i] == '\n'
|| line[i] == '\t'
|| line[i] == ' ') {
name = line + i + 1;
}
}
name_len = line + line_len - name;
end = name;
} else {
/* Filename is first item on line */
name_len = strcspn(line, " \t\r\n");
name = line;
line += name_len;
end = line + line_len;
}
/* name/name_len is the name within the line. */
/* line..end brackets the entire line except the name */
if ((entry->name = malloc(name_len + 1)) == NULL) {
archive_set_error(&a->archive, errno, "Can't allocate memory");
return (ARCHIVE_FATAL);
}
memcpy(entry->name, name, name_len);
entry->name[name_len] = '\0';
parse_escapes(entry->name, entry);
entry->next_dup = NULL;
if (entry->full) {
if (!__archive_rb_tree_insert_node(&mtree->rbtree, &entry->rbnode)) {
struct mtree_entry *alt;
alt = (struct mtree_entry *)__archive_rb_tree_find_node(
&mtree->rbtree, entry->name);
while (alt->next_dup)
alt = alt->next_dup;
alt->next_dup = entry;
}
}
for (iter = *global; iter != NULL; iter = iter->next) {
r = add_option(a, &entry->options, iter->value,
strlen(iter->value));
if (r != ARCHIVE_OK)
return (r);
}
for (;;) {
next = line + strspn(line, " \t\r\n");
if (*next == '\0')
return (ARCHIVE_OK);
if (next >= end)
return (ARCHIVE_OK);
line = next;
next = line + strcspn(line, " \t\r\n");
eq = strchr(line, '=');
if (eq == NULL || eq > next)
len = next - line;
else
len = eq - line;
remove_option(&entry->options, line, len);
r = add_option(a, &entry->options, line, next - line);
if (r != ARCHIVE_OK)
return (r);
line = next;
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x40, %edi
callq 0x3e578
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x91863d
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x3e130
movq -0x98(%rbp), %rdi
movl (%rax), %esi
leaq 0x2a1593(%rip), %rdx # 0xbb9bbd
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x918a8e
movq -0x40(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x40(%rbp), %rax
movb $0x0, 0x39(%rax)
movq -0x40(%rbp), %rax
movb $0x0, 0x38(%rax)
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x918689
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
jmp 0x918698
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x0, 0x10(%rbp)
je 0x9187a7
jmp 0x9186af
cmpq $0x0, -0x30(%rbp)
jle 0x91870d
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
subq $0x1, %rcx
movb (%rax,%rcx), %al
movb %al, -0x81(%rbp)
movsbl -0x81(%rbp), %eax
cmpl $0xd, %eax
je 0x9186fb
movsbl -0x81(%rbp), %eax
cmpl $0xa, %eax
je 0x9186fb
movsbl -0x81(%rbp), %eax
cmpl $0x9, %eax
je 0x9186fb
movsbl -0x81(%rbp), %eax
cmpl $0x20, %eax
jne 0x918709
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x91870b
jmp 0x91870d
jmp 0x9186af
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x80(%rbp)
movslq -0x80(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0x91878a
movq -0x28(%rbp), %rax
movslq -0x80(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
je 0x91876a
movq -0x28(%rbp), %rax
movslq -0x80(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x91876a
movq -0x28(%rbp), %rax
movslq -0x80(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
je 0x91876a
movq -0x28(%rbp), %rax
movslq -0x80(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x91877d
movq -0x28(%rbp), %rax
movslq -0x80(%rbp), %rcx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x91877f
movl -0x80(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x80(%rbp)
jmp 0x91871c
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq -0x60(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x9187db
movq -0x28(%rbp), %rdi
leaq 0x2738ee(%rip), %rsi # 0xb8c0a0
callq 0x3da90
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x70(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x70(%rbp), %rdi
addq $0x1, %rdi
callq 0x3e578
movq -0x40(%rbp), %rcx
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
jne 0x918829
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0x3e130
movq -0xa0(%rbp), %rdi
movl (%rax), %esi
leaq 0x2a13a7(%rip), %rdx # 0xbb9bbd
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x918a8e
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x60(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x3cb70
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x70(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x40(%rbp), %rsi
callq 0x918ce0
movq -0x40(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x40(%rbp), %rax
cmpb $0x0, 0x38(%rax)
je 0x9188e0
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
movq -0x40(%rbp), %rsi
callq 0x8f19d0
cmpl $0x0, %eax
jne 0x9188de
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x8f17e0
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x9188cf
movq -0x90(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x90(%rbp)
jmp 0x9188ad
movq -0x40(%rbp), %rcx
movq -0x90(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x9188e0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x918968
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x40(%rbp), %rax
addq $0x28, %rax
movq %rax, -0xb0(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3b8f0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq %rax, %rcx
callq 0x918f10
movl %eax, -0x7c(%rbp)
cmpl $0x0, -0x7c(%rbp)
je 0x918959
movl -0x7c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x918a8e
jmp 0x91895b
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x9188eb
jmp 0x91896a
movq -0x28(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x273720(%rip), %rsi # 0xb8c0a0
callq 0x3d500
movq %rax, %rcx
movq -0xc0(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x9189ae
movl $0x0, -0x4(%rbp)
jmp 0x918a8e
movq -0x50(%rbp), %rax
cmpq -0x68(%rbp), %rax
jb 0x9189c4
movl $0x0, -0x4(%rbp)
jmp 0x918a8e
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x2736be(%rip), %rsi # 0xb8c0a0
callq 0x3da90
movq %rax, %rcx
movq -0xc8(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
movl $0x3d, %esi
callq 0x3d450
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x918a1b
movq -0x58(%rbp), %rax
cmpq -0x50(%rbp), %rax
jbe 0x918a2c
movq -0x50(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x78(%rbp)
jmp 0x918a3b
movq -0x58(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x78(%rbp)
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq -0x28(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0x919010
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x28, %rsi
movq -0x28(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rax, %rcx
callq 0x918f10
movl %eax, -0x7c(%rbp)
cmpl $0x0, -0x7c(%rbp)
je 0x918a81
movl -0x7c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x918a8e
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x91896a
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c
|
process_global_unset
|
static int
process_global_unset(struct archive_read *a,
struct mtree_option **global, const char *line)
{
const char *next;
size_t len;
line += 6;
if (strchr(line, '=') != NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"/unset shall not contain `='");
return ARCHIVE_FATAL;
}
for (;;) {
next = line + strspn(line, " \t\r\n");
if (*next == '\0')
return (ARCHIVE_OK);
line = next;
len = strcspn(line, " \t\r\n");
if (len == 3 && strncmp(line, "all", 3) == 0) {
free_options(*global);
*global = NULL;
} else {
remove_option(global, line, len);
}
line += len;
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x6, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x3d, %esi
callq 0x3d450
cmpq $0x0, %rax
je 0x918c17
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x2a3d20(%rip), %rdx # 0xbbc924
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x918ccc
jmp 0x918c19
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x273474(%rip), %rsi # 0xb8c0a0
callq 0x3d500
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x918c54
movl $0x0, -0x4(%rbp)
jmp 0x918ccc
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x273439(%rip), %rsi # 0xb8c0a0
callq 0x3da90
movq %rax, -0x30(%rbp)
cmpq $0x3, -0x30(%rbp)
jne 0x918caa
movq -0x20(%rbp), %rdi
leaq 0x265354(%rip), %rsi # 0xb7dfd6
movl $0x3, %edx
callq 0x3ce80
cmpl $0x0, %eax
jne 0x918caa
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x916b30
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
jmp 0x918cbb
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x919010
movq -0x30(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x918c19
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c
|
parse_escapes
|
static void
parse_escapes(char *src, struct mtree_entry *mentry)
{
char *dest = src;
char c;
if (mentry != NULL && strcmp(src, ".") == 0)
mentry->full = 1;
while (*src != '\0') {
c = *src++;
if (c == '/' && mentry != NULL)
mentry->full = 1;
if (c == '\\') {
switch (src[0]) {
case '0':
if (src[1] < '0' || src[1] > '7') {
c = 0;
++src;
break;
}
/* FALLTHROUGH */
case '1':
case '2':
case '3':
if (src[1] >= '0' && src[1] <= '7' &&
src[2] >= '0' && src[2] <= '7') {
c = (src[0] - '0') << 6;
c |= (src[1] - '0') << 3;
c |= (src[2] - '0');
src += 3;
}
break;
case 'a':
c = '\a';
++src;
break;
case 'b':
c = '\b';
++src;
break;
case 'f':
c = '\f';
++src;
break;
case 'n':
c = '\n';
++src;
break;
case 'r':
c = '\r';
++src;
break;
case 's':
c = ' ';
++src;
break;
case 't':
c = '\t';
++src;
break;
case 'v':
c = '\v';
++src;
break;
case '\\':
c = '\\';
++src;
break;
}
}
*dest++ = c;
}
*dest = '\0';
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x918d1c
movq -0x8(%rbp), %rdi
leaq 0x23880d(%rip), %rsi # 0xb51517
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x918d1c
movq -0x10(%rbp), %rax
movb $0x1, 0x38(%rax)
jmp 0x918d1e
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x918f03
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x2f, %eax
jne 0x918d5a
cmpq $0x0, -0x10(%rbp)
je 0x918d5a
movq -0x10(%rbp), %rax
movb $0x1, 0x38(%rax)
movsbl -0x19(%rbp), %eax
cmpl $0x5c, %eax
jne 0x918eea
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
addl $-0x30, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x46, %eax
ja 0x918ee8
movq -0x28(%rbp), %rax
leaq 0x2a37c1(%rip), %rcx # 0xbbc54c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x30, %eax
jl 0x918dae
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x37, %eax
jle 0x918dc3
movb $0x0, -0x19(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x918ee8
jmp 0x918dc5
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x30, %eax
jl 0x918e40
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x37, %eax
jg 0x918e40
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x30, %eax
jl 0x918e40
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x37, %eax
jg 0x918e40
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
shll $0x6, %eax
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %ecx
subl $0x30, %ecx
shll $0x3, %ecx
movsbl -0x19(%rbp), %eax
orl %ecx, %eax
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %ecx
subl $0x30, %ecx
movsbl -0x19(%rbp), %eax
orl %ecx, %eax
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x8(%rbp)
jmp 0x918ee8
movb $0x7, -0x19(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x918ee8
movb $0x8, -0x19(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x918ee8
movb $0xc, -0x19(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x918ee8
movb $0xa, -0x19(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x918ee8
movb $0xd, -0x19(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x918ee8
movb $0x20, -0x19(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x918ee8
movb $0x9, -0x19(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x918ee8
movb $0xb, -0x19(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x918ee8
movb $0x5c, -0x19(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x918eea
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x918d1e
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c
|
add_option
|
static int
add_option(struct archive_read *a, struct mtree_option **global,
const char *value, size_t len)
{
struct mtree_option *opt;
if ((opt = malloc(sizeof(*opt))) == NULL) {
archive_set_error(&a->archive, errno, "Can't allocate memory");
return (ARCHIVE_FATAL);
}
if ((opt->value = malloc(len + 1)) == NULL) {
free(opt);
archive_set_error(&a->archive, errno, "Can't allocate memory");
return (ARCHIVE_FATAL);
}
memcpy(opt->value, value, len);
opt->value[len] = '\0';
opt->next = *global;
*global = opt;
return (ARCHIVE_OK);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x10, %edi
callq 0x3e578
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x918f69
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x3e130
movq -0x38(%rbp), %rdi
movl (%rax), %esi
leaq 0x2a0c67(%rip), %rdx # 0xbb9bbd
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x918ffc
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
callq 0x3e578
movq -0x30(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x918fb7
movq -0x30(%rbp), %rdi
callq 0x3e548
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x3e130
movq -0x40(%rbp), %rdi
movl (%rax), %esi
leaq 0x2a0c16(%rip), %rdx # 0xbb9bbd
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x918ffc
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3cb70
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c
|
try_skip_sfx
|
static int try_skip_sfx(struct archive_read *a)
{
const char *p;
if ((p = __archive_read_ahead(a, 7, NULL)) == NULL)
return ARCHIVE_EOF;
if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0)
{
char signature[sizeof(rar5_signature_xor)];
const void *h;
const char *q;
size_t skip, total = 0;
ssize_t bytes, window = 4096;
rar5_signature(signature);
while (total + window <= (1024 * 512)) {
h = __archive_read_ahead(a, window, &bytes);
if (h == NULL) {
/* Remaining bytes are less than window. */
window >>= 1;
if (window < 0x40)
goto fatal;
continue;
}
if (bytes < 0x40)
goto fatal;
p = h;
q = p + bytes;
/*
* Scan ahead until we find something that looks
* like the RAR header.
*/
while (p + 8 < q) {
if (memcmp(p, signature, sizeof(signature)) == 0) {
skip = p - (const char *)h;
__archive_read_consume(a, skip);
return (ARCHIVE_OK);
}
p += 0x10;
}
skip = p - (const char *)h;
__archive_read_consume(a, skip);
total += skip;
}
}
return ARCHIVE_OK;
fatal:
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Couldn't find out RAR header");
return (ARCHIVE_FATAL);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x7, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x8f4160
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x923164
movl $0x1, -0x4(%rbp)
jmp 0x9232cc
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4d, %eax
jne 0x92317d
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x5a, %eax
je 0x923197
movq -0x18(%rbp), %rax
movl (%rax), %eax
subl $0x464c457f, %eax # imm = 0x464C457F
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x9232a5
movq $0x0, -0x40(%rbp)
movq $0x1000, -0x50(%rbp) # imm = 0x1000
leaq -0x20(%rbp), %rdi
callq 0x923020
movq -0x40(%rbp), %rax
addq -0x50(%rbp), %rax
cmpq $0x80000, %rax # imm = 0x80000
ja 0x9232a3
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x8f4160
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9231f9
movq -0x50(%rbp), %rax
sarq %rax
movq %rax, -0x50(%rbp)
cmpq $0x40, -0x50(%rbp)
jge 0x9231f7
jmp 0x9232ae
jmp 0x9231b0
cmpq $0x40, -0x48(%rbp)
jge 0x923205
jmp 0x9232ae
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
cmpq -0x30(%rbp), %rax
jae 0x923276
movq -0x18(%rbp), %rax
leaq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq (%rax), %rax
subq %rcx, %rax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x923268
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x8f4710
movl $0x0, -0x4(%rbp)
jmp 0x9232cc
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0x923219
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x8f4710
movq -0x38(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x9231b0
jmp 0x9232a5
movl $0x0, -0x4(%rbp)
jmp 0x9232cc
movq -0x10(%rbp), %rdi
movl $0x54, %esi
leaq 0x299c1f(%rip), %rdx # 0xbbcedd
movb $0x0, %al
callq 0x9401f0
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c
|
free_sconv_object
|
static void
free_sconv_object(struct archive_string_conv *sc)
{
free(sc->from_charset);
free(sc->to_charset);
archive_string_free(&sc->utftmp);
#if HAVE_ICONV
if (sc->cd != (iconv_t)-1)
iconv_close(sc->cd);
if (sc->cd_w != (iconv_t)-1)
iconv_close(sc->cd_w);
#endif
free(sc);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3e548
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3e548
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x938460
movq -0x8(%rbp), %rdi
callq 0x3e548
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c
|
mbsnbytes
|
static size_t
mbsnbytes(const void *_p, size_t n)
{
size_t s;
const char *p, *pp;
if (_p == NULL)
return (0);
p = (const char *)_p;
/* Like strlen(p), except won't examine positions beyond p[n]. */
s = 0;
pp = p;
while (s < n && *pp) {
pp++;
s++;
}
return (s);
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x93963d
movq $0x0, -0x8(%rbp)
jmp 0x93969f
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x31(%rbp)
jae 0x939674
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x93967d
jmp 0x939697
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x939655
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c
|
archive_mstring_get_wcs
|
int
archive_mstring_get_wcs(struct archive *a, struct archive_mstring *aes,
const wchar_t **wp)
{
int r, ret = 0;
(void)a;/* UNUSED */
/* Return WCS form if we already have it. */
if (aes->aes_set & AES_SET_WCS) {
*wp = aes->aes_wcs.s;
return (ret);
}
*wp = NULL;
/* Try converting UTF8 to MBS first if MBS does not exist yet. */
if ((aes->aes_set & AES_SET_MBS) == 0) {
const char *p; /* unused */
archive_mstring_get_mbs(a, aes, &p); /* ignore errors, we'll handle it later */
}
/* Try converting MBS to WCS using native locale. */
if (aes->aes_set & AES_SET_MBS) {
archive_wstring_empty(&(aes->aes_wcs));
r = archive_wstring_append_from_mbs(&(aes->aes_wcs),
aes->aes_mbs.s, aes->aes_mbs.length);
if (r == 0) {
aes->aes_set |= AES_SET_WCS;
*wp = aes->aes_wcs.s;
} else
ret = -1;/* failure. */
}
return (ret);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x60(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x939a64
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x939afc
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl 0x60(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x939a8f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x9398a0
movq -0x18(%rbp), %rax
movl 0x60(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x939af6
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x9388b0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x939aed
movq -0x18(%rbp), %rax
movl 0x60(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x60(%rax)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x939af4
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
jmp 0x939af6
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c
|
strncat_from_utf8_libarchive2
|
static int
strncat_from_utf8_libarchive2(struct archive_string *as,
const void *_p, size_t len, struct archive_string_conv *sc)
{
const char *s;
int n;
char *p;
char *end;
uint32_t unicode;
#if HAVE_WCRTOMB
mbstate_t shift_state;
memset(&shift_state, 0, sizeof(shift_state));
#else
/* Clear the shift state before starting. */
wctomb(NULL, L'\0');
#endif
(void)sc; /* UNUSED */
/*
* Allocate buffer for MBS.
* We need this allocation here since it is possible that
* as->s is still NULL.
*/
if (archive_string_ensure(as, as->length + len + 1) == NULL)
return (-1);
s = (const char *)_p;
p = as->s + as->length;
end = as->s + as->buffer_length - MB_CUR_MAX -1;
while ((n = _utf8_to_unicode(&unicode, s, len)) != 0) {
wchar_t wc;
if (p >= end) {
as->length = p - as->s;
/* Re-allocate buffer for MBS. */
if (archive_string_ensure(as,
as->length + max(len * 2,
(size_t)MB_CUR_MAX) + 1) == NULL)
return (-1);
p = as->s + as->length;
end = as->s + as->buffer_length - MB_CUR_MAX -1;
}
/*
* As libarchive 2.x, translates the UTF-8 characters into
* wide-characters in the assumption that WCS is Unicode.
*/
if (n < 0) {
n *= -1;
wc = L'?';
} else
wc = (wchar_t)unicode;
s += n;
len -= n;
/*
* Translates the wide-character into the current locale MBS.
*/
#if HAVE_WCRTOMB
n = (int)wcrtomb(p, wc, &shift_state);
#else
n = (int)wctomb(p, wc);
#endif
if (n == -1)
return (-1);
p += n;
}
as->length = p - as->s;
as->s[as->length] = '\0';
return (0);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x54(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x3b780
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
addq -0x20(%rbp), %rsi
addq $0x1, %rsi
callq 0x938530
cmpq $0x0, %rax
jne 0x93a6e6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x93a8cd
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x10(%rcx), %rax
movq %rax, -0x60(%rbp)
callq 0x3d610
movq %rax, %rdx
movq -0x60(%rbp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x4c(%rbp), %rdi
callq 0x93e660
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x93a89d
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jb 0x93a829
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x68(%rbp)
callq 0x3d610
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jbe 0x93a7ae
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x80(%rbp)
jmp 0x93a7b7
callq 0x3d610
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x80(%rbp), %rax
addq %rax, %rsi
addq $0x1, %rsi
callq 0x938530
cmpq $0x0, %rax
jne 0x93a7e1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x93a8cd
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x10(%rcx), %rax
movq %rax, -0x88(%rbp)
callq 0x3d610
movq %rax, %rdx
movq -0x88(%rbp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x48(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x93a83f
imull $-0x1, -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl $0x3f, -0x58(%rbp)
jmp 0x93a845
movl -0x4c(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movslq -0x34(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
movl -0x58(%rbp), %esi
leaq -0x54(%rbp), %rdx
callq 0x3b200
movl %eax, -0x34(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0x93a887
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x93a8cd
movl -0x34(%rbp), %ecx
movq -0x40(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0x93a730
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
|
/JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.