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, &copyfile_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