Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
This file has been truncated, but you can view the full file.
./src/CMakeFiles/rawspeed.dir/librawspeed/decompressors/SonyArw2Decompressor.cpp.o: file format elf64-x86-64
Disassembly of section .text:
0000000000000000 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)>:
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:36
namespace rawspeed {
SonyArw2Decompressor::SonyArw2Decompressor(const RawImage& img,
const ByteStream& input_)
: AbstractParallelizedDecompressor(img) {
0: 55 push %rbp
1: 48 89 e5 mov %rsp,%rbp
4: 41 57 push %r15
6: 41 56 push %r14
8: 41 55 push %r13
a: 41 54 push %r12
c: 53 push %rbx
d: 48 83 e4 e0 and $0xffffffffffffffe0,%rsp
11: 48 81 ec 80 00 00 00 sub $0x80,%rsp
18: 48 89 e3 mov %rsp,%rbx
1b: 48 89 53 18 mov %rdx,0x18(%rbx)
1f: 49 89 f6 mov %rsi,%r14
22: 49 89 fc mov %rdi,%r12
25: 48 8b 05 00 00 00 00 mov 0x0(%rip),%rax # 2c <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x2c>
2c: 83 38 00 cmpl $0x0,(%rax)
2f: 0f 84 a9 08 00 00 je 8de <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x8de>
35: bf 60 00 00 00 mov $0x60,%edi
3a: e8 00 00 00 00 callq 3f <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x3f>
3f: 49 89 c7 mov %rax,%r15
42: 4c 89 f9 mov %r15,%rcx
45: 4d 85 ff test %r15,%r15
48: 75 0e jne 58 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x58>
4a: 48 89 e1 mov %rsp,%rcx
4d: 48 83 c1 a0 add $0xffffffffffffffa0,%rcx
51: 48 83 e1 e0 and $0xffffffffffffffe0,%rcx
55: 48 89 cc mov %rcx,%rsp
58: 48 89 4b 58 mov %rcx,0x58(%rbx)
5c: 48 c7 01 b3 8a b5 41 movq $0x41b58ab3,(%rcx)
63: 48 8d 05 00 00 00 00 lea 0x0(%rip),%rax # 6a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x6a>
6a: 48 89 41 08 mov %rax,0x8(%rcx)
6e: 48 8b 05 00 00 00 00 mov 0x0(%rip),%rax # 75 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x75>
75: 48 89 41 10 mov %rax,0x10(%rcx)
79: 49 89 cd mov %rcx,%r13
7c: 49 c1 ed 03 shr $0x3,%r13
80: 48 b8 f1 f1 f1 f1 f8 movabs $0xf3f8f8f8f1f1f1f1,%rax
87: f8 f8 f3
8a: 49 89 85 00 80 ff 7f mov %rax,0x7fff8000(%r13)
91: 41 c7 85 08 80 ff 7f movl $0xf3f3f3f3,0x7fff8008(%r13)
98: f3 f3 f3 f3
9c: 4d 85 e4 test %r12,%r12
9f: 0f 84 9e 0c 00 00 je d43 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd43>
a5: 44 89 e0 mov %r12d,%eax
a8: 83 e0 07 and $0x7,%eax
ab: 48 85 c0 test %rax,%rax
ae: 0f 85 8f 0c 00 00 jne d43 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd43>
b4: 41 f6 c6 07 test $0x7,%r14b
b8: 0f 85 25 0d 00 00 jne de3 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xde3>
AbstractParallelizedDecompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/AbstractParallelizedDecompressor.h:45
virtual void decompressThreaded(const RawDecompressorThread* t) const = 0;
void decompressOne(uint32 pieces) const;
public:
explicit AbstractParallelizedDecompressor(const RawImage& img) : mRaw(img) {}
be: 4c 89 e0 mov %r12,%rax
c1: 48 c1 e8 03 shr $0x3,%rax
c5: 48 89 43 48 mov %rax,0x48(%rbx)
c9: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
d0: 0f 85 21 0d 00 00 jne df7 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xdf7>
d6: 48 89 4b 38 mov %rcx,0x38(%rbx)
da: 48 8b 05 00 00 00 00 mov 0x0(%rip),%rax # e1 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe1>
e1: 48 83 c0 10 add $0x10,%rax
e5: 48 89 43 50 mov %rax,0x50(%rbx)
e9: 49 89 04 24 mov %rax,(%r12)
ed: 49 8d 44 24 08 lea 0x8(%r12),%rax
f2: a8 07 test $0x7,%al
f4: 0f 85 05 0d 00 00 jne dff <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xdff>
fa: 48 89 43 08 mov %rax,0x8(%rbx)
fe: 48 89 c7 mov %rax,%rdi
101: 4c 89 f6 mov %r14,%rsi
104: e8 00 00 00 00 callq 109 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x109>
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:36
109: 48 8b 43 48 mov 0x48(%rbx),%rax
10d: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
114: 0f 85 fc 0c 00 00 jne e16 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe16>
11a: 48 8b 05 00 00 00 00 mov 0x0(%rip),%rax # 121 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x121>
121: 48 83 c0 10 add $0x10,%rax
125: 49 89 04 24 mov %rax,(%r12)
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:34
SonyArw2Decompressor::SonyArw2Decompressor(const RawImage& img,
129: 4d 8d 74 24 10 lea 0x10(%r12),%r14
12e: 41 f6 c6 07 test $0x7,%r14b
132: 0f 85 e6 0c 00 00 jne e1e <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe1e>
Buffer():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/Buffer.h:63
{
public:
using size_type = uint32;
protected:
const uchar8* data = nullptr;
138: 4c 89 f0 mov %r14,%rax
13b: 48 c1 e8 03 shr $0x3,%rax
13f: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
146: 0f 85 e6 0c 00 00 jne e32 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe32>
14c: 49 c7 44 24 10 00 00 movq $0x0,0x10(%r12)
153: 00 00
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/Buffer.h:64
size_type size = 0;
155: 49 8d 7c 24 18 lea 0x18(%r12),%rdi
15a: 48 89 f8 mov %rdi,%rax
15d: 48 c1 e8 03 shr $0x3,%rax
161: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
167: 84 c0 test %al,%al
169: 0f 85 a8 07 00 00 jne 917 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x917>
16f: 41 c7 44 24 18 00 00 movl $0x0,0x18(%r12)
176: 00 00
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/Buffer.h:65
bool isOwner = false;
178: 49 8d 7c 24 1c lea 0x1c(%r12),%rdi
17d: 48 89 f8 mov %rdi,%rax
180: 48 c1 e8 03 shr $0x3,%rax
184: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
18a: 84 c0 test %al,%al
18c: 0f 85 9a 07 00 00 jne 92c <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x92c>
192: 41 c6 44 24 1c 00 movb $0x0,0x1c(%r12)
DataBuffer():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/Buffer.h:185
* byte sized data, like int, float, etc.
*/
class DataBuffer : public Buffer {
// FIXME: default should be Endianness::unknown !
Endianness endianness = Endianness::little;
198: 49 8d 7c 24 20 lea 0x20(%r12),%rdi
19d: 48 89 f8 mov %rdi,%rax
1a0: 48 c1 e8 03 shr $0x3,%rax
1a4: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
1aa: 84 c0 test %al,%al
1ac: 0f 85 8c 07 00 00 jne 93e <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x93e>
1b2: 4c 89 7b 30 mov %r15,0x30(%rbx)
1b6: 41 c7 44 24 20 ad de movl $0xdead,0x20(%r12)
1bd: 00 00
ByteStream():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/ByteStream.h:39
namespace rawspeed {
class ByteStream : public DataBuffer
{
protected:
size_type pos = 0; // position of stream in bytes (this is next byte to deliver)
1bf: 49 8d 7c 24 24 lea 0x24(%r12),%rdi
1c4: 48 89 f8 mov %rdi,%rax
1c7: 48 c1 e8 03 shr $0x3,%rax
1cb: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
1d1: 84 c0 test %al,%al
1d3: 0f 85 7a 07 00 00 jne 953 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x953>
1d9: c7 07 00 00 00 00 movl $0x0,(%rdi)
1df: 48 ba 23 da e6 f9 21 movabs $0xded91821f9e6da23,%rdx
1e6: 18 d9 de
1e9: 49 bf 69 2d 38 eb 08 movabs $0x9ddfea08eb382d69,%r15
1f0: ea df 9d
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:37
if (mRaw->getCpp() != 1 || mRaw->getDataType() != TYPE_USHORT16 ||
1f3: 49 8b 04 24 mov (%r12),%rax
1f7: 48 89 c1 mov %rax,%rcx
1fa: 48 31 d1 xor %rdx,%rcx
1fd: 49 0f af cf imul %r15,%rcx
201: 48 89 ce mov %rcx,%rsi
204: 48 c1 ee 2f shr $0x2f,%rsi
208: 48 31 c6 xor %rax,%rsi
20b: 48 31 ce xor %rcx,%rsi
20e: 49 0f af f7 imul %r15,%rsi
212: 48 89 f2 mov %rsi,%rdx
215: 48 c1 ea 2f shr $0x2f,%rdx
219: 48 31 f2 xor %rsi,%rdx
21c: 49 0f af d7 imul %r15,%rdx
220: 89 d0 mov %edx,%eax
222: 83 e0 7f and $0x7f,%eax
225: 4c 8b 05 00 00 00 00 mov 0x0(%rip),%r8 # 22c <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x22c>
22c: 49 39 14 c0 cmp %rdx,(%r8,%rax,8)
230: 0f 85 ab 07 00 00 jne 9e1 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x9e1>
236: 4c 89 73 40 mov %r14,0x40(%rbx)
23a: 48 8b 7b 08 mov 0x8(%rbx),%rdi
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
public:
static RawImage create(RawImageType type = TYPE_USHORT16);
static RawImage create(const iPoint2D &dim,
RawImageType type = TYPE_USHORT16,
uint32 componentsPerPixel = 1);
RawImageData* operator->() const { return p_; }
23e: 48 89 f8 mov %rdi,%rax
241: 48 c1 e8 03 shr $0x3,%rax
245: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
24c: 0f 85 e8 0b 00 00 jne e3a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe3a>
252: 4c 8b 37 mov (%rdi),%r14
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:37
255: 41 f6 c6 07 test $0x7,%r14b
259: 0f 85 f8 0a 00 00 jne d57 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd57>
25f: 4d 85 f6 test %r14,%r14
262: 0f 84 ef 0a 00 00 je d57 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd57>
268: 48 89 43 10 mov %rax,0x10(%rbx)
26c: 48 ba 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%rdx
273: 46 e3 cb
276: 49 8b 06 mov (%r14),%rax
279: 48 89 c1 mov %rax,%rcx
27c: 48 31 d1 xor %rdx,%rcx
27f: 49 0f af cf imul %r15,%rcx
283: 48 89 ce mov %rcx,%rsi
286: 48 c1 ee 2f shr $0x2f,%rsi
28a: 48 31 c6 xor %rax,%rsi
28d: 48 31 ce xor %rcx,%rsi
290: 49 0f af f7 imul %r15,%rsi
294: 48 89 f2 mov %rsi,%rdx
297: 48 c1 ea 2f shr $0x2f,%rdx
29b: 48 31 f2 xor %rsi,%rdx
29e: 49 0f af d7 imul %r15,%rdx
2a2: 89 d0 mov %edx,%eax
2a4: 83 e0 7f and $0x7f,%eax
2a7: 49 39 14 c0 cmp %rdx,(%r8,%rax,8)
2ab: 0f 85 4b 07 00 00 jne 9fc <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x9fc>
2b1: 4c 89 f7 mov %r14,%rdi
2b4: e8 00 00 00 00 callq 2b9 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x2b9>
2b9: 83 f8 01 cmp $0x1,%eax
2bc: 4c 89 63 28 mov %r12,0x28(%rbx)
2c0: 4c 89 6b 20 mov %r13,0x20(%rbx)
2c4: 49 bd 23 da e6 f9 21 movabs $0xded91821f9e6da23,%r13
2cb: 18 d9 de
2ce: 0f 85 f1 07 00 00 jne ac5 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xac5>
2d4: 49 8b 04 24 mov (%r12),%rax
2d8: 48 89 c1 mov %rax,%rcx
2db: 4c 31 e9 xor %r13,%rcx
2de: 49 0f af cf imul %r15,%rcx
2e2: 48 89 ce mov %rcx,%rsi
2e5: 48 c1 ee 2f shr $0x2f,%rsi
2e9: 48 31 c6 xor %rax,%rsi
2ec: 48 31 ce xor %rcx,%rsi
2ef: 49 0f af f7 imul %r15,%rsi
2f3: 48 89 f2 mov %rsi,%rdx
2f6: 48 c1 ea 2f shr $0x2f,%rdx
2fa: 48 31 f2 xor %rsi,%rdx
2fd: 49 0f af d7 imul %r15,%rdx
301: 89 d0 mov %edx,%eax
303: 83 e0 7f and $0x7f,%eax
306: 4c 8b 05 00 00 00 00 mov 0x0(%rip),%r8 # 30d <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x30d>
30d: 49 39 14 c0 cmp %rdx,(%r8,%rax,8)
311: 48 8b 7b 08 mov 0x8(%rbx),%rdi
315: 48 8b 43 10 mov 0x10(%rbx),%rax
319: 0f 85 f1 06 00 00 jne a10 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xa10>
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
31f: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
326: 48 ba 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%rdx
32d: 46 e3 cb
330: 0f 85 0f 07 00 00 jne a45 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xa45>
336: 4c 8b 37 mov (%rdi),%r14
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:37
339: 41 f6 c6 07 test $0x7,%r14b
33d: 0f 85 28 0a 00 00 jne d6b <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd6b>
343: 4d 85 f6 test %r14,%r14
346: 0f 84 1f 0a 00 00 je d6b <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd6b>
34c: 49 8b 06 mov (%r14),%rax
34f: 48 89 c1 mov %rax,%rcx
352: 48 31 d1 xor %rdx,%rcx
355: 49 0f af cf imul %r15,%rcx
359: 48 89 ce mov %rcx,%rsi
35c: 48 c1 ee 2f shr $0x2f,%rsi
360: 48 31 c6 xor %rax,%rsi
363: 48 31 ce xor %rcx,%rsi
366: 49 0f af f7 imul %r15,%rsi
36a: 48 89 f2 mov %rsi,%rdx
36d: 48 c1 ea 2f shr $0x2f,%rdx
371: 48 31 f2 xor %rsi,%rdx
374: 49 0f af d7 imul %r15,%rdx
378: 89 d0 mov %edx,%eax
37a: 83 e0 7f and $0x7f,%eax
37d: 49 39 14 c0 cmp %rdx,(%r8,%rax,8)
381: 0f 85 c3 06 00 00 jne a4a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xa4a>
387: 4c 89 f7 mov %r14,%rdi
38a: e8 00 00 00 00 callq 38f <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x38f>
38f: 85 c0 test %eax,%eax
391: 0f 85 2e 07 00 00 jne ac5 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xac5>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:38
mRaw->getBpp() != 2)
397: 49 8b 04 24 mov (%r12),%rax
39b: 48 89 c1 mov %rax,%rcx
39e: 4c 31 e9 xor %r13,%rcx
3a1: 49 0f af cf imul %r15,%rcx
3a5: 48 89 ce mov %rcx,%rsi
3a8: 48 c1 ee 2f shr $0x2f,%rsi
3ac: 48 31 c6 xor %rax,%rsi
3af: 48 31 ce xor %rcx,%rsi
3b2: 49 0f af f7 imul %r15,%rsi
3b6: 48 89 f2 mov %rsi,%rdx
3b9: 48 c1 ea 2f shr $0x2f,%rdx
3bd: 48 31 f2 xor %rsi,%rdx
3c0: 49 0f af d7 imul %r15,%rdx
3c4: 89 d0 mov %edx,%eax
3c6: 83 e0 7f and $0x7f,%eax
3c9: 4c 8b 05 00 00 00 00 mov 0x0(%rip),%r8 # 3d0 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x3d0>
3d0: 49 39 14 c0 cmp %rdx,(%r8,%rax,8)
3d4: 48 8b 7b 08 mov 0x8(%rbx),%rdi
3d8: 48 8b 43 10 mov 0x10(%rbx),%rax
3dc: 0f 85 89 06 00 00 jne a6b <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xa6b>
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
3e2: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
3e9: 48 ba 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%rdx
3f0: 46 e3 cb
3f3: 0f 85 a7 06 00 00 jne aa0 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xaa0>
3f9: 4c 8b 37 mov (%rdi),%r14
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:38
3fc: 41 f6 c6 07 test $0x7,%r14b
400: 0f 85 79 09 00 00 jne d7f <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd7f>
406: 4d 85 f6 test %r14,%r14
409: 0f 84 70 09 00 00 je d7f <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd7f>
40f: 49 8b 06 mov (%r14),%rax
412: 48 89 c1 mov %rax,%rcx
415: 48 31 d1 xor %rdx,%rcx
418: 49 0f af cf imul %r15,%rcx
41c: 48 89 ce mov %rcx,%rsi
41f: 48 c1 ee 2f shr $0x2f,%rsi
423: 48 31 c6 xor %rax,%rsi
426: 48 31 ce xor %rcx,%rsi
429: 49 0f af f7 imul %r15,%rsi
42d: 48 89 f2 mov %rsi,%rdx
430: 48 c1 ea 2f shr $0x2f,%rdx
434: 48 31 f2 xor %rsi,%rdx
437: 49 0f af d7 imul %r15,%rdx
43b: 89 d0 mov %edx,%eax
43d: 83 e0 7f and $0x7f,%eax
440: 49 39 14 c0 cmp %rdx,(%r8,%rax,8)
444: 0f 85 5b 06 00 00 jne aa5 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xaa5>
44a: 4c 89 f7 mov %r14,%rdi
44d: e8 00 00 00 00 callq 452 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x452>
452: 83 f8 02 cmp $0x2,%eax
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:37
if (mRaw->getCpp() != 1 || mRaw->getDataType() != TYPE_USHORT16 ||
455: 0f 85 6a 06 00 00 jne ac5 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xac5>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:41
ThrowRDE("Unexpected component count / data type");
const uint32 w = mRaw->dim.x;
45b: 49 8b 04 24 mov (%r12),%rax
45f: 48 89 c1 mov %rax,%rcx
462: 4c 31 e9 xor %r13,%rcx
465: 49 0f af cf imul %r15,%rcx
469: 48 89 ce mov %rcx,%rsi
46c: 48 c1 ee 2f shr $0x2f,%rsi
470: 48 31 c6 xor %rax,%rsi
473: 48 31 ce xor %rcx,%rsi
476: 49 0f af f7 imul %r15,%rsi
47a: 48 89 f2 mov %rsi,%rdx
47d: 48 c1 ea 2f shr $0x2f,%rdx
481: 48 31 f2 xor %rsi,%rdx
484: 49 0f af d7 imul %r15,%rdx
488: 89 d0 mov %edx,%eax
48a: 83 e0 7f and $0x7f,%eax
48d: 4c 8b 05 00 00 00 00 mov 0x0(%rip),%r8 # 494 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x494>
494: 49 39 14 c0 cmp %rdx,(%r8,%rax,8)
498: 48 8b 7b 08 mov 0x8(%rbx),%rdi
49c: 48 8b 73 18 mov 0x18(%rbx),%rsi
4a0: 4c 8b 53 10 mov 0x10(%rbx),%r10
4a4: 0f 85 41 06 00 00 jne aeb <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xaeb>
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
4aa: 41 80 ba 00 80 ff 7f cmpb $0x0,0x7fff8000(%r10)
4b1: 00
4b2: 49 b9 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%r9
4b9: 46 e3 cb
4bc: 0f 85 63 06 00 00 jne b25 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xb25>
4c2: 4c 8b 37 mov (%rdi),%r14
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:41
4c5: 41 f6 c6 07 test $0x7,%r14b
4c9: 0f 85 c4 08 00 00 jne d93 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd93>
4cf: 4d 85 f6 test %r14,%r14
4d2: 0f 84 bb 08 00 00 je d93 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd93>
4d8: 49 8b 06 mov (%r14),%rax
4db: 48 89 c2 mov %rax,%rdx
4de: 4c 31 ca xor %r9,%rdx
4e1: 49 0f af d7 imul %r15,%rdx
4e5: 48 89 d1 mov %rdx,%rcx
4e8: 48 c1 e9 2f shr $0x2f,%rcx
4ec: 48 31 c1 xor %rax,%rcx
4ef: 48 31 d1 xor %rdx,%rcx
4f2: 49 0f af cf imul %r15,%rcx
4f6: 48 89 ca mov %rcx,%rdx
4f9: 48 c1 ea 2f shr $0x2f,%rdx
4fd: 48 31 ca xor %rcx,%rdx
500: 49 0f af d7 imul %r15,%rdx
504: 89 d0 mov %edx,%eax
506: 83 e0 7f and $0x7f,%eax
509: 49 39 14 c0 cmp %rdx,(%r8,%rax,8)
50d: 0f 85 17 06 00 00 jne b2a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xb2a>
513: 49 83 c6 48 add $0x48,%r14
517: 41 f6 c6 07 test $0x7,%r14b
51b: 0f 85 43 06 00 00 jne b64 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xb64>
521: 4c 89 f0 mov %r14,%rax
524: 48 c1 e8 03 shr $0x3,%rax
528: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
52e: 84 c0 test %al,%al
530: 0f 85 32 04 00 00 jne 968 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x968>
536: 45 8b 36 mov (%r14),%r14d
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:42
const uint32 h = mRaw->dim.y;
539: 49 8b 04 24 mov (%r12),%rax
53d: 48 89 c2 mov %rax,%rdx
540: 4c 31 ea xor %r13,%rdx
543: 49 0f af d7 imul %r15,%rdx
547: 48 89 d1 mov %rdx,%rcx
54a: 48 c1 e9 2f shr $0x2f,%rcx
54e: 48 31 c1 xor %rax,%rcx
551: 48 31 d1 xor %rdx,%rcx
554: 49 0f af cf imul %r15,%rcx
558: 48 89 ca mov %rcx,%rdx
55b: 48 c1 ea 2f shr $0x2f,%rdx
55f: 48 31 ca xor %rcx,%rdx
562: 49 0f af d7 imul %r15,%rdx
566: 89 d0 mov %edx,%eax
568: 83 e0 7f and $0x7f,%eax
56b: 49 39 14 c0 cmp %rdx,(%r8,%rax,8)
56f: 0f 85 03 06 00 00 jne b78 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xb78>
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
575: 41 80 ba 00 80 ff 7f cmpb $0x0,0x7fff8000(%r10)
57c: 00
57d: 0f 85 2f 06 00 00 jne bb2 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xbb2>
583: 4c 8b 2f mov (%rdi),%r13
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:42
586: 41 f6 c5 07 test $0x7,%r13b
58a: 0f 85 17 08 00 00 jne da7 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xda7>
590: 4d 85 ed test %r13,%r13
593: 0f 84 0e 08 00 00 je da7 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xda7>
599: 49 8b 45 00 mov 0x0(%r13),%rax
59d: 48 89 c2 mov %rax,%rdx
5a0: 4c 31 ca xor %r9,%rdx
5a3: 49 0f af d7 imul %r15,%rdx
5a7: 48 89 d1 mov %rdx,%rcx
5aa: 48 c1 e9 2f shr $0x2f,%rcx
5ae: 48 31 c1 xor %rax,%rcx
5b1: 48 31 d1 xor %rdx,%rcx
5b4: 49 0f af cf imul %r15,%rcx
5b8: 48 89 ca mov %rcx,%rdx
5bb: 48 c1 ea 2f shr $0x2f,%rdx
5bf: 48 31 ca xor %rcx,%rdx
5c2: 49 0f af d7 imul %r15,%rdx
5c6: 89 d0 mov %edx,%eax
5c8: 83 e0 7f and $0x7f,%eax
5cb: 49 39 14 c0 cmp %rdx,(%r8,%rax,8)
5cf: 0f 85 e2 05 00 00 jne bb7 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xbb7>
5d5: 4d 8d 65 48 lea 0x48(%r13),%r12
5d9: 41 f6 c4 07 test $0x7,%r12b
5dd: 0f 85 0e 06 00 00 jne bf1 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xbf1>
5e3: 49 83 c5 4c add $0x4c,%r13
5e7: 41 f6 c5 03 test $0x3,%r13b
5eb: 0f 85 4e 08 00 00 jne e3f <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe3f>
5f1: 4c 89 e8 mov %r13,%rax
5f4: 48 c1 e8 03 shr $0x3,%rax
5f8: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
5fe: 84 c0 test %al,%al
600: 0f 85 7b 03 00 00 jne 981 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x981>
606: 41 8b 4d 00 mov 0x0(%r13),%ecx
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:44
if (w == 0 || h == 0 || w % 32 != 0 || w > 8000 || h > 5320)
60a: 81 f9 c8 14 00 00 cmp $0x14c8,%ecx
610: 0f 87 04 07 00 00 ja d1a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd1a>
616: 41 81 fe 40 1f 00 00 cmp $0x1f40,%r14d
61d: 0f 87 f7 06 00 00 ja d1a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd1a>
623: 44 89 f0 mov %r14d,%eax
626: 83 e0 1f and $0x1f,%eax
629: 0f 85 eb 06 00 00 jne d1a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd1a>
62f: 45 85 f6 test %r14d,%r14d
632: 0f 84 e2 06 00 00 je d1a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd1a>
638: 85 c9 test %ecx,%ecx
63a: 0f 84 da 06 00 00 je d1a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd1a>
640: 48 8b 43 20 mov 0x20(%rbx),%rax
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:48
ThrowRDE("Unexpected image dimensions found: (%u; %u)", w, h);
// 1 byte per pixel
input = input_.peekStream(mRaw->dim.x * mRaw->dim.y);
644: 66 c7 80 04 80 ff 7f movw $0x0,0x7fff8004(%rax)
64b: 00 00
64d: c6 80 06 80 ff 7f 00 movb $0x0,0x7fff8006(%rax)
654: 40 f6 c6 07 test $0x7,%sil
658: 4c 8b 63 28 mov 0x28(%rbx),%r12
65c: 49 bd 23 da e6 f9 21 movabs $0xded91821f9e6da23,%r13
663: 18 d9 de
666: 0f 85 e7 07 00 00 jne e53 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe53>
66c: 49 8b 04 24 mov (%r12),%rax
670: 48 89 c2 mov %rax,%rdx
673: 4c 31 ea xor %r13,%rdx
676: 49 0f af d7 imul %r15,%rdx
67a: 48 89 d1 mov %rdx,%rcx
67d: 48 c1 e9 2f shr $0x2f,%rcx
681: 48 31 c1 xor %rax,%rcx
684: 48 31 d1 xor %rdx,%rcx
687: 49 0f af cf imul %r15,%rcx
68b: 48 89 ca mov %rcx,%rdx
68e: 48 c1 ea 2f shr $0x2f,%rdx
692: 48 31 ca xor %rcx,%rdx
695: 49 0f af d7 imul %r15,%rdx
699: 89 d0 mov %edx,%eax
69b: 83 e0 7f and $0x7f,%eax
69e: 49 39 14 c0 cmp %rdx,(%r8,%rax,8)
6a2: 0f 85 5d 05 00 00 jne c05 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xc05>
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
6a8: 41 80 ba 00 80 ff 7f cmpb $0x0,0x7fff8000(%r10)
6af: 00
6b0: 0f 85 89 05 00 00 jne c3f <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xc3f>
6b6: 4c 8b 37 mov (%rdi),%r14
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:48
6b9: 41 f6 c6 07 test $0x7,%r14b
6bd: 0f 85 f8 06 00 00 jne dbb <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xdbb>
6c3: 4d 85 f6 test %r14,%r14
6c6: 0f 84 ef 06 00 00 je dbb <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xdbb>
6cc: 49 8b 06 mov (%r14),%rax
6cf: 48 89 c2 mov %rax,%rdx
6d2: 4c 31 ca xor %r9,%rdx
6d5: 49 0f af d7 imul %r15,%rdx
6d9: 48 89 d1 mov %rdx,%rcx
6dc: 48 c1 e9 2f shr $0x2f,%rcx
6e0: 48 31 c1 xor %rax,%rcx
6e3: 48 31 d1 xor %rdx,%rcx
6e6: 49 0f af cf imul %r15,%rcx
6ea: 48 89 ca mov %rcx,%rdx
6ed: 48 c1 ea 2f shr $0x2f,%rdx
6f1: 48 31 ca xor %rcx,%rdx
6f4: 49 0f af d7 imul %r15,%rdx
6f8: 89 d0 mov %edx,%eax
6fa: 83 e0 7f and $0x7f,%eax
6fd: 49 39 14 c0 cmp %rdx,(%r8,%rax,8)
701: 0f 85 3d 05 00 00 jne c44 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xc44>
707: 49 83 c6 48 add $0x48,%r14
70b: 41 f6 c6 07 test $0x7,%r14b
70f: 0f 85 69 05 00 00 jne c7e <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xc7e>
715: 4c 89 f0 mov %r14,%rax
718: 48 c1 e8 03 shr $0x3,%rax
71c: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
722: 84 c0 test %al,%al
724: 0f 85 70 02 00 00 jne 99a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x99a>
72a: 45 8b 36 mov (%r14),%r14d
72d: 49 8b 04 24 mov (%r12),%rax
731: 49 31 c5 xor %rax,%r13
734: 4d 0f af ef imul %r15,%r13
738: 4c 89 e9 mov %r13,%rcx
73b: 48 c1 e9 2f shr $0x2f,%rcx
73f: 48 31 c1 xor %rax,%rcx
742: 4c 31 e9 xor %r13,%rcx
745: 49 0f af cf imul %r15,%rcx
749: 48 89 ca mov %rcx,%rdx
74c: 48 c1 ea 2f shr $0x2f,%rdx
750: 48 31 ca xor %rcx,%rdx
753: 49 0f af d7 imul %r15,%rdx
757: 89 d0 mov %edx,%eax
759: 83 e0 7f and $0x7f,%eax
75c: 49 39 14 c0 cmp %rdx,(%r8,%rax,8)
760: 0f 85 2c 05 00 00 jne c92 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xc92>
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
766: 41 80 ba 00 80 ff 7f cmpb $0x0,0x7fff8000(%r10)
76d: 00
76e: 0f 85 58 05 00 00 jne ccc <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xccc>
774: 4c 8b 2f mov (%rdi),%r13
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:48
777: 41 f6 c5 07 test $0x7,%r13b
77b: 0f 85 4e 06 00 00 jne dcf <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xdcf>
781: 4d 85 ed test %r13,%r13
784: 0f 84 45 06 00 00 je dcf <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xdcf>
78a: 49 8b 45 00 mov 0x0(%r13),%rax
78e: 49 31 c1 xor %rax,%r9
791: 4d 0f af cf imul %r15,%r9
795: 4c 89 c9 mov %r9,%rcx
798: 48 c1 e9 2f shr $0x2f,%rcx
79c: 48 31 c1 xor %rax,%rcx
79f: 4c 31 c9 xor %r9,%rcx
7a2: 49 0f af cf imul %r15,%rcx
7a6: 48 89 ca mov %rcx,%rdx
7a9: 48 c1 ea 2f shr $0x2f,%rdx
7ad: 48 31 ca xor %rcx,%rdx
7b0: 49 0f af d7 imul %r15,%rdx
7b4: 89 d0 mov %edx,%eax
7b6: 83 e0 7f and $0x7f,%eax
7b9: 49 39 14 c0 cmp %rdx,(%r8,%rax,8)
7bd: 0f 85 0e 05 00 00 jne cd1 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xcd1>
7c3: 4d 8d 65 48 lea 0x48(%r13),%r12
7c7: 41 f6 c4 07 test $0x7,%r12b
7cb: 0f 85 21 05 00 00 jne cf2 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xcf2>
7d1: 49 83 c5 4c add $0x4c,%r13
7d5: 41 f6 c5 03 test $0x3,%r13b
7d9: 0f 85 8b 06 00 00 jne e6a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe6a>
7df: 4c 89 e8 mov %r13,%rax
7e2: 48 c1 e8 03 shr $0x3,%rax
7e6: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
7ec: 84 c0 test %al,%al
7ee: 0f 85 bf 01 00 00 jne 9b3 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x9b3>
7f4: 45 8b 6d 00 mov 0x0(%r13),%r13d
7f8: 44 89 e9 mov %r13d,%ecx
7fb: 41 0f af ce imul %r14d,%ecx
7ff: 0f 80 79 06 00 00 jo e7e <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe7e>
rawspeed::ByteStream::peekStream(unsigned int) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/ByteStream.h:114
Buffer ret = getSubView(pos, size_);
pos += size_;
return ret;
}
inline ByteStream peekStream(size_type size_) const {
return getSubStream(pos, size_);
805: 48 8d 7e 14 lea 0x14(%rsi),%rdi
809: 48 89 f8 mov %rdi,%rax
80c: 48 c1 e8 03 shr $0x3,%rax
810: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
816: 84 c0 test %al,%al
818: 0f 85 ae 01 00 00 jne 9cc <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x9cc>
81e: 48 8b 43 38 mov 0x38(%rbx),%rax
822: 4c 8d 70 20 lea 0x20(%rax),%r14
826: 8b 56 14 mov 0x14(%rsi),%edx
829: 4c 89 f7 mov %r14,%rdi
82c: 4c 8b 63 28 mov 0x28(%rbx),%r12
830: 4c 8b 6b 20 mov 0x20(%rbx),%r13
834: e8 00 00 00 00 callq 839 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x839>
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:48
839: 49 8b 04 24 mov (%r12),%rax
83d: 48 b9 ec 11 a0 c3 09 movabs $0x9b4d5109c3a011ec,%rcx
844: 51 4d 9b
847: 48 31 c1 xor %rax,%rcx
84a: 49 0f af cf imul %r15,%rcx
84e: 48 89 ce mov %rcx,%rsi
851: 48 c1 ee 2f shr $0x2f,%rsi
855: 48 31 c6 xor %rax,%rsi
858: 48 31 ce xor %rcx,%rsi
85b: 49 0f af f7 imul %r15,%rsi
85f: 48 89 f2 mov %rsi,%rdx
862: 48 c1 ea 2f shr $0x2f,%rdx
866: 48 31 f2 xor %rsi,%rdx
869: 49 0f af d7 imul %r15,%rdx
86d: 89 d0 mov %edx,%eax
86f: 83 e0 7f and $0x7f,%eax
872: 48 8b 0d 00 00 00 00 mov 0x0(%rip),%rcx # 879 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x879>
879: 48 39 14 c1 cmp %rdx,(%rcx,%rax,8)
87d: 0f 85 83 04 00 00 jne d06 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd06>
883: 48 8b 7b 40 mov 0x40(%rbx),%rdi
887: 4c 89 f6 mov %r14,%rsi
88a: e8 00 00 00 00 callq 88f <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x88f>
88f: 4c 89 f7 mov %r14,%rdi
892: e8 00 00 00 00 callq 897 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x897>
897: 66 41 c7 85 04 80 ff movw $0xf8f8,0x7fff8004(%r13)
89e: 7f f8 f8
8a1: 41 c6 85 06 80 ff 7f movb $0xf8,0x7fff8006(%r13)
8a8: f8
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:49
}
8a9: 48 8b 43 38 mov 0x38(%rbx),%rax
8ad: 48 c7 00 0e 36 e0 45 movq $0x45e0360e,(%rax)
8b4: 48 8b 4b 30 mov 0x30(%rbx),%rcx
8b8: 48 85 c9 test %rcx,%rcx
8bb: 74 35 je 8f2 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x8f2>
8bd: 48 b8 f5 f5 f5 f5 f5 movabs $0xf5f5f5f5f5f5f5f5,%rax
8c4: f5 f5 f5
8c7: 49 89 85 00 80 ff 7f mov %rax,0x7fff8000(%r13)
8ce: 49 89 85 08 80 ff 7f mov %rax,0x7fff8008(%r13)
8d5: 48 8b 41 78 mov 0x78(%rcx),%rax
8d9: c6 00 00 movb $0x0,(%rax)
8dc: eb 2a jmp 908 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x908>
8de: 45 31 ff xor %r15d,%r15d
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:36
: AbstractParallelizedDecompressor(img) {
8e1: 4c 89 f9 mov %r15,%rcx
8e4: 4d 85 ff test %r15,%r15
8e7: 0f 85 6b f7 ff ff jne 58 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x58>
8ed: e9 58 f7 ff ff jmpq 4a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x4a>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:49
}
8f2: 49 c7 85 00 80 ff 7f movq $0x0,0x7fff8000(%r13)
8f9: 00 00 00 00
8fd: 41 c7 85 08 80 ff 7f movl $0x0,0x7fff8008(%r13)
904: 00 00 00 00
908: 48 8d 65 d8 lea -0x28(%rbp),%rsp
90c: 5b pop %rbx
90d: 41 5c pop %r12
90f: 41 5d pop %r13
911: 41 5e pop %r14
913: 41 5f pop %r15
915: 5d pop %rbp
916: c3 retq
Buffer():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/Buffer.h:64
size_type size = 0;
917: 89 f9 mov %edi,%ecx
919: 83 e1 07 and $0x7,%ecx
91c: 83 c1 03 add $0x3,%ecx
91f: 38 c1 cmp %al,%cl
921: 0f 8c 48 f8 ff ff jl 16f <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x16f>
927: e8 00 00 00 00 callq 92c <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x92c>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/Buffer.h:65
bool isOwner = false;
92c: 89 f9 mov %edi,%ecx
92e: 83 e1 07 and $0x7,%ecx
931: 38 c1 cmp %al,%cl
933: 0f 8c 59 f8 ff ff jl 192 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x192>
939: e8 00 00 00 00 callq 93e <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x93e>
DataBuffer():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/Buffer.h:185
Endianness endianness = Endianness::little;
93e: 89 f9 mov %edi,%ecx
940: 83 e1 07 and $0x7,%ecx
943: 83 c1 03 add $0x3,%ecx
946: 38 c1 cmp %al,%cl
948: 0f 8c 64 f8 ff ff jl 1b2 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x1b2>
94e: e8 00 00 00 00 callq 953 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x953>
ByteStream():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/ByteStream.h:39
size_type pos = 0; // position of stream in bytes (this is next byte to deliver)
953: 89 f9 mov %edi,%ecx
955: 83 e1 07 and $0x7,%ecx
958: 83 c1 03 add $0x3,%ecx
95b: 38 c1 cmp %al,%cl
95d: 0f 8c 76 f8 ff ff jl 1d9 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x1d9>
963: e8 00 00 00 00 callq 968 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x968>
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:41
const uint32 w = mRaw->dim.x;
968: 44 89 f1 mov %r14d,%ecx
96b: 83 e1 07 and $0x7,%ecx
96e: 83 c1 03 add $0x3,%ecx
971: 38 c1 cmp %al,%cl
973: 0f 8c bd fb ff ff jl 536 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x536>
979: 4c 89 f7 mov %r14,%rdi
97c: e8 00 00 00 00 callq 981 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x981>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:42
const uint32 h = mRaw->dim.y;
981: 44 89 e9 mov %r13d,%ecx
984: 83 e1 07 and $0x7,%ecx
987: 83 c1 03 add $0x3,%ecx
98a: 38 c1 cmp %al,%cl
98c: 0f 8c 74 fc ff ff jl 606 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x606>
992: 4c 89 ef mov %r13,%rdi
995: e8 00 00 00 00 callq 99a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x99a>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:48
input = input_.peekStream(mRaw->dim.x * mRaw->dim.y);
99a: 44 89 f1 mov %r14d,%ecx
99d: 83 e1 07 and $0x7,%ecx
9a0: 83 c1 03 add $0x3,%ecx
9a3: 38 c1 cmp %al,%cl
9a5: 0f 8c 7f fd ff ff jl 72a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x72a>
9ab: 4c 89 f7 mov %r14,%rdi
9ae: e8 00 00 00 00 callq 9b3 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x9b3>
9b3: 44 89 e9 mov %r13d,%ecx
9b6: 83 e1 07 and $0x7,%ecx
9b9: 83 c1 03 add $0x3,%ecx
9bc: 38 c1 cmp %al,%cl
9be: 0f 8c 30 fe ff ff jl 7f4 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x7f4>
9c4: 4c 89 ef mov %r13,%rdi
9c7: e8 00 00 00 00 callq 9cc <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x9cc>
rawspeed::ByteStream::peekStream(unsigned int) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/ByteStream.h:114
return getSubStream(pos, size_);
9cc: 89 fa mov %edi,%edx
9ce: 83 e2 07 and $0x7,%edx
9d1: 83 c2 03 add $0x3,%edx
9d4: 38 c2 cmp %al,%dl
9d6: 0f 8c 42 fe ff ff jl 81e <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x81e>
9dc: e8 00 00 00 00 callq 9e1 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x9e1>
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:37
if (mRaw->getCpp() != 1 || mRaw->getDataType() != TYPE_USHORT16 ||
9e1: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 9e8 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x9e8>
9e8: 4c 89 e6 mov %r12,%rsi
9eb: e8 00 00 00 00 callq 9f0 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x9f0>
9f0: 4c 8b 05 00 00 00 00 mov 0x0(%rip),%r8 # 9f7 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x9f7>
9f7: e9 3a f8 ff ff jmpq 236 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x236>
9fc: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # a03 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xa03>
a03: 4c 89 f6 mov %r14,%rsi
a06: e8 00 00 00 00 callq a0b <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xa0b>
a0b: e9 a1 f8 ff ff jmpq 2b1 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x2b1>
a10: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # a17 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xa17>
a17: 4c 89 e6 mov %r12,%rsi
a1a: e8 00 00 00 00 callq a1f <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xa1f>
a1f: 48 8b 43 10 mov 0x10(%rbx),%rax
a23: 4c 8b 05 00 00 00 00 mov 0x0(%rip),%r8 # a2a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xa2a>
a2a: 48 8b 7b 08 mov 0x8(%rbx),%rdi
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
a2e: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
a35: 48 ba 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%rdx
a3c: 46 e3 cb
a3f: 0f 84 f1 f8 ff ff je 336 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x336>
a45: e8 00 00 00 00 callq a4a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xa4a>
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:37
a4a: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # a51 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xa51>
a51: 4c 89 f6 mov %r14,%rsi
a54: e8 00 00 00 00 callq a59 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xa59>
a59: 4c 89 f7 mov %r14,%rdi
a5c: e8 00 00 00 00 callq a61 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xa61>
a61: 85 c0 test %eax,%eax
a63: 0f 84 2e f9 ff ff je 397 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x397>
a69: eb 5a jmp ac5 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xac5>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:38
mRaw->getBpp() != 2)
a6b: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # a72 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xa72>
a72: 4c 89 e6 mov %r12,%rsi
a75: e8 00 00 00 00 callq a7a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xa7a>
a7a: 48 8b 43 10 mov 0x10(%rbx),%rax
a7e: 4c 8b 05 00 00 00 00 mov 0x0(%rip),%r8 # a85 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xa85>
a85: 48 8b 7b 08 mov 0x8(%rbx),%rdi
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
a89: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
a90: 48 ba 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%rdx
a97: 46 e3 cb
a9a: 0f 84 59 f9 ff ff je 3f9 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x3f9>
aa0: e8 00 00 00 00 callq aa5 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xaa5>
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:38
aa5: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # aac <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xaac>
aac: 4c 89 f6 mov %r14,%rsi
aaf: e8 00 00 00 00 callq ab4 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xab4>
ab4: 4c 89 f7 mov %r14,%rdi
ab7: e8 00 00 00 00 callq abc <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xabc>
abc: 83 f8 02 cmp $0x2,%eax
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:37
if (mRaw->getCpp() != 1 || mRaw->getDataType() != TYPE_USHORT16 ||
abf: 0f 84 96 f9 ff ff je 45b <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x45b>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:39
ThrowRDE("Unexpected component count / data type");
ac5: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # acc <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xacc>
acc: 48 8d 35 00 00 00 00 lea 0x0(%rip),%rsi # ad3 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xad3>
ad3: 31 c0 xor %eax,%eax
ad5: e8 00 00 00 00 callq ada <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xada>
ada: e8 00 00 00 00 callq adf <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xadf>
adf: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # ae6 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xae6>
ae6: e8 00 00 00 00 callq aeb <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xaeb>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:41
const uint32 w = mRaw->dim.x;
aeb: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # af2 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xaf2>
af2: 4c 89 e6 mov %r12,%rsi
af5: e8 00 00 00 00 callq afa <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xafa>
afa: 4c 8b 53 10 mov 0x10(%rbx),%r10
afe: 4c 8b 05 00 00 00 00 mov 0x0(%rip),%r8 # b05 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xb05>
b05: 48 8b 73 18 mov 0x18(%rbx),%rsi
b09: 48 8b 7b 08 mov 0x8(%rbx),%rdi
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
b0d: 41 80 ba 00 80 ff 7f cmpb $0x0,0x7fff8000(%r10)
b14: 00
b15: 49 b9 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%r9
b1c: 46 e3 cb
b1f: 0f 84 9d f9 ff ff je 4c2 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x4c2>
b25: e8 00 00 00 00 callq b2a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xb2a>
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:41
b2a: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # b31 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xb31>
b31: 4c 89 f6 mov %r14,%rsi
b34: e8 00 00 00 00 callq b39 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xb39>
b39: 4c 8b 53 10 mov 0x10(%rbx),%r10
b3d: 49 b9 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%r9
b44: 46 e3 cb
b47: 4c 8b 05 00 00 00 00 mov 0x0(%rip),%r8 # b4e <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xb4e>
b4e: 48 8b 73 18 mov 0x18(%rbx),%rsi
b52: 48 8b 7b 08 mov 0x8(%rbx),%rdi
b56: 49 83 c6 48 add $0x48,%r14
b5a: 41 f6 c6 07 test $0x7,%r14b
b5e: 0f 84 bd f9 ff ff je 521 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x521>
b64: e8 00 00 00 00 callq b69 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xb69>
b69: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # b70 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xb70>
b70: 4c 89 f6 mov %r14,%rsi
b73: e8 00 00 00 00 callq b78 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xb78>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:42
const uint32 h = mRaw->dim.y;
b78: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # b7f <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xb7f>
b7f: 4c 89 e6 mov %r12,%rsi
b82: e8 00 00 00 00 callq b87 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xb87>
b87: 4c 8b 53 10 mov 0x10(%rbx),%r10
b8b: 49 b9 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%r9
b92: 46 e3 cb
b95: 4c 8b 05 00 00 00 00 mov 0x0(%rip),%r8 # b9c <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xb9c>
b9c: 48 8b 73 18 mov 0x18(%rbx),%rsi
ba0: 48 8b 7b 08 mov 0x8(%rbx),%rdi
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
ba4: 41 80 ba 00 80 ff 7f cmpb $0x0,0x7fff8000(%r10)
bab: 00
bac: 0f 84 d1 f9 ff ff je 583 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x583>
bb2: e8 00 00 00 00 callq bb7 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xbb7>
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:42
bb7: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # bbe <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xbbe>
bbe: 4c 89 ee mov %r13,%rsi
bc1: e8 00 00 00 00 callq bc6 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xbc6>
bc6: 4c 8b 53 10 mov 0x10(%rbx),%r10
bca: 49 b9 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%r9
bd1: 46 e3 cb
bd4: 4c 8b 05 00 00 00 00 mov 0x0(%rip),%r8 # bdb <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xbdb>
bdb: 48 8b 73 18 mov 0x18(%rbx),%rsi
bdf: 48 8b 7b 08 mov 0x8(%rbx),%rdi
be3: 4d 8d 65 48 lea 0x48(%r13),%r12
be7: 41 f6 c4 07 test $0x7,%r12b
beb: 0f 84 f2 f9 ff ff je 5e3 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x5e3>
bf1: e8 00 00 00 00 callq bf6 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xbf6>
bf6: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # bfd <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xbfd>
bfd: 4c 89 e6 mov %r12,%rsi
c00: e8 00 00 00 00 callq c05 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xc05>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:48
input = input_.peekStream(mRaw->dim.x * mRaw->dim.y);
c05: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # c0c <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xc0c>
c0c: 4c 89 e6 mov %r12,%rsi
c0f: e8 00 00 00 00 callq c14 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xc14>
c14: 4c 8b 53 10 mov 0x10(%rbx),%r10
c18: 49 b9 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%r9
c1f: 46 e3 cb
c22: 4c 8b 05 00 00 00 00 mov 0x0(%rip),%r8 # c29 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xc29>
c29: 48 8b 73 18 mov 0x18(%rbx),%rsi
c2d: 48 8b 7b 08 mov 0x8(%rbx),%rdi
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
c31: 41 80 ba 00 80 ff 7f cmpb $0x0,0x7fff8000(%r10)
c38: 00
c39: 0f 84 77 fa ff ff je 6b6 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x6b6>
c3f: e8 00 00 00 00 callq c44 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xc44>
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:48
c44: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # c4b <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xc4b>
c4b: 4c 89 f6 mov %r14,%rsi
c4e: e8 00 00 00 00 callq c53 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xc53>
c53: 4c 8b 53 10 mov 0x10(%rbx),%r10
c57: 49 b9 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%r9
c5e: 46 e3 cb
c61: 4c 8b 05 00 00 00 00 mov 0x0(%rip),%r8 # c68 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xc68>
c68: 48 8b 73 18 mov 0x18(%rbx),%rsi
c6c: 48 8b 7b 08 mov 0x8(%rbx),%rdi
c70: 49 83 c6 48 add $0x48,%r14
c74: 41 f6 c6 07 test $0x7,%r14b
c78: 0f 84 97 fa ff ff je 715 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x715>
c7e: e8 00 00 00 00 callq c83 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xc83>
c83: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # c8a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xc8a>
c8a: 4c 89 f6 mov %r14,%rsi
c8d: e8 00 00 00 00 callq c92 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xc92>
c92: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # c99 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xc99>
c99: 4c 89 e6 mov %r12,%rsi
c9c: e8 00 00 00 00 callq ca1 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xca1>
ca1: 4c 8b 53 10 mov 0x10(%rbx),%r10
ca5: 49 b9 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%r9
cac: 46 e3 cb
caf: 4c 8b 05 00 00 00 00 mov 0x0(%rip),%r8 # cb6 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xcb6>
cb6: 48 8b 73 18 mov 0x18(%rbx),%rsi
cba: 48 8b 7b 08 mov 0x8(%rbx),%rdi
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
cbe: 41 80 ba 00 80 ff 7f cmpb $0x0,0x7fff8000(%r10)
cc5: 00
cc6: 0f 84 a8 fa ff ff je 774 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x774>
ccc: e8 00 00 00 00 callq cd1 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xcd1>
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:48
cd1: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # cd8 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xcd8>
cd8: 4c 89 ee mov %r13,%rsi
cdb: e8 00 00 00 00 callq ce0 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xce0>
ce0: 48 8b 73 18 mov 0x18(%rbx),%rsi
ce4: 4d 8d 65 48 lea 0x48(%r13),%r12
ce8: 41 f6 c4 07 test $0x7,%r12b
cec: 0f 84 df fa ff ff je 7d1 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x7d1>
cf2: e8 00 00 00 00 callq cf7 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xcf7>
cf7: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # cfe <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xcfe>
cfe: 4c 89 e6 mov %r12,%rsi
d01: e8 00 00 00 00 callq d06 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd06>
d06: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # d0d <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd0d>
d0d: 4c 89 e6 mov %r12,%rsi
d10: e8 00 00 00 00 callq d15 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd15>
d15: e9 69 fb ff ff jmpq 883 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0x883>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:45
ThrowRDE("Unexpected image dimensions found: (%u; %u)", w, h);
d1a: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # d21 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd21>
d21: 48 8d 35 00 00 00 00 lea 0x0(%rip),%rsi # d28 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd28>
d28: 31 c0 xor %eax,%eax
d2a: 44 89 f2 mov %r14d,%edx
d2d: e8 00 00 00 00 callq d32 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd32>
d32: e8 00 00 00 00 callq d37 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd37>
d37: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # d3e <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd3e>
d3e: e8 00 00 00 00 callq d43 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd43>
d43: e8 00 00 00 00 callq d48 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd48>
d48: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # d4f <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd4f>
d4f: 4c 89 e6 mov %r12,%rsi
d52: e8 00 00 00 00 callq d57 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd57>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:37
if (mRaw->getCpp() != 1 || mRaw->getDataType() != TYPE_USHORT16 ||
d57: e8 00 00 00 00 callq d5c <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd5c>
d5c: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # d63 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd63>
d63: 4c 89 f6 mov %r14,%rsi
d66: e8 00 00 00 00 callq d6b <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd6b>
d6b: e8 00 00 00 00 callq d70 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd70>
d70: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # d77 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd77>
d77: 4c 89 f6 mov %r14,%rsi
d7a: e8 00 00 00 00 callq d7f <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd7f>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:38
mRaw->getBpp() != 2)
d7f: e8 00 00 00 00 callq d84 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd84>
d84: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # d8b <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd8b>
d8b: 4c 89 f6 mov %r14,%rsi
d8e: e8 00 00 00 00 callq d93 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd93>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:41
const uint32 w = mRaw->dim.x;
d93: e8 00 00 00 00 callq d98 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd98>
d98: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # d9f <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xd9f>
d9f: 4c 89 f6 mov %r14,%rsi
da2: e8 00 00 00 00 callq da7 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xda7>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:42
const uint32 h = mRaw->dim.y;
da7: e8 00 00 00 00 callq dac <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xdac>
dac: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # db3 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xdb3>
db3: 4c 89 ee mov %r13,%rsi
db6: e8 00 00 00 00 callq dbb <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xdbb>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:48
input = input_.peekStream(mRaw->dim.x * mRaw->dim.y);
dbb: e8 00 00 00 00 callq dc0 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xdc0>
dc0: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # dc7 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xdc7>
dc7: 4c 89 f6 mov %r14,%rsi
dca: e8 00 00 00 00 callq dcf <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xdcf>
dcf: e8 00 00 00 00 callq dd4 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xdd4>
dd4: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # ddb <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xddb>
ddb: 4c 89 ee mov %r13,%rsi
dde: e8 00 00 00 00 callq de3 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xde3>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:36
: AbstractParallelizedDecompressor(img) {
de3: e8 00 00 00 00 callq de8 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xde8>
de8: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # def <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xdef>
def: 4c 89 f6 mov %r14,%rsi
df2: e8 00 00 00 00 callq df7 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xdf7>
AbstractParallelizedDecompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/AbstractParallelizedDecompressor.h:45
df7: 4c 89 e7 mov %r12,%rdi
dfa: e8 00 00 00 00 callq dff <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xdff>
dff: 49 89 c6 mov %rax,%r14
e02: e8 00 00 00 00 callq e07 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe07>
e07: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # e0e <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe0e>
e0e: 4c 89 f6 mov %r14,%rsi
e11: e8 00 00 00 00 callq e16 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe16>
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:36
e16: 4c 89 e7 mov %r12,%rdi
e19: e8 00 00 00 00 callq e1e <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe1e>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:34
SonyArw2Decompressor::SonyArw2Decompressor(const RawImage& img,
e1e: e8 00 00 00 00 callq e23 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe23>
e23: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # e2a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe2a>
e2a: 4c 89 f6 mov %r14,%rsi
e2d: e8 00 00 00 00 callq e32 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe32>
Buffer():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/Buffer.h:63
const uchar8* data = nullptr;
e32: 4c 89 f7 mov %r14,%rdi
e35: e8 00 00 00 00 callq e3a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe3a>
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
e3a: e8 00 00 00 00 callq e3f <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe3f>
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:42
const uint32 h = mRaw->dim.y;
e3f: e8 00 00 00 00 callq e44 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe44>
e44: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # e4b <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe4b>
e4b: 4c 89 ee mov %r13,%rsi
e4e: e8 00 00 00 00 callq e53 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe53>
e53: 49 89 f6 mov %rsi,%r14
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:48
input = input_.peekStream(mRaw->dim.x * mRaw->dim.y);
e56: e8 00 00 00 00 callq e5b <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe5b>
e5b: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # e62 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe62>
e62: 4c 89 f6 mov %r14,%rsi
e65: e8 00 00 00 00 callq e6a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe6a>
e6a: e8 00 00 00 00 callq e6f <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe6f>
e6f: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # e76 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe76>
e76: 4c 89 ee mov %r13,%rsi
e79: e8 00 00 00 00 callq e7e <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe7e>
e7e: e8 00 00 00 00 callq e83 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe83>
e83: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # e8a <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe8a>
e8a: 4c 89 f6 mov %r14,%rsi
e8d: 4c 89 ea mov %r13,%rdx
e90: e8 00 00 00 00 callq e95 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xe95>
e95: 49 89 c6 mov %rax,%r14
e98: eb 1a jmp eb4 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xeb4>
e9a: 49 89 c6 mov %rax,%r14
e9d: eb 15 jmp eb4 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xeb4>
e9f: 49 89 c6 mov %rax,%r14
ea2: 66 41 c7 85 04 80 ff movw $0xf8f8,0x7fff8004(%r13)
ea9: 7f f8 f8
eac: 41 c6 85 06 80 ff 7f movb $0xf8,0x7fff8006(%r13)
eb3: f8
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:49
}
eb4: 48 8b 7b 40 mov 0x40(%rbx),%rdi
eb8: e8 00 00 00 00 callq ebd <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xebd>
~AbstractParallelizedDecompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/AbstractParallelizedDecompressor.h:46
virtual ~AbstractParallelizedDecompressor() = default;
ebd: 48 8b 43 48 mov 0x48(%rbx),%rax
ec1: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
ec8: 74 09 je ed3 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xed3>
eca: 48 8b 7b 28 mov 0x28(%rbx),%rdi
ece: e8 00 00 00 00 callq ed3 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xed3>
ed3: 48 8b 43 28 mov 0x28(%rbx),%rax
ed7: 48 8b 4b 50 mov 0x50(%rbx),%rcx
edb: 48 89 08 mov %rcx,(%rax)
ede: 48 8b 7b 08 mov 0x8(%rbx),%rdi
ee2: e8 00 00 00 00 callq ee7 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xee7>
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:49
ee7: 48 8b 43 38 mov 0x38(%rbx),%rax
eeb: 48 c7 00 0e 36 e0 45 movq $0x45e0360e,(%rax)
ef2: 48 83 7b 30 00 cmpq $0x0,0x30(%rbx)
ef7: 74 2f je f28 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xf28>
ef9: 48 b8 f5 f5 f5 f5 f5 movabs $0xf5f5f5f5f5f5f5f5,%rax
f00: f5 f5 f5
f03: 48 8b 4b 20 mov 0x20(%rbx),%rcx
f07: 48 89 81 00 80 ff 7f mov %rax,0x7fff8000(%rcx)
f0e: 48 89 81 08 80 ff 7f mov %rax,0x7fff8008(%rcx)
f15: 48 8b 43 30 mov 0x30(%rbx),%rax
f19: 48 8b 40 78 mov 0x78(%rax),%rax
f1d: c6 00 00 movb $0x0,(%rax)
f20: 4c 89 f7 mov %r14,%rdi
f23: e8 00 00 00 00 callq f28 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xf28>
f28: 48 8b 43 20 mov 0x20(%rbx),%rax
f2c: 48 c7 80 00 80 ff 7f movq $0x0,0x7fff8000(%rax)
f33: 00 00 00 00
f37: c7 80 08 80 ff 7f 00 movl $0x0,0x7fff8008(%rax)
f3e: 00 00 00
f41: 4c 89 f7 mov %r14,%rdi
f44: e8 00 00 00 00 callq f49 <rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)+0xf49>
rawspeed::SonyArw2Decompressor::SonyArw2Decompressor(rawspeed::RawImage const&, rawspeed::ByteStream const&)():
f49: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
0000000000000f50 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const>:
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:52
void SonyArw2Decompressor::decompressThreaded(
const RawDecompressorThread* t) const {
f50: 55 push %rbp
f51: 48 89 e5 mov %rsp,%rbp
f54: 41 57 push %r15
f56: 41 56 push %r14
f58: 41 55 push %r13
f5a: 41 54 push %r12
f5c: 53 push %rbx
f5d: 48 83 e4 e0 and $0xffffffffffffffe0,%rsp
f61: 48 81 ec 20 01 00 00 sub $0x120,%rsp
f68: 48 89 e3 mov %rsp,%rbx
f6b: 48 89 73 58 mov %rsi,0x58(%rbx)
f6f: 48 8b 05 00 00 00 00 mov 0x0(%rip),%rax # f76 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x26>
f76: 83 38 00 cmpl $0x0,(%rax)
f79: 48 89 7b 18 mov %rdi,0x18(%rbx)
f7d: 0f 84 ab 0c 00 00 je 1c2e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xcde>
f83: bf 80 00 00 00 mov $0x80,%edi
f88: e8 00 00 00 00 callq f8d <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x3d>
f8d: 48 8b 7b 18 mov 0x18(%rbx),%rdi
f91: 49 89 c7 mov %rax,%r15
f94: 4d 89 fc mov %r15,%r12
f97: 4d 85 ff test %r15,%r15
f9a: 75 0e jne faa <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x5a>
f9c: 49 89 e4 mov %rsp,%r12
f9f: 49 83 c4 80 add $0xffffffffffffff80,%r12
fa3: 49 83 e4 e0 and $0xffffffffffffffe0,%r12
fa7: 4c 89 e4 mov %r12,%rsp
faa: 4c 89 a3 f8 00 00 00 mov %r12,0xf8(%rbx)
fb1: 49 c7 04 24 b3 8a b5 movq $0x41b58ab3,(%r12)
fb8: 41
fb9: 48 8d 05 00 00 00 00 lea 0x0(%rip),%rax # fc0 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x70>
fc0: 49 89 44 24 08 mov %rax,0x8(%r12)
fc5: 48 8b 05 00 00 00 00 mov 0x0(%rip),%rax # fcc <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x7c>
fcc: 49 89 44 24 10 mov %rax,0x10(%r12)
fd1: 4d 89 e5 mov %r12,%r13
fd4: 49 c1 ed 03 shr $0x3,%r13
fd8: 48 b8 f1 f1 f1 f1 f8 movabs $0xf8f8f8f8f1f1f1f1,%rax
fdf: f8 f8 f8
fe2: 49 89 85 00 80 ff 7f mov %rax,0x7fff8000(%r13)
fe9: 48 b8 f8 f2 f2 f2 f2 movabs $0xf3f8f2f2f2f2f2f8,%rax
ff0: f2 f8 f3
ff3: 49 89 85 08 80 ff 7f mov %rax,0x7fff8008(%r13)
ffa: 48 85 ff test %rdi,%rdi
ffd: 0f 84 e8 10 00 00 je 20eb <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x119b>
1003: 89 f8 mov %edi,%eax
1005: 83 e0 07 and $0x7,%eax
1008: 48 85 c0 test %rax,%rax
100b: 0f 85 da 10 00 00 jne 20eb <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x119b>
1011: 48 ba 23 da e6 f9 21 movabs $0xded91821f9e6da23,%rdx
1018: 18 d9 de
101b: 49 b8 69 2d 38 eb 08 movabs $0x9ddfea08eb382d69,%r8
1022: ea df 9d
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:53
uchar8* data = mRaw->getData();
1025: 48 8b 07 mov (%rdi),%rax
1028: 48 89 c1 mov %rax,%rcx
102b: 48 31 d1 xor %rdx,%rcx
102e: 49 0f af c8 imul %r8,%rcx
1032: 48 89 ce mov %rcx,%rsi
1035: 48 c1 ee 2f shr $0x2f,%rsi
1039: 48 31 c6 xor %rax,%rsi
103c: 48 31 ce xor %rcx,%rsi
103f: 49 0f af f0 imul %r8,%rsi
1043: 48 89 f2 mov %rsi,%rdx
1046: 48 c1 ea 2f shr $0x2f,%rdx
104a: 48 31 f2 xor %rsi,%rdx
104d: 49 0f af d0 imul %r8,%rdx
1051: 89 d0 mov %edx,%eax
1053: 83 e0 7f and $0x7f,%eax
1056: 4c 8b 0d 00 00 00 00 mov 0x0(%rip),%r9 # 105d <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10d>
105d: 49 39 14 c1 cmp %rdx,(%r9,%rax,8)
1061: 0f 85 a3 0c 00 00 jne 1d0a <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xdba>
1067: 4c 8d 77 08 lea 0x8(%rdi),%r14
106b: 41 f6 c6 07 test $0x7,%r14b
106f: 0f 85 c8 0c 00 00 jne 1d3d <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xded>
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
1075: 4c 89 f0 mov %r14,%rax
1078: 48 c1 e8 03 shr $0x3,%rax
107c: 48 89 43 50 mov %rax,0x50(%rbx)
1080: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
1087: 0f 85 04 11 00 00 jne 2191 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1241>
108d: 4c 89 63 28 mov %r12,0x28(%rbx)
1091: 4c 89 7b 38 mov %r15,0x38(%rbx)
1095: 4c 89 b3 c8 00 00 00 mov %r14,0xc8(%rbx)
109c: 4d 8b 36 mov (%r14),%r14
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:53
109f: 41 f6 c6 07 test $0x7,%r14b
10a3: 0f 85 59 10 00 00 jne 2102 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11b2>
10a9: 4d 85 f6 test %r14,%r14
10ac: 0f 84 50 10 00 00 je 2102 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11b2>
10b2: 48 ba 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%rdx
10b9: 46 e3 cb
10bc: 49 8b 06 mov (%r14),%rax
10bf: 48 89 c1 mov %rax,%rcx
10c2: 48 31 d1 xor %rdx,%rcx
10c5: 49 0f af c8 imul %r8,%rcx
10c9: 48 89 ce mov %rcx,%rsi
10cc: 48 c1 ee 2f shr $0x2f,%rsi
10d0: 48 31 c6 xor %rax,%rsi
10d3: 48 31 ce xor %rcx,%rsi
10d6: 49 0f af f0 imul %r8,%rsi
10da: 48 89 f2 mov %rsi,%rdx
10dd: 48 c1 ea 2f shr $0x2f,%rdx
10e1: 48 31 f2 xor %rsi,%rdx
10e4: 49 0f af d0 imul %r8,%rdx
10e8: 89 d0 mov %edx,%eax
10ea: 83 e0 7f and $0x7f,%eax
10ed: 49 39 14 c1 cmp %rdx,(%r9,%rax,8)
10f1: 4d 89 c4 mov %r8,%r12
10f4: 4d 89 cf mov %r9,%r15
10f7: 0f 85 54 0c 00 00 jne 1d51 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xe01>
10fd: 4c 89 f7 mov %r14,%rdi
1100: e8 00 00 00 00 callq 1105 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1b5>
1105: 48 89 83 b0 00 00 00 mov %rax,0xb0(%rbx)
110c: 4c 8b 43 18 mov 0x18(%rbx),%r8
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:54
uint32 pitch = mRaw->pitch;
1110: 49 8b 00 mov (%r8),%rax
1113: 48 89 c1 mov %rax,%rcx
1116: 48 ba 23 da e6 f9 21 movabs $0xded91821f9e6da23,%rdx
111d: 18 d9 de
1120: 48 31 d1 xor %rdx,%rcx
1123: 49 0f af cc imul %r12,%rcx
1127: 48 89 ce mov %rcx,%rsi
112a: 48 c1 ee 2f shr $0x2f,%rsi
112e: 48 31 c6 xor %rax,%rsi
1131: 48 31 ce xor %rcx,%rsi
1134: 49 0f af f4 imul %r12,%rsi
1138: 48 89 f2 mov %rsi,%rdx
113b: 48 c1 ea 2f shr $0x2f,%rdx
113f: 48 31 f2 xor %rsi,%rdx
1142: 49 0f af d4 imul %r12,%rdx
1146: 89 d0 mov %edx,%eax
1148: 83 e0 7f and $0x7f,%eax
114b: 49 39 14 c7 cmp %rdx,(%r15,%rax,8)
114f: 4c 89 e7 mov %r12,%rdi
1152: 4d 89 f9 mov %r15,%r9
1155: 0f 85 0a 0c 00 00 jne 1d65 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xe15>
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
115b: 48 8b 43 50 mov 0x50(%rbx),%rax
115f: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
1166: 4c 8b a3 c8 00 00 00 mov 0xc8(%rbx),%r12
116d: 0f 85 2f 0c 00 00 jne 1da2 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xe52>
1173: 4d 8b 34 24 mov (%r12),%r14
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:54
1177: 41 f6 c6 07 test $0x7,%r14b
117b: 0f 85 95 0f 00 00 jne 2116 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11c6>
1181: 4d 85 f6 test %r14,%r14
1184: 0f 84 8c 0f 00 00 je 2116 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11c6>
118a: 49 8b 06 mov (%r14),%rax
118d: 48 89 c1 mov %rax,%rcx
1190: 48 ba 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%rdx
1197: 46 e3 cb
119a: 48 31 d1 xor %rdx,%rcx
119d: 48 0f af cf imul %rdi,%rcx
11a1: 48 89 ce mov %rcx,%rsi
11a4: 48 c1 ee 2f shr $0x2f,%rsi
11a8: 48 31 c6 xor %rax,%rsi
11ab: 48 31 ce xor %rcx,%rsi
11ae: 48 0f af f7 imul %rdi,%rsi
11b2: 48 89 f2 mov %rsi,%rdx
11b5: 48 c1 ea 2f shr $0x2f,%rdx
11b9: 48 31 f2 xor %rsi,%rdx
11bc: 48 0f af d7 imul %rdi,%rdx
11c0: 89 d0 mov %edx,%eax
11c2: 83 e0 7f and $0x7f,%eax
11c5: 49 39 14 c1 cmp %rdx,(%r9,%rax,8)
11c9: 0f 85 db 0b 00 00 jne 1daa <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xe5a>
11cf: 49 83 c6 50 add $0x50,%r14
11d3: 41 f6 c6 07 test $0x7,%r14b
11d7: 0f 85 ff 0b 00 00 jne 1ddc <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xe8c>
11dd: 4c 89 f0 mov %r14,%rax
11e0: 48 c1 e8 03 shr $0x3,%rax
11e4: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
11ea: 84 c0 test %al,%al
11ec: 0f 85 69 0a 00 00 jne 1c5b <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xd0b>
11f2: 41 8b 06 mov (%r14),%eax
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:55
int32 w = mRaw->dim.x;
11f5: 48 89 83 a8 00 00 00 mov %rax,0xa8(%rbx)
11fc: 49 8b 00 mov (%r8),%rax
11ff: 48 89 c1 mov %rax,%rcx
1202: 48 ba 23 da e6 f9 21 movabs $0xded91821f9e6da23,%rdx
1209: 18 d9 de
120c: 48 31 d1 xor %rdx,%rcx
120f: 48 0f af cf imul %rdi,%rcx
1213: 48 89 ce mov %rcx,%rsi
1216: 48 c1 ee 2f shr $0x2f,%rsi
121a: 48 31 c6 xor %rax,%rsi
121d: 48 31 ce xor %rcx,%rsi
1220: 48 0f af f7 imul %rdi,%rsi
1224: 48 89 f2 mov %rsi,%rdx
1227: 48 c1 ea 2f shr $0x2f,%rdx
122b: 48 31 f2 xor %rsi,%rdx
122e: 48 0f af d7 imul %rdi,%rdx
1232: 89 d0 mov %edx,%eax
1234: 83 e0 7f and $0x7f,%eax
1237: 49 39 14 c1 cmp %rdx,(%r9,%rax,8)
123b: 0f 85 af 0b 00 00 jne 1df0 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xea0>
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
1241: 48 8b 43 50 mov 0x50(%rbx),%rax
1245: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
124c: 0f 85 d4 0b 00 00 jne 1e26 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xed6>
1252: 4d 8b 34 24 mov (%r12),%r14
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:55
1256: 41 f6 c6 07 test $0x7,%r14b
125a: 0f 85 ca 0e 00 00 jne 212a <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11da>
1260: 4d 85 f6 test %r14,%r14
1263: 0f 84 c1 0e 00 00 je 212a <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11da>
1269: 49 8b 06 mov (%r14),%rax
126c: 48 89 c1 mov %rax,%rcx
126f: 48 ba 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%rdx
1276: 46 e3 cb
1279: 48 31 d1 xor %rdx,%rcx
127c: 48 0f af cf imul %rdi,%rcx
1280: 48 89 ce mov %rcx,%rsi
1283: 48 c1 ee 2f shr $0x2f,%rsi
1287: 48 31 c6 xor %rax,%rsi
128a: 48 31 ce xor %rcx,%rsi
128d: 48 0f af f7 imul %rdi,%rsi
1291: 48 89 f2 mov %rsi,%rdx
1294: 48 c1 ea 2f shr $0x2f,%rdx
1298: 48 31 f2 xor %rsi,%rdx
129b: 48 0f af d7 imul %rdi,%rdx
129f: 89 d0 mov %edx,%eax
12a1: 83 e0 7f and $0x7f,%eax
12a4: 49 39 14 c1 cmp %rdx,(%r9,%rax,8)
12a8: 0f 85 80 0b 00 00 jne 1e2e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xede>
12ae: 49 83 c6 48 add $0x48,%r14
12b2: 41 f6 c6 07 test $0x7,%r14b
12b6: 0f 85 a4 0b 00 00 jne 1e60 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xf10>
12bc: 4c 89 f0 mov %r14,%rax
12bf: 48 c1 e8 03 shr $0x3,%rax
12c3: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
12c9: 84 c0 test %al,%al
12cb: 0f 85 a3 09 00 00 jne 1c74 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xd24>
12d1: 41 8b 06 mov (%r14),%eax
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:57
assert(mRaw->dim.x > 0);
12d4: 48 89 43 70 mov %rax,0x70(%rbx)
12d8: 49 8b 00 mov (%r8),%rax
12db: 48 89 c1 mov %rax,%rcx
12de: 48 ba 23 da e6 f9 21 movabs $0xded91821f9e6da23,%rdx
12e5: 18 d9 de
12e8: 48 31 d1 xor %rdx,%rcx
12eb: 48 0f af cf imul %rdi,%rcx
12ef: 48 89 ce mov %rcx,%rsi
12f2: 48 c1 ee 2f shr $0x2f,%rsi
12f6: 48 31 c6 xor %rax,%rsi
12f9: 48 31 ce xor %rcx,%rsi
12fc: 48 0f af f7 imul %rdi,%rsi
1300: 48 89 f2 mov %rsi,%rdx
1303: 48 c1 ea 2f shr $0x2f,%rdx
1307: 48 31 f2 xor %rsi,%rdx
130a: 48 0f af d7 imul %rdi,%rdx
130e: 89 d0 mov %edx,%eax
1310: 83 e0 7f and $0x7f,%eax
1313: 49 39 14 c1 cmp %rdx,(%r9,%rax,8)
1317: 0f 85 57 0b 00 00 jne 1e74 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xf24>
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
131d: 48 8b 43 50 mov 0x50(%rbx),%rax
1321: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
1328: 0f 85 7c 0b 00 00 jne 1eaa <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xf5a>
132e: 4d 8b 34 24 mov (%r12),%r14
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:57
1332: 41 f6 c6 07 test $0x7,%r14b
1336: 0f 85 02 0e 00 00 jne 213e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11ee>
133c: 4d 85 f6 test %r14,%r14
133f: 0f 84 f9 0d 00 00 je 213e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11ee>
1345: 49 8b 06 mov (%r14),%rax
1348: 48 89 c1 mov %rax,%rcx
134b: 48 ba 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%rdx
1352: 46 e3 cb
1355: 48 31 d1 xor %rdx,%rcx
1358: 48 0f af cf imul %rdi,%rcx
135c: 48 89 ce mov %rcx,%rsi
135f: 48 c1 ee 2f shr $0x2f,%rsi
1363: 48 31 c6 xor %rax,%rsi
1366: 48 31 ce xor %rcx,%rsi
1369: 48 0f af f7 imul %rdi,%rsi
136d: 48 89 f2 mov %rsi,%rdx
1370: 48 c1 ea 2f shr $0x2f,%rdx
1374: 48 31 f2 xor %rsi,%rdx
1377: 48 0f af d7 imul %rdi,%rdx
137b: 89 d0 mov %edx,%eax
137d: 83 e0 7f and $0x7f,%eax
1380: 49 39 14 c1 cmp %rdx,(%r9,%rax,8)
1384: 0f 85 28 0b 00 00 jne 1eb2 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xf62>
138a: 49 83 c6 48 add $0x48,%r14
138e: 41 f6 c6 07 test $0x7,%r14b
1392: 0f 85 4c 0b 00 00 jne 1ee4 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xf94>
1398: 4c 89 f0 mov %r14,%rax
139b: 48 c1 e8 03 shr $0x3,%rax
139f: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
13a5: 84 c0 test %al,%al
13a7: 0f 85 e0 08 00 00 jne 1c8d <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xd3d>
13ad: 41 83 3e 00 cmpl $0x0,(%r14)
13b1: 0f 8e e2 0d 00 00 jle 2199 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1249>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:58
assert(mRaw->dim.x % 32 == 0);
13b7: 49 8b 00 mov (%r8),%rax
13ba: 48 89 c1 mov %rax,%rcx
13bd: 48 ba 23 da e6 f9 21 movabs $0xded91821f9e6da23,%rdx
13c4: 18 d9 de
13c7: 48 31 d1 xor %rdx,%rcx
13ca: 48 0f af cf imul %rdi,%rcx
13ce: 48 89 ce mov %rcx,%rsi
13d1: 48 c1 ee 2f shr $0x2f,%rsi
13d5: 48 31 c6 xor %rax,%rsi
13d8: 48 31 ce xor %rcx,%rsi
13db: 48 0f af f7 imul %rdi,%rsi
13df: 48 89 f2 mov %rsi,%rdx
13e2: 48 c1 ea 2f shr $0x2f,%rdx
13e6: 48 31 f2 xor %rsi,%rdx
13e9: 48 0f af d7 imul %rdi,%rdx
13ed: 89 d0 mov %edx,%eax
13ef: 83 e0 7f and $0x7f,%eax
13f2: 49 39 14 c1 cmp %rdx,(%r9,%rax,8)
13f6: 0f 85 fc 0a 00 00 jne 1ef8 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xfa8>
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
13fc: 48 8b 43 50 mov 0x50(%rbx),%rax
1400: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
1407: 0f 85 21 0b 00 00 jne 1f2e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xfde>
140d: 4d 8b 34 24 mov (%r12),%r14
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:58
1411: 41 f6 c6 07 test $0x7,%r14b
1415: 0f 85 37 0d 00 00 jne 2152 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1202>
141b: 4d 85 f6 test %r14,%r14
141e: 0f 84 2e 0d 00 00 je 2152 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1202>
1424: 49 8b 06 mov (%r14),%rax
1427: 48 89 c1 mov %rax,%rcx
142a: 48 ba 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%rdx
1431: 46 e3 cb
1434: 48 31 d1 xor %rdx,%rcx
1437: 48 0f af cf imul %rdi,%rcx
143b: 48 89 ce mov %rcx,%rsi
143e: 48 c1 ee 2f shr $0x2f,%rsi
1442: 48 31 c6 xor %rax,%rsi
1445: 48 31 ce xor %rcx,%rsi
1448: 48 0f af f7 imul %rdi,%rsi
144c: 48 89 f2 mov %rsi,%rdx
144f: 48 c1 ea 2f shr $0x2f,%rdx
1453: 48 31 f2 xor %rsi,%rdx
1456: 48 0f af d7 imul %rdi,%rdx
145a: 89 d0 mov %edx,%eax
145c: 83 e0 7f and $0x7f,%eax
145f: 49 39 14 c1 cmp %rdx,(%r9,%rax,8)
1463: 0f 85 cd 0a 00 00 jne 1f36 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xfe6>
1469: 49 83 c6 48 add $0x48,%r14
146d: 41 f6 c6 07 test $0x7,%r14b
1471: 0f 85 f1 0a 00 00 jne 1f68 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1018>
1477: 4c 89 f0 mov %r14,%rax
147a: 48 c1 e8 03 shr $0x3,%rax
147e: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
1484: 84 c0 test %al,%al
1486: 0f 85 1a 08 00 00 jne 1ca6 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xd56>
148c: 41 f6 06 1f testb $0x1f,(%r14)
1490: 0f 85 33 0d 00 00 jne 21c9 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1279>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:59
assert(mRaw->dim.y > 0);
1496: 49 8b 00 mov (%r8),%rax
1499: 48 89 c1 mov %rax,%rcx
149c: 48 ba 23 da e6 f9 21 movabs $0xded91821f9e6da23,%rdx
14a3: 18 d9 de
14a6: 48 31 d1 xor %rdx,%rcx
14a9: 48 0f af cf imul %rdi,%rcx
14ad: 48 89 ce mov %rcx,%rsi
14b0: 48 c1 ee 2f shr $0x2f,%rsi
14b4: 48 31 c6 xor %rax,%rsi
14b7: 48 31 ce xor %rcx,%rsi
14ba: 48 0f af f7 imul %rdi,%rsi
14be: 48 89 f2 mov %rsi,%rdx
14c1: 48 c1 ea 2f shr $0x2f,%rdx
14c5: 48 31 f2 xor %rsi,%rdx
14c8: 48 0f af d7 imul %rdi,%rdx
14cc: 89 d0 mov %edx,%eax
14ce: 83 e0 7f and $0x7f,%eax
14d1: 49 39 14 c1 cmp %rdx,(%r9,%rax,8)
14d5: 0f 85 a1 0a 00 00 jne 1f7c <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x102c>
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
14db: 48 8b 43 50 mov 0x50(%rbx),%rax
14df: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
14e6: 0f 85 c6 0a 00 00 jne 1fb2 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1062>
14ec: 4d 8b 34 24 mov (%r12),%r14
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:59
14f0: 41 f6 c6 07 test $0x7,%r14b
14f4: 0f 85 6c 0c 00 00 jne 2166 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1216>
14fa: 4d 85 f6 test %r14,%r14
14fd: 0f 84 63 0c 00 00 je 2166 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1216>
1503: 49 8b 06 mov (%r14),%rax
1506: 48 89 c1 mov %rax,%rcx
1509: 48 ba 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%rdx
1510: 46 e3 cb
1513: 48 31 d1 xor %rdx,%rcx
1516: 48 0f af cf imul %rdi,%rcx
151a: 48 89 ce mov %rcx,%rsi
151d: 48 c1 ee 2f shr $0x2f,%rsi
1521: 48 31 c6 xor %rax,%rsi
1524: 48 31 ce xor %rcx,%rsi
1527: 48 0f af f7 imul %rdi,%rsi
152b: 48 89 f2 mov %rsi,%rdx
152e: 48 c1 ea 2f shr $0x2f,%rdx
1532: 48 31 f2 xor %rsi,%rdx
1535: 48 0f af d7 imul %rdi,%rdx
1539: 89 d0 mov %edx,%eax
153b: 83 e0 7f and $0x7f,%eax
153e: 49 39 14 c1 cmp %rdx,(%r9,%rax,8)
1542: 0f 85 72 0a 00 00 jne 1fba <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x106a>
1548: 4d 8d 7e 48 lea 0x48(%r14),%r15
154c: 41 f6 c7 07 test $0x7,%r15b
1550: 0f 85 96 0a 00 00 jne 1fec <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x109c>
1556: 49 83 c6 4c add $0x4c,%r14
155a: 41 f6 c6 03 test $0x3,%r14b
155e: 0f 85 95 0c 00 00 jne 21f9 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x12a9>
1564: 4c 89 f0 mov %r14,%rax
1567: 48 c1 e8 03 shr $0x3,%rax
156b: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
1571: 84 c0 test %al,%al
1573: 4c 8b 7b 28 mov 0x28(%rbx),%r15
1577: 0f 85 42 07 00 00 jne 1cbf <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xd6f>
157d: 41 83 3e 00 cmpl $0x0,(%r14)
1581: 0f 8e 86 0c 00 00 jle 220d <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x12bd>
1587: 49 81 c5 00 80 ff 7f add $0x7fff8000,%r13
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:61
BitPumpLSB bits(input);
158e: 41 c7 45 04 00 00 00 movl $0x0,0x4(%r13)
1595: 00
1596: 41 c6 45 08 00 movb $0x0,0x8(%r13)
159b: 49 8b 00 mov (%r8),%rax
159e: 48 b9 ec 11 a0 c3 09 movabs $0x9b4d5109c3a011ec,%rcx
15a5: 51 4d 9b
15a8: 48 31 c1 xor %rax,%rcx
15ab: 48 0f af cf imul %rdi,%rcx
15af: 48 89 ce mov %rcx,%rsi
15b2: 48 c1 ee 2f shr $0x2f,%rsi
15b6: 48 31 c6 xor %rax,%rsi
15b9: 48 31 ce xor %rcx,%rsi
15bc: 48 0f af f7 imul %rdi,%rsi
15c0: 48 89 f2 mov %rsi,%rdx
15c3: 48 c1 ea 2f shr $0x2f,%rdx
15c7: 48 31 f2 xor %rsi,%rdx
15ca: 48 0f af d7 imul %rdi,%rdx
15ce: 89 d0 mov %edx,%eax
15d0: 83 e0 7f and $0x7f,%eax
15d3: 49 39 14 c1 cmp %rdx,(%r9,%rax,8)
15d7: 0f 85 23 0a 00 00 jne 2000 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10b0>
15dd: 4d 8d 70 10 lea 0x10(%r8),%r14
15e1: 41 f6 c6 07 test $0x7,%r14b
15e5: 0f 85 37 0a 00 00 jne 2022 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10d2>
15eb: 49 8d 7f 20 lea 0x20(%r15),%rdi
15ef: 48 89 7b 60 mov %rdi,0x60(%rbx)
15f3: 4c 89 f6 mov %r14,%rsi
15f6: e8 00 00 00 00 callq 15fb <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x6ab>
15fb: 48 8b 7b 58 mov 0x58(%rbx),%rdi
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:62
for (uint32 y = t->start; y < t->end; y++) {
15ff: 40 f6 c7 07 test $0x7,%dil
1603: 0f 85 71 0b 00 00 jne 217a <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x122a>
1609: 48 85 ff test %rdi,%rdi
160c: 0f 84 68 0b 00 00 je 217a <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x122a>
1612: 4c 8d 77 10 lea 0x10(%rdi),%r14
1616: 41 f6 c6 07 test $0x7,%r14b
161a: 0f 85 1d 0c 00 00 jne 223d <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x12ed>
1620: 48 83 c7 14 add $0x14,%rdi
1624: 40 f6 c7 03 test $0x3,%dil
1628: 4c 8b 43 60 mov 0x60(%rbx),%r8
162c: 0f 85 1f 0c 00 00 jne 2251 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1301>
1632: 4c 89 f0 mov %r14,%rax
1635: 48 c1 e8 03 shr $0x3,%rax
1639: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
163f: 84 c0 test %al,%al
1641: 0f 85 91 06 00 00 jne 1cd8 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xd88>
1647: 41 8b 0e mov (%r14),%ecx
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:69
// Realign
bits.setBufferPosition(w * y);
uint32 random = bits.peekBits(24);
// Process 32 pixels (16x2) per loop.
for (int32 x = 0; x < w - 30;) {
164a: 48 8b 43 70 mov 0x70(%rbx),%rax
164e: 41 89 c6 mov %eax,%r14d
1651: 41 83 ee 1e sub $0x1e,%r14d
1655: 41 0f 90 c7 seto %r15b
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:62
for (uint32 y = t->start; y < t->end; y++) {
1659: 48 89 f8 mov %rdi,%rax
165c: 48 c1 e8 03 shr $0x3,%rax
1660: 48 89 83 e0 00 00 00 mov %rax,0xe0(%rbx)
1667: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
166d: 84 c0 test %al,%al
166f: 0f 85 7c 06 00 00 jne 1cf1 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xda1>
1675: 3b 0f cmp (%rdi),%ecx
1677: 0f 83 6d 05 00 00 jae 1bea <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xc9a>
167d: 48 8b 43 28 mov 0x28(%rbx),%rax
1681: 4c 8d 48 70 lea 0x70(%rax),%r9
1685: 49 8d 40 14 lea 0x14(%r8),%rax
1689: 49 8d 50 20 lea 0x20(%r8),%rdx
168d: 49 8d 70 18 lea 0x18(%r8),%rsi
1691: 48 89 83 90 00 00 00 mov %rax,0x90(%rbx)
1698: 48 c1 e8 03 shr $0x3,%rax
169c: 48 89 83 d8 00 00 00 mov %rax,0xd8(%rbx)
16a3: 48 89 53 48 mov %rdx,0x48(%rbx)
16a7: 48 c1 ea 03 shr $0x3,%rdx
16ab: 48 89 93 c0 00 00 00 mov %rdx,0xc0(%rbx)
16b2: 48 89 b3 88 00 00 00 mov %rsi,0x88(%rbx)
16b9: 48 c1 ee 03 shr $0x3,%rsi
16bd: 48 89 b3 b8 00 00 00 mov %rsi,0xb8(%rbx)
16c4: 4c 89 4b 78 mov %r9,0x78(%rbx)
16c8: 49 c1 e9 03 shr $0x3,%r9
16cc: 4c 89 8b d0 00 00 00 mov %r9,0xd0(%rbx)
16d3: 48 89 7b 58 mov %rdi,0x58(%rbx)
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:63
auto* dest = reinterpret_cast<ushort16*>(&data[y * pitch]);
16d7: 89 c8 mov %ecx,%eax
16d9: f7 a3 a8 00 00 00 mull 0xa8(%rbx)
16df: 0f 80 83 0b 00 00 jo 2268 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1318>
16e5: 89 c0 mov %eax,%eax
16e7: 48 03 83 b0 00 00 00 add 0xb0(%rbx),%rax
16ee: 48 89 83 80 00 00 00 mov %rax,0x80(%rbx)
16f5: 0f 82 8b 0b 00 00 jb 2286 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1336>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:65
bits.setBufferPosition(w * y);
16fb: 48 8b 43 70 mov 0x70(%rbx),%rax
16ff: 89 4b 6c mov %ecx,0x6c(%rbx)
1702: f7 e1 mul %ecx
1704: 0f 80 9b 0b 00 00 jo 22a5 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1355>
rawspeed::BitStream<rawspeed::PlainBitPumpTag, rawspeed::BitStreamCacheLeftInRightOut>::setBufferPosition(unsigned int)():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/BitPumpLSB.h:46
cache.push(getLE<uint32>(input), 32);
return 4;
}
template <> inline void BitPumpLSB::setBufferPosition(size_type newPos) {
pos = newPos;
170a: 48 8b 8b d8 00 00 00 mov 0xd8(%rbx),%rcx
1711: 8a 89 00 80 ff 7f mov 0x7fff8000(%rcx),%cl
1717: 84 c9 test %cl,%cl
1719: 0f 85 55 04 00 00 jne 1b74 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xc24>
171f: 48 8b 8b 90 00 00 00 mov 0x90(%rbx),%rcx
1726: 89 01 mov %eax,(%rcx)
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/BitPumpLSB.h:47
cache.fillLevel = 0;
1728: 48 8b 83 c0 00 00 00 mov 0xc0(%rbx),%rax
172f: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
1735: 84 c0 test %al,%al
1737: 0f 85 51 04 00 00 jne 1b8e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xc3e>
173d: 48 8b 43 48 mov 0x48(%rbx),%rax
1741: c7 00 00 00 00 00 movl $0x0,(%rax)
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/BitPumpLSB.h:48
cache.cache = 0;
1747: 48 8b 83 b8 00 00 00 mov 0xb8(%rbx),%rax
174e: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
1755: 0f 85 66 0b 00 00 jne 22c1 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1371>
175b: 49 c7 40 18 00 00 00 movq $0x0,0x18(%r8)
1762: 00
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:66
uint32 random = bits.peekBits(24);
1763: 41 c6 45 0e 04 movb $0x4,0xe(%r13)
rawspeed::BitStream<rawspeed::PlainBitPumpTag, rawspeed::BitStreamCacheLeftInRightOut>::peekBits(unsigned int)():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/BitStream.h:187
assert(nbits <= cache.fillLevel);
cache.skip(nbits);
}
inline uint32 peekBits(uint32 nbits) {
fill(nbits);
1768: be 18 00 00 00 mov $0x18,%esi
176d: 4c 89 c7 mov %r8,%rdi
1770: e8 00 00 00 00 callq 1775 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x825>
rawspeed::BitStream<rawspeed::PlainBitPumpTag, rawspeed::BitStreamCacheLeftInRightOut>::peekBitsNoFill(unsigned int)():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/BitStream.h:170
assert(nbits <= cache.fillLevel);
1775: 48 8b 83 c0 00 00 00 mov 0xc0(%rbx),%rax
177c: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
1782: 84 c0 test %al,%al
1784: 0f 85 1b 04 00 00 jne 1ba5 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xc55>
178a: 48 8b 43 48 mov 0x48(%rbx),%rax
178e: 83 38 17 cmpl $0x17,(%rax)
1791: 4c 8b 43 60 mov 0x60(%rbx),%r8
1795: 0f 86 32 0b 00 00 jbe 22cd <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x137d>
rawspeed::BitStreamCacheLeftInRightOut::peek(unsigned int) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/BitStream.h:63
return cache & ((1 << count) - 1);
179b: 48 8b 83 b8 00 00 00 mov 0xb8(%rbx),%rax
17a2: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
17a9: 0f 85 4e 0b 00 00 jne 22fd <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x13ad>
17af: 48 8b 83 88 00 00 00 mov 0x88(%rbx),%rax
17b6: 8b 00 mov (%rax),%eax
17b8: b9 ff ff ff 00 mov $0xffffff,%ecx
17bd: 21 c8 and %ecx,%eax
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:66
17bf: 48 8b 8b d0 00 00 00 mov 0xd0(%rbx),%rcx
17c6: 8a 89 00 80 ff 7f mov 0x7fff8000(%rcx),%cl
17cc: 84 c9 test %cl,%cl
17ce: 0f 85 e8 03 00 00 jne 1bbc <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xc6c>
17d4: 48 8b 4b 78 mov 0x78(%rbx),%rcx
17d8: 89 01 mov %eax,(%rcx)
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:69
for (int32 x = 0; x < w - 30;) {
17da: 45 84 ff test %r15b,%r15b
17dd: 0f 85 26 0b 00 00 jne 2309 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x13b9>
17e3: 45 85 f6 test %r14d,%r14d
17e6: 0f 8e 54 03 00 00 jle 1b40 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xbf0>
17ec: 31 c0 xor %eax,%eax
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:70
int _max = bits.getBits(11);
17ee: 4c 89 ab a0 00 00 00 mov %r13,0xa0(%rbx)
17f5: 44 89 b3 9c 00 00 00 mov %r14d,0x9c(%rbx)
17fc: 44 88 7b 23 mov %r15b,0x23(%rbx)
1800: 89 43 40 mov %eax,0x40(%rbx)
1803: be 0b 00 00 00 mov $0xb,%esi
1808: 4c 89 c7 mov %r8,%rdi
180b: 4d 89 c7 mov %r8,%r15
180e: e8 00 00 00 00 callq 1813 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x8c3>
1813: 89 43 44 mov %eax,0x44(%rbx)
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:71
int _min = bits.getBits(11);
1816: be 0b 00 00 00 mov $0xb,%esi
181b: 4c 89 ff mov %r15,%rdi
181e: e8 00 00 00 00 callq 1823 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x8d3>
1823: 89 43 24 mov %eax,0x24(%rbx)
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:72
int _imax = bits.getBits(4);
1826: be 04 00 00 00 mov $0x4,%esi
182b: 4c 89 ff mov %r15,%rdi
182e: e8 00 00 00 00 callq 1833 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x8e3>
1833: 41 89 c6 mov %eax,%r14d
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:73
int _imin = bits.getBits(4);
1836: be 04 00 00 00 mov $0x4,%esi
183b: 4c 89 ff mov %r15,%rdi
183e: e8 00 00 00 00 callq 1843 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x8f3>
1843: 89 c1 mov %eax,%ecx
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:76
int sh = 0;
while ((sh < 4) && ((0x80 << sh) <= (_max - _min)))
1845: 8b 53 44 mov 0x44(%rbx),%edx
1848: 2b 53 24 sub 0x24(%rbx),%edx
184b: 0f 80 d2 0a 00 00 jo 2323 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x13d3>
1851: c7 43 34 00 00 00 00 movl $0x0,0x34(%rbx)
1858: 81 fa 80 00 00 00 cmp $0x80,%edx
185e: 48 8b 73 18 mov 0x18(%rbx),%rsi
1862: 48 bf 69 2d 38 eb 08 movabs $0x9ddfea08eb382d69,%rdi
1869: ea df 9d
186c: 4c 8b 05 00 00 00 00 mov 0x0(%rip),%r8 # 1873 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x923>
1873: 7c 3b jl 18b0 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x960>
1875: c7 43 34 01 00 00 00 movl $0x1,0x34(%rbx)
187c: 81 fa 00 01 00 00 cmp $0x100,%edx
1882: 7c 2c jl 18b0 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x960>
1884: c7 43 34 02 00 00 00 movl $0x2,0x34(%rbx)
188b: 81 fa 00 02 00 00 cmp $0x200,%edx
1891: 7c 1d jl 18b0 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x960>
1893: 31 c0 xor %eax,%eax
1895: 81 fa 00 04 00 00 cmp $0x400,%edx
189b: 0f 9c c0 setl %al
189e: ba 04 00 00 00 mov $0x4,%edx
18a3: 29 c2 sub %eax,%edx
18a5: 89 53 34 mov %edx,0x34(%rbx)
18a8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1)
18af: 00
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:79
sh++;
for (int i = 0; i < 16; i++) {
18b0: 44 89 f0 mov %r14d,%eax
18b3: 48 89 83 f0 00 00 00 mov %rax,0xf0(%rbx)
18ba: 89 c8 mov %ecx,%eax
18bc: 48 89 83 e8 00 00 00 mov %rax,0xe8(%rbx)
18c3: 45 31 ff xor %r15d,%r15d
18c6: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
18cd: 00 00 00
18d0: 44 8b 6b 44 mov 0x44(%rbx),%r13d
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:81
int p;
if (i == _imax)
18d4: 44 39 bb f0 00 00 00 cmp %r15d,0xf0(%rbx)
18db: 74 52 je 192f <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x9df>
18dd: 44 8b 6b 24 mov 0x24(%rbx),%r13d
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:84
p = _max;
else {
if (i == _imin)
18e1: 44 39 bb e8 00 00 00 cmp %r15d,0xe8(%rbx)
18e8: 74 45 je 192f <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x9df>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:87
p = _min;
else {
p = (bits.getBits(7) << sh) + _min;
18ea: be 07 00 00 00 mov $0x7,%esi
18ef: 48 8b 7b 60 mov 0x60(%rbx),%rdi
18f3: e8 00 00 00 00 callq 18f8 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x9a8>
18f8: 8b 4b 34 mov 0x34(%rbx),%ecx
18fb: d3 e0 shl %cl,%eax
18fd: 41 89 c5 mov %eax,%r13d
1900: 44 03 6b 24 add 0x24(%rbx),%r13d
1904: 0f 82 c3 07 00 00 jb 20cd <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x117d>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:88
if (p > 0x7ff)
190a: 41 81 fd 00 08 00 00 cmp $0x800,%r13d
1911: b8 ff 07 00 00 mov $0x7ff,%eax
1916: 44 0f 4d e8 cmovge %eax,%r13d
191a: 48 8b 73 18 mov 0x18(%rbx),%rsi
191e: 48 bf 69 2d 38 eb 08 movabs $0x9ddfea08eb382d69,%rdi
1925: ea df 9d
1928: 4c 8b 05 00 00 00 00 mov 0x0(%rip),%r8 # 192f <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x9df>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:92
p = 0x7ff;
}
}
mRaw->setWithLookUp(p << 1, reinterpret_cast<uchar8*>(&dest[x + i * 2]),
192f: 48 8b 06 mov (%rsi),%rax
1932: 48 89 c1 mov %rax,%rcx
1935: 48 ba 23 da e6 f9 21 movabs $0xded91821f9e6da23,%rdx
193c: 18 d9 de
193f: 48 31 d1 xor %rdx,%rcx
1942: 48 0f af cf imul %rdi,%rcx
1946: 48 89 ce mov %rcx,%rsi
1949: 48 c1 ee 2f shr $0x2f,%rsi
194d: 48 31 c6 xor %rax,%rsi
1950: 48 31 ce xor %rcx,%rsi
1953: 48 0f af f7 imul %rdi,%rsi
1957: 48 89 f2 mov %rsi,%rdx
195a: 48 c1 ea 2f shr $0x2f,%rdx
195e: 48 31 f2 xor %rsi,%rdx
1961: 48 0f af d7 imul %rdi,%rdx
1965: 89 d0 mov %edx,%eax
1967: 83 e0 7f and $0x7f,%eax
196a: 49 39 14 c0 cmp %rdx,(%r8,%rax,8)
196e: 0f 85 2d 01 00 00 jne 1aa1 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xb51>
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
1974: 48 8b 43 50 mov 0x50(%rbx),%rax
1978: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
197f: 0f 85 01 07 00 00 jne 2086 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1136>
1985: 4d 8b 34 24 mov (%r12),%r14
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:92
1989: 41 f6 c6 07 test $0x7,%r14b
198d: 0f 85 a3 06 00 00 jne 2036 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10e6>
1993: 4d 85 f6 test %r14,%r14
1996: 0f 84 9a 06 00 00 je 2036 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10e6>
199c: 49 8b 06 mov (%r14),%rax
199f: 48 89 c1 mov %rax,%rcx
19a2: 48 ba 47 1c 04 a0 4f movabs $0xcbe3464fa0041c47,%rdx
19a9: 46 e3 cb
19ac: 48 31 d1 xor %rdx,%rcx
19af: 48 0f af cf imul %rdi,%rcx
19b3: 48 89 ce mov %rcx,%rsi
19b6: 48 c1 ee 2f shr $0x2f,%rsi
19ba: 48 31 c6 xor %rax,%rsi
19bd: 48 31 ce xor %rcx,%rsi
19c0: 48 0f af f7 imul %rdi,%rsi
19c4: 48 89 f2 mov %rsi,%rdx
19c7: 48 c1 ea 2f shr $0x2f,%rdx
19cb: 48 31 f2 xor %rsi,%rdx
19ce: 48 0f af d7 imul %rdi,%rdx
19d2: 89 d0 mov %edx,%eax
19d4: 83 e0 7f and $0x7f,%eax
19d7: 49 39 14 c0 cmp %rdx,(%r8,%rax,8)
19db: 0f 85 f7 00 00 00 jne 1ad8 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xb88>
19e1: 4c 89 f0 mov %r14,%rax
19e4: 48 c1 e8 03 shr $0x3,%rax
19e8: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
19ef: 0f 85 99 06 00 00 jne 208e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x113e>
19f5: 49 8b 3e mov (%r14),%rdi
19f8: 48 83 c7 20 add $0x20,%rdi
19fc: 48 89 f8 mov %rdi,%rax
19ff: 48 c1 e8 03 shr $0x3,%rax
1a03: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
1a0a: 0f 85 3a 06 00 00 jne 204a <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10fa>
1a10: 45 85 ed test %r13d,%r13d
1a13: 0f 88 7d 06 00 00 js 2096 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1146>
1a19: 44 89 f8 mov %r15d,%eax
1a1c: 01 c0 add %eax,%eax
1a1e: 0f 80 2b 06 00 00 jo 204f <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10ff>
1a24: 8b 4b 40 mov 0x40(%rbx),%ecx
1a27: 01 c1 add %eax,%ecx
1a29: 0f 80 39 06 00 00 jo 2068 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1118>
1a2f: 4c 8b 07 mov (%rdi),%r8
1a32: 48 63 c9 movslq %ecx,%rcx
1a35: 4c 8d 24 09 lea (%rcx,%rcx,1),%r12
1a39: 48 8b 93 80 00 00 00 mov 0x80(%rbx),%rdx
1a40: 49 01 d4 add %rdx,%r12
1a43: 0f 92 c0 setb %al
1a46: 49 39 d4 cmp %rdx,%r12
1a49: 0f 93 c2 setae %dl
1a4c: 85 c9 test %ecx,%ecx
1a4e: 79 02 jns 1a52 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xb02>
1a50: 89 c2 mov %eax,%edx
1a52: 84 d2 test %dl,%dl
1a54: 0f 84 58 06 00 00 je 20b2 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1162>
1a5a: 45 01 ed add %r13d,%r13d
1a5d: 48 8b 83 80 00 00 00 mov 0x80(%rbx),%rax
1a64: 48 8d 14 48 lea (%rax,%rcx,2),%rdx
1a68: 41 0f b7 f5 movzwl %r13w,%esi
1a6c: 4c 89 f7 mov %r14,%rdi
1a6f: 48 8b 4b 78 mov 0x78(%rbx),%rcx
1a73: 41 ff d0 callq *%r8
1a76: 4c 8b a3 c8 00 00 00 mov 0xc8(%rbx),%r12
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:79
for (int i = 0; i < 16; i++) {
1a7d: 49 ff c7 inc %r15
1a80: 41 83 ff 10 cmp $0x10,%r15d
1a84: 48 8b 73 18 mov 0x18(%rbx),%rsi
1a88: 48 bf 69 2d 38 eb 08 movabs $0x9ddfea08eb382d69,%rdi
1a8f: ea df 9d
1a92: 4c 8b 05 00 00 00 00 mov 0x0(%rip),%r8 # 1a99 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xb49>
1a99: 0f 82 31 fe ff ff jb 18d0 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x980>
1a9f: eb 5f jmp 1b00 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xbb0>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:92
mRaw->setWithLookUp(p << 1, reinterpret_cast<uchar8*>(&dest[x + i * 2]),
1aa1: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1aa8 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xb58>
1aa8: 48 8b 73 18 mov 0x18(%rbx),%rsi
1aac: e8 00 00 00 00 callq 1ab1 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xb61>
1ab1: 4c 8b 05 00 00 00 00 mov 0x0(%rip),%r8 # 1ab8 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xb68>
1ab8: 48 bf 69 2d 38 eb 08 movabs $0x9ddfea08eb382d69,%rdi
1abf: ea df 9d
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
1ac2: 48 8b 43 50 mov 0x50(%rbx),%rax
1ac6: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
1acd: 0f 84 b2 fe ff ff je 1985 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xa35>
1ad3: e9 ae 05 00 00 jmpq 2086 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1136>
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:92
1ad8: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1adf <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xb8f>
1adf: 4c 89 f6 mov %r14,%rsi
1ae2: e8 00 00 00 00 callq 1ae7 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xb97>
1ae7: 4c 89 f0 mov %r14,%rax
1aea: 48 c1 e8 03 shr $0x3,%rax
1aee: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
1af5: 0f 84 fa fe ff ff je 19f5 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xaa5>
1afb: e9 8e 05 00 00 jmpq 208e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x113e>
1b00: 8b 53 40 mov 0x40(%rbx),%edx
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:95
&random);
}
x += ((x & 1) != 0) ? 31 : 1; // Skip to next 32 pixels
1b03: f6 c2 01 test $0x1,%dl
1b06: b8 1f 00 00 00 mov $0x1f,%eax
1b0b: b9 01 00 00 00 mov $0x1,%ecx
1b10: 0f 44 c1 cmove %ecx,%eax
1b13: 89 d1 mov %edx,%ecx
1b15: 01 c1 add %eax,%ecx
1b17: 0f 80 25 08 00 00 jo 2342 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x13f2>
1b1d: 89 c8 mov %ecx,%eax
1b1f: 44 8b b3 9c 00 00 00 mov 0x9c(%rbx),%r14d
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:69
for (int32 x = 0; x < w - 30;) {
1b26: 44 39 f1 cmp %r14d,%ecx
1b29: 4c 8b ab a0 00 00 00 mov 0xa0(%rbx),%r13
1b30: 4c 8b 43 60 mov 0x60(%rbx),%r8
1b34: 44 8a 7b 23 mov 0x23(%rbx),%r15b
1b38: 0f 8c c2 fc ff ff jl 1800 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x8b0>
1b3e: 66 90 xchg %ax,%ax
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:97
}
}
1b40: 41 c6 45 0e f8 movb $0xf8,0xe(%r13)
1b45: 8b 43 6c mov 0x6c(%rbx),%eax
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:62
for (uint32 y = t->start; y < t->end; y++) {
1b48: 89 c1 mov %eax,%ecx
1b4a: 83 c1 01 add $0x1,%ecx
1b4d: 0f 82 0c 08 00 00 jb 235f <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x140f>
1b53: 48 8b 83 e0 00 00 00 mov 0xe0(%rbx),%rax
1b5a: 8a 80 00 80 ff 7f mov 0x7fff8000(%rax),%al
1b60: 84 c0 test %al,%al
1b62: 75 6f jne 1bd3 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xc83>
1b64: 89 ca mov %ecx,%edx
1b66: 48 8b 43 58 mov 0x58(%rbx),%rax
1b6a: 3b 08 cmp (%rax),%ecx
1b6c: 0f 82 65 fb ff ff jb 16d7 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x787>
1b72: eb 76 jmp 1bea <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xc9a>
rawspeed::BitStream<rawspeed::PlainBitPumpTag, rawspeed::BitStreamCacheLeftInRightOut>::setBufferPosition(unsigned int)():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/BitPumpLSB.h:46
pos = newPos;
1b74: 48 8b 93 90 00 00 00 mov 0x90(%rbx),%rdx
1b7b: 83 e2 07 and $0x7,%edx
1b7e: 83 c2 03 add $0x3,%edx
1b81: 38 ca cmp %cl,%dl
1b83: 0f 8c 96 fb ff ff jl 171f <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x7cf>
1b89: e9 ed 07 00 00 jmpq 237b <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x142b>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/BitPumpLSB.h:47
cache.fillLevel = 0;
1b8e: 48 8b 4b 48 mov 0x48(%rbx),%rcx
1b92: 83 e1 07 and $0x7,%ecx
1b95: 83 c1 03 add $0x3,%ecx
1b98: 38 c1 cmp %al,%cl
1b9a: 0f 8c 9d fb ff ff jl 173d <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x7ed>
1ba0: e9 e2 07 00 00 jmpq 2387 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1437>
rawspeed::BitStream<rawspeed::PlainBitPumpTag, rawspeed::BitStreamCacheLeftInRightOut>::peekBitsNoFill(unsigned int)():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/BitStream.h:170
assert(nbits <= cache.fillLevel);
1ba5: 48 8b 4b 48 mov 0x48(%rbx),%rcx
1ba9: 83 e1 07 and $0x7,%ecx
1bac: 83 c1 03 add $0x3,%ecx
1baf: 38 c1 cmp %al,%cl
1bb1: 0f 8c d3 fb ff ff jl 178a <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x83a>
1bb7: e9 d4 07 00 00 jmpq 2390 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1440>
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:66
uint32 random = bits.peekBits(24);
1bbc: 48 8b 53 78 mov 0x78(%rbx),%rdx
1bc0: 83 e2 07 and $0x7,%edx
1bc3: 83 c2 03 add $0x3,%edx
1bc6: 38 ca cmp %cl,%dl
1bc8: 0f 8c 06 fc ff ff jl 17d4 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x884>
1bce: e9 c6 07 00 00 jmpq 2399 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1449>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:62
for (uint32 y = t->start; y < t->end; y++) {
1bd3: 48 8b 53 58 mov 0x58(%rbx),%rdx
1bd7: 83 e2 07 and $0x7,%edx
1bda: 83 c2 03 add $0x3,%edx
1bdd: 38 c2 cmp %al,%dl
1bdf: 7c 83 jl 1b64 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xc14>
1be1: 48 8b 7b 58 mov 0x58(%rbx),%rdi
1be5: e8 00 00 00 00 callq 1bea <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xc9a>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:98
}
1bea: 4c 89 c7 mov %r8,%rdi
1bed: e8 00 00 00 00 callq 1bf2 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xca2>
1bf2: 41 c7 45 04 f8 f8 f8 movl $0xf8f8f8f8,0x4(%r13)
1bf9: f8
1bfa: 41 c6 45 08 f8 movb $0xf8,0x8(%r13)
1bff: 48 8b 43 28 mov 0x28(%rbx),%rax
1c03: 48 c7 00 0e 36 e0 45 movq $0x45e0360e,(%rax)
1c0a: 48 8b 4b 38 mov 0x38(%rbx),%rcx
1c0e: 48 85 c9 test %rcx,%rcx
1c11: 74 2f je 1c42 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xcf2>
1c13: 48 b8 f5 f5 f5 f5 f5 movabs $0xf5f5f5f5f5f5f5f5,%rax
1c1a: f5 f5 f5
1c1d: 49 89 45 00 mov %rax,0x0(%r13)
1c21: 49 89 45 08 mov %rax,0x8(%r13)
1c25: 48 8b 41 78 mov 0x78(%rcx),%rax
1c29: c6 00 00 movb $0x0,(%rax)
1c2c: eb 1e jmp 1c4c <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xcfc>
1c2e: 45 31 ff xor %r15d,%r15d
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:52
const RawDecompressorThread* t) const {
1c31: 4d 89 fc mov %r15,%r12
1c34: 4d 85 ff test %r15,%r15
1c37: 0f 85 6d f3 ff ff jne faa <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x5a>
1c3d: e9 5a f3 ff ff jmpq f9c <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x4c>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:98
}
1c42: c5 f8 57 c0 vxorps %xmm0,%xmm0,%xmm0
1c46: c4 c1 78 11 45 00 vmovups %xmm0,0x0(%r13)
1c4c: 48 8d 65 d8 lea -0x28(%rbp),%rsp
1c50: 5b pop %rbx
1c51: 41 5c pop %r12
1c53: 41 5d pop %r13
1c55: 41 5e pop %r14
1c57: 41 5f pop %r15
1c59: 5d pop %rbp
1c5a: c3 retq
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:54
uint32 pitch = mRaw->pitch;
1c5b: 44 89 f1 mov %r14d,%ecx
1c5e: 83 e1 07 and $0x7,%ecx
1c61: 83 c1 03 add $0x3,%ecx
1c64: 38 c1 cmp %al,%cl
1c66: 0f 8c 86 f5 ff ff jl 11f2 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x2a2>
1c6c: 4c 89 f7 mov %r14,%rdi
1c6f: e8 00 00 00 00 callq 1c74 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xd24>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:55
int32 w = mRaw->dim.x;
1c74: 44 89 f1 mov %r14d,%ecx
1c77: 83 e1 07 and $0x7,%ecx
1c7a: 83 c1 03 add $0x3,%ecx
1c7d: 38 c1 cmp %al,%cl
1c7f: 0f 8c 4c f6 ff ff jl 12d1 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x381>
1c85: 4c 89 f7 mov %r14,%rdi
1c88: e8 00 00 00 00 callq 1c8d <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xd3d>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:57
assert(mRaw->dim.x > 0);
1c8d: 44 89 f1 mov %r14d,%ecx
1c90: 83 e1 07 and $0x7,%ecx
1c93: 83 c1 03 add $0x3,%ecx
1c96: 38 c1 cmp %al,%cl
1c98: 0f 8c 0f f7 ff ff jl 13ad <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x45d>
1c9e: 4c 89 f7 mov %r14,%rdi
1ca1: e8 00 00 00 00 callq 1ca6 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xd56>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:58
assert(mRaw->dim.x % 32 == 0);
1ca6: 44 89 f1 mov %r14d,%ecx
1ca9: 83 e1 07 and $0x7,%ecx
1cac: 83 c1 03 add $0x3,%ecx
1caf: 38 c1 cmp %al,%cl
1cb1: 0f 8c d5 f7 ff ff jl 148c <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x53c>
1cb7: 4c 89 f7 mov %r14,%rdi
1cba: e8 00 00 00 00 callq 1cbf <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xd6f>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:59
assert(mRaw->dim.y > 0);
1cbf: 44 89 f1 mov %r14d,%ecx
1cc2: 83 e1 07 and $0x7,%ecx
1cc5: 83 c1 03 add $0x3,%ecx
1cc8: 38 c1 cmp %al,%cl
1cca: 0f 8c ad f8 ff ff jl 157d <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x62d>
1cd0: 4c 89 f7 mov %r14,%rdi
1cd3: e8 00 00 00 00 callq 1cd8 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xd88>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:62
for (uint32 y = t->start; y < t->end; y++) {
1cd8: 44 89 f1 mov %r14d,%ecx
1cdb: 83 e1 07 and $0x7,%ecx
1cde: 83 c1 03 add $0x3,%ecx
1ce1: 38 c1 cmp %al,%cl
1ce3: 0f 8c 5e f9 ff ff jl 1647 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x6f7>
1ce9: 4c 89 f7 mov %r14,%rdi
1cec: e8 00 00 00 00 callq 1cf1 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xda1>
1cf1: 89 ca mov %ecx,%edx
1cf3: 89 f9 mov %edi,%ecx
1cf5: 83 e1 07 and $0x7,%ecx
1cf8: 83 c1 03 add $0x3,%ecx
1cfb: 38 c1 cmp %al,%cl
1cfd: 89 d1 mov %edx,%ecx
1cff: 0f 8c 70 f9 ff ff jl 1675 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x725>
1d05: e8 00 00 00 00 callq 1d0a <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xdba>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:53
uchar8* data = mRaw->getData();
1d0a: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1d11 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xdc1>
1d11: 48 8b 73 18 mov 0x18(%rbx),%rsi
1d15: e8 00 00 00 00 callq 1d1a <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xdca>
1d1a: 4c 8b 0d 00 00 00 00 mov 0x0(%rip),%r9 # 1d21 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xdd1>
1d21: 49 b8 69 2d 38 eb 08 movabs $0x9ddfea08eb382d69,%r8
1d28: ea df 9d
1d2b: 48 8b 7b 18 mov 0x18(%rbx),%rdi
1d2f: 4c 8d 77 08 lea 0x8(%rdi),%r14
1d33: 41 f6 c6 07 test $0x7,%r14b
1d37: 0f 84 38 f3 ff ff je 1075 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x125>
1d3d: e8 00 00 00 00 callq 1d42 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xdf2>
1d42: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1d49 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xdf9>
1d49: 4c 89 f6 mov %r14,%rsi
1d4c: e8 00 00 00 00 callq 1d51 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xe01>
1d51: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1d58 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xe08>
1d58: 4c 89 f6 mov %r14,%rsi
1d5b: e8 00 00 00 00 callq 1d60 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xe10>
1d60: e9 98 f3 ff ff jmpq 10fd <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1ad>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:54
uint32 pitch = mRaw->pitch;
1d65: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1d6c <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xe1c>
1d6c: 48 8b 73 18 mov 0x18(%rbx),%rsi
1d70: e8 00 00 00 00 callq 1d75 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xe25>
1d75: 4c 8b 0d 00 00 00 00 mov 0x0(%rip),%r9 # 1d7c <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xe2c>
1d7c: 48 bf 69 2d 38 eb 08 movabs $0x9ddfea08eb382d69,%rdi
1d83: ea df 9d
1d86: 4c 8b 43 18 mov 0x18(%rbx),%r8
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
1d8a: 48 8b 43 50 mov 0x50(%rbx),%rax
1d8e: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
1d95: 4c 8b a3 c8 00 00 00 mov 0xc8(%rbx),%r12
1d9c: 0f 84 d1 f3 ff ff je 1173 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x223>
1da2: 4c 89 e7 mov %r12,%rdi
1da5: e8 00 00 00 00 callq 1daa <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xe5a>
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:54
1daa: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1db1 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xe61>
1db1: 4c 89 f6 mov %r14,%rsi
1db4: e8 00 00 00 00 callq 1db9 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xe69>
1db9: 4c 8b 0d 00 00 00 00 mov 0x0(%rip),%r9 # 1dc0 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xe70>
1dc0: 48 bf 69 2d 38 eb 08 movabs $0x9ddfea08eb382d69,%rdi
1dc7: ea df 9d
1dca: 4c 8b 43 18 mov 0x18(%rbx),%r8
1dce: 49 83 c6 50 add $0x50,%r14
1dd2: 41 f6 c6 07 test $0x7,%r14b
1dd6: 0f 84 01 f4 ff ff je 11dd <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x28d>
1ddc: e8 00 00 00 00 callq 1de1 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xe91>
1de1: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1de8 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xe98>
1de8: 4c 89 f6 mov %r14,%rsi
1deb: e8 00 00 00 00 callq 1df0 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xea0>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:55
int32 w = mRaw->dim.x;
1df0: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1df7 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xea7>
1df7: 48 8b 73 18 mov 0x18(%rbx),%rsi
1dfb: e8 00 00 00 00 callq 1e00 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xeb0>
1e00: 4c 8b 0d 00 00 00 00 mov 0x0(%rip),%r9 # 1e07 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xeb7>
1e07: 48 bf 69 2d 38 eb 08 movabs $0x9ddfea08eb382d69,%rdi
1e0e: ea df 9d
1e11: 4c 8b 43 18 mov 0x18(%rbx),%r8
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
1e15: 48 8b 43 50 mov 0x50(%rbx),%rax
1e19: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
1e20: 0f 84 2c f4 ff ff je 1252 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x302>
1e26: 4c 89 e7 mov %r12,%rdi
1e29: e8 00 00 00 00 callq 1e2e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xede>
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:55
1e2e: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1e35 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xee5>
1e35: 4c 89 f6 mov %r14,%rsi
1e38: e8 00 00 00 00 callq 1e3d <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xeed>
1e3d: 4c 8b 0d 00 00 00 00 mov 0x0(%rip),%r9 # 1e44 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xef4>
1e44: 48 bf 69 2d 38 eb 08 movabs $0x9ddfea08eb382d69,%rdi
1e4b: ea df 9d
1e4e: 4c 8b 43 18 mov 0x18(%rbx),%r8
1e52: 49 83 c6 48 add $0x48,%r14
1e56: 41 f6 c6 07 test $0x7,%r14b
1e5a: 0f 84 5c f4 ff ff je 12bc <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x36c>
1e60: e8 00 00 00 00 callq 1e65 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xf15>
1e65: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1e6c <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xf1c>
1e6c: 4c 89 f6 mov %r14,%rsi
1e6f: e8 00 00 00 00 callq 1e74 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xf24>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:57
assert(mRaw->dim.x > 0);
1e74: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1e7b <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xf2b>
1e7b: 48 8b 73 18 mov 0x18(%rbx),%rsi
1e7f: e8 00 00 00 00 callq 1e84 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xf34>
1e84: 4c 8b 0d 00 00 00 00 mov 0x0(%rip),%r9 # 1e8b <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xf3b>
1e8b: 48 bf 69 2d 38 eb 08 movabs $0x9ddfea08eb382d69,%rdi
1e92: ea df 9d
1e95: 4c 8b 43 18 mov 0x18(%rbx),%r8
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
1e99: 48 8b 43 50 mov 0x50(%rbx),%rax
1e9d: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
1ea4: 0f 84 84 f4 ff ff je 132e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x3de>
1eaa: 4c 89 e7 mov %r12,%rdi
1ead: e8 00 00 00 00 callq 1eb2 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xf62>
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:57
1eb2: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1eb9 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xf69>
1eb9: 4c 89 f6 mov %r14,%rsi
1ebc: e8 00 00 00 00 callq 1ec1 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xf71>
1ec1: 4c 8b 0d 00 00 00 00 mov 0x0(%rip),%r9 # 1ec8 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xf78>
1ec8: 48 bf 69 2d 38 eb 08 movabs $0x9ddfea08eb382d69,%rdi
1ecf: ea df 9d
1ed2: 4c 8b 43 18 mov 0x18(%rbx),%r8
1ed6: 49 83 c6 48 add $0x48,%r14
1eda: 41 f6 c6 07 test $0x7,%r14b
1ede: 0f 84 b4 f4 ff ff je 1398 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x448>
1ee4: e8 00 00 00 00 callq 1ee9 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xf99>
1ee9: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1ef0 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xfa0>
1ef0: 4c 89 f6 mov %r14,%rsi
1ef3: e8 00 00 00 00 callq 1ef8 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xfa8>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:58
assert(mRaw->dim.x % 32 == 0);
1ef8: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1eff <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xfaf>
1eff: 48 8b 73 18 mov 0x18(%rbx),%rsi
1f03: e8 00 00 00 00 callq 1f08 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xfb8>
1f08: 4c 8b 0d 00 00 00 00 mov 0x0(%rip),%r9 # 1f0f <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xfbf>
1f0f: 48 bf 69 2d 38 eb 08 movabs $0x9ddfea08eb382d69,%rdi
1f16: ea df 9d
1f19: 4c 8b 43 18 mov 0x18(%rbx),%r8
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
1f1d: 48 8b 43 50 mov 0x50(%rbx),%rax
1f21: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
1f28: 0f 84 df f4 ff ff je 140d <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x4bd>
1f2e: 4c 89 e7 mov %r12,%rdi
1f31: e8 00 00 00 00 callq 1f36 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xfe6>
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:58
1f36: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1f3d <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xfed>
1f3d: 4c 89 f6 mov %r14,%rsi
1f40: e8 00 00 00 00 callq 1f45 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xff5>
1f45: 4c 8b 0d 00 00 00 00 mov 0x0(%rip),%r9 # 1f4c <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0xffc>
1f4c: 48 bf 69 2d 38 eb 08 movabs $0x9ddfea08eb382d69,%rdi
1f53: ea df 9d
1f56: 4c 8b 43 18 mov 0x18(%rbx),%r8
1f5a: 49 83 c6 48 add $0x48,%r14
1f5e: 41 f6 c6 07 test $0x7,%r14b
1f62: 0f 84 0f f5 ff ff je 1477 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x527>
1f68: e8 00 00 00 00 callq 1f6d <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x101d>
1f6d: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1f74 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1024>
1f74: 4c 89 f6 mov %r14,%rsi
1f77: e8 00 00 00 00 callq 1f7c <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x102c>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:59
assert(mRaw->dim.y > 0);
1f7c: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1f83 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1033>
1f83: 48 8b 73 18 mov 0x18(%rbx),%rsi
1f87: e8 00 00 00 00 callq 1f8c <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x103c>
1f8c: 4c 8b 0d 00 00 00 00 mov 0x0(%rip),%r9 # 1f93 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1043>
1f93: 48 bf 69 2d 38 eb 08 movabs $0x9ddfea08eb382d69,%rdi
1f9a: ea df 9d
1f9d: 4c 8b 43 18 mov 0x18(%rbx),%r8
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
1fa1: 48 8b 43 50 mov 0x50(%rbx),%rax
1fa5: 80 b8 00 80 ff 7f 00 cmpb $0x0,0x7fff8000(%rax)
1fac: 0f 84 3a f5 ff ff je 14ec <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x59c>
1fb2: 4c 89 e7 mov %r12,%rdi
1fb5: e8 00 00 00 00 callq 1fba <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x106a>
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:59
1fba: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1fc1 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1071>
1fc1: 4c 89 f6 mov %r14,%rsi
1fc4: e8 00 00 00 00 callq 1fc9 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1079>
1fc9: 4c 8b 0d 00 00 00 00 mov 0x0(%rip),%r9 # 1fd0 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1080>
1fd0: 48 bf 69 2d 38 eb 08 movabs $0x9ddfea08eb382d69,%rdi
1fd7: ea df 9d
1fda: 4c 8b 43 18 mov 0x18(%rbx),%r8
1fde: 4d 8d 7e 48 lea 0x48(%r14),%r15
1fe2: 41 f6 c7 07 test $0x7,%r15b
1fe6: 0f 84 6a f5 ff ff je 1556 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x606>
1fec: e8 00 00 00 00 callq 1ff1 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10a1>
1ff1: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1ff8 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10a8>
1ff8: 4c 89 fe mov %r15,%rsi
1ffb: e8 00 00 00 00 callq 2000 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10b0>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:61
BitPumpLSB bits(input);
2000: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2007 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10b7>
2007: 48 8b 73 18 mov 0x18(%rbx),%rsi
200b: e8 00 00 00 00 callq 2010 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10c0>
2010: 4c 8b 43 18 mov 0x18(%rbx),%r8
2014: 4d 8d 70 10 lea 0x10(%r8),%r14
2018: 41 f6 c6 07 test $0x7,%r14b
201c: 0f 84 c9 f5 ff ff je 15eb <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x69b>
2022: e8 00 00 00 00 callq 2027 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10d7>
2027: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 202e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10de>
202e: 4c 89 f6 mov %r14,%rsi
2031: e8 00 00 00 00 callq 2036 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10e6>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:92
mRaw->setWithLookUp(p << 1, reinterpret_cast<uchar8*>(&dest[x + i * 2]),
2036: e8 00 00 00 00 callq 203b <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10eb>
203b: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2042 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10f2>
2042: 4c 89 f6 mov %r14,%rsi
2045: e8 00 00 00 00 callq 204a <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10fa>
204a: e8 00 00 00 00 callq 204f <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x10ff>
204f: e8 00 00 00 00 callq 2054 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1104>
2054: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 205b <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x110b>
205b: ba 02 00 00 00 mov $0x2,%edx
2060: 4c 89 fe mov %r15,%rsi
2063: e8 00 00 00 00 callq 2068 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1118>
2068: 44 8b 73 40 mov 0x40(%rbx),%r14d
206c: 41 89 c7 mov %eax,%r15d
206f: e8 00 00 00 00 callq 2074 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1124>
2074: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 207b <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x112b>
207b: 4c 89 f6 mov %r14,%rsi
207e: 4c 89 fa mov %r15,%rdx
2081: e8 00 00 00 00 callq 2086 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1136>
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
2086: 4c 89 e7 mov %r12,%rdi
2089: e8 00 00 00 00 callq 208e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x113e>
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:92
208e: 4c 89 f7 mov %r14,%rdi
2091: e8 00 00 00 00 callq 2096 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1146>
2096: 45 89 ee mov %r13d,%r14d
2099: e8 00 00 00 00 callq 209e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x114e>
209e: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 20a5 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1155>
20a5: ba 01 00 00 00 mov $0x1,%edx
20aa: 4c 89 f6 mov %r14,%rsi
20ad: e8 00 00 00 00 callq 20b2 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1162>
20b2: e8 00 00 00 00 callq 20b7 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1167>
20b7: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 20be <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x116e>
20be: 48 8b b3 80 00 00 00 mov 0x80(%rbx),%rsi
20c5: 4c 89 e2 mov %r12,%rdx
20c8: e8 00 00 00 00 callq 20cd <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x117d>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:87
p = (bits.getBits(7) << sh) + _min;
20cd: 41 89 c6 mov %eax,%r14d
20d0: 44 8b 7b 24 mov 0x24(%rbx),%r15d
20d4: e8 00 00 00 00 callq 20d9 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1189>
20d9: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 20e0 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1190>
20e0: 4c 89 f6 mov %r14,%rsi
20e3: 4c 89 fa mov %r15,%rdx
20e6: e8 00 00 00 00 callq 20eb <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x119b>
20eb: 49 89 fe mov %rdi,%r14
20ee: e8 00 00 00 00 callq 20f3 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11a3>
20f3: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 20fa <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11aa>
20fa: 4c 89 f6 mov %r14,%rsi
20fd: e8 00 00 00 00 callq 2102 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11b2>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:53
uchar8* data = mRaw->getData();
2102: e8 00 00 00 00 callq 2107 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11b7>
2107: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 210e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11be>
210e: 4c 89 f6 mov %r14,%rsi
2111: e8 00 00 00 00 callq 2116 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11c6>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:54
uint32 pitch = mRaw->pitch;
2116: e8 00 00 00 00 callq 211b <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11cb>
211b: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2122 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11d2>
2122: 4c 89 f6 mov %r14,%rsi
2125: e8 00 00 00 00 callq 212a <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11da>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:55
int32 w = mRaw->dim.x;
212a: e8 00 00 00 00 callq 212f <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11df>
212f: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2136 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11e6>
2136: 4c 89 f6 mov %r14,%rsi
2139: e8 00 00 00 00 callq 213e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11ee>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:57
assert(mRaw->dim.x > 0);
213e: e8 00 00 00 00 callq 2143 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11f3>
2143: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 214a <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x11fa>
214a: 4c 89 f6 mov %r14,%rsi
214d: e8 00 00 00 00 callq 2152 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1202>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:58
assert(mRaw->dim.x % 32 == 0);
2152: e8 00 00 00 00 callq 2157 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1207>
2157: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 215e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x120e>
215e: 4c 89 f6 mov %r14,%rsi
2161: e8 00 00 00 00 callq 2166 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1216>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:59
assert(mRaw->dim.y > 0);
2166: e8 00 00 00 00 callq 216b <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x121b>
216b: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2172 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1222>
2172: 4c 89 f6 mov %r14,%rsi
2175: e8 00 00 00 00 callq 217a <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x122a>
217a: 49 89 fe mov %rdi,%r14
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:62
for (uint32 y = t->start; y < t->end; y++) {
217d: e8 00 00 00 00 callq 2182 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1232>
2182: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2189 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1239>
2189: 4c 89 f6 mov %r14,%rsi
218c: e8 00 00 00 00 callq 2191 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1241>
rawspeed::RawImage::operator->() const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/common/RawImage.h:234
2191: 4c 89 f7 mov %r14,%rdi
2194: e8 00 00 00 00 callq 2199 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1249>
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:57
assert(mRaw->dim.x > 0);
2199: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 21a0 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1250>
21a0: 48 8d 35 00 00 00 00 lea 0x0(%rip),%rsi # 21a7 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1257>
21a7: 48 8d 0d 00 00 00 00 lea 0x0(%rip),%rcx # 21ae <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x125e>
21ae: ba 39 00 00 00 mov $0x39,%edx
21b3: e8 00 00 00 00 callq 21b8 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1268>
21b8: e8 00 00 00 00 callq 21bd <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x126d>
21bd: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 21c4 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1274>
21c4: e8 00 00 00 00 callq 21c9 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1279>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:58
assert(mRaw->dim.x % 32 == 0);
21c9: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 21d0 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1280>
21d0: 48 8d 35 00 00 00 00 lea 0x0(%rip),%rsi # 21d7 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1287>
21d7: 48 8d 0d 00 00 00 00 lea 0x0(%rip),%rcx # 21de <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x128e>
21de: ba 3a 00 00 00 mov $0x3a,%edx
21e3: e8 00 00 00 00 callq 21e8 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1298>
21e8: e8 00 00 00 00 callq 21ed <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x129d>
21ed: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 21f4 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x12a4>
21f4: e8 00 00 00 00 callq 21f9 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x12a9>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:59
assert(mRaw->dim.y > 0);
21f9: e8 00 00 00 00 callq 21fe <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x12ae>
21fe: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2205 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x12b5>
2205: 4c 89 f6 mov %r14,%rsi
2208: e8 00 00 00 00 callq 220d <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x12bd>
220d: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2214 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x12c4>
2214: 48 8d 35 00 00 00 00 lea 0x0(%rip),%rsi # 221b <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x12cb>
221b: 48 8d 0d 00 00 00 00 lea 0x0(%rip),%rcx # 2222 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x12d2>
2222: ba 3b 00 00 00 mov $0x3b,%edx
2227: e8 00 00 00 00 callq 222c <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x12dc>
222c: e8 00 00 00 00 callq 2231 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x12e1>
2231: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2238 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x12e8>
2238: e8 00 00 00 00 callq 223d <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x12ed>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:62
for (uint32 y = t->start; y < t->end; y++) {
223d: e8 00 00 00 00 callq 2242 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x12f2>
2242: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2249 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x12f9>
2249: 4c 89 f6 mov %r14,%rsi
224c: e8 00 00 00 00 callq 2251 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1301>
2251: 49 89 fe mov %rdi,%r14
2254: e8 00 00 00 00 callq 2259 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1309>
2259: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2260 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1310>
2260: 4c 89 f6 mov %r14,%rsi
2263: e8 00 00 00 00 callq 2268 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1318>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:63
auto* dest = reinterpret_cast<ushort16*>(&data[y * pitch]);
2268: 41 89 ce mov %ecx,%r14d
226b: e8 00 00 00 00 callq 2270 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1320>
2270: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2277 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1327>
2277: 4c 89 f6 mov %r14,%rsi
227a: 48 8b 93 a8 00 00 00 mov 0xa8(%rbx),%rdx
2281: e8 00 00 00 00 callq 2286 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1336>
2286: e8 00 00 00 00 callq 228b <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x133b>
228b: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2292 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1342>
2292: 48 8b b3 b0 00 00 00 mov 0xb0(%rbx),%rsi
2299: 48 8b 93 80 00 00 00 mov 0x80(%rbx),%rdx
22a0: e8 00 00 00 00 callq 22a5 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1355>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:65
bits.setBufferPosition(w * y);
22a5: 44 8b 73 6c mov 0x6c(%rbx),%r14d
22a9: e8 00 00 00 00 callq 22ae <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x135e>
22ae: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 22b5 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1365>
22b5: 48 8b 73 70 mov 0x70(%rbx),%rsi
22b9: 4c 89 f2 mov %r14,%rdx
22bc: e8 00 00 00 00 callq 22c1 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1371>
rawspeed::BitStream<rawspeed::PlainBitPumpTag, rawspeed::BitStreamCacheLeftInRightOut>::setBufferPosition(unsigned int)():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/BitPumpLSB.h:48
cache.cache = 0;
22c1: 48 8b bb 88 00 00 00 mov 0x88(%rbx),%rdi
22c8: e8 00 00 00 00 callq 22cd <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x137d>
rawspeed::BitStream<rawspeed::PlainBitPumpTag, rawspeed::BitStreamCacheLeftInRightOut>::peekBitsNoFill(unsigned int)():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/BitStream.h:170
22cd: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 22d4 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1384>
22d4: 48 8d 35 00 00 00 00 lea 0x0(%rip),%rsi # 22db <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x138b>
22db: 48 8d 0d 00 00 00 00 lea 0x0(%rip),%rcx # 22e2 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1392>
22e2: ba aa 00 00 00 mov $0xaa,%edx
22e7: e8 00 00 00 00 callq 22ec <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x139c>
22ec: e8 00 00 00 00 callq 22f1 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x13a1>
22f1: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 22f8 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x13a8>
22f8: e8 00 00 00 00 callq 22fd <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x13ad>
rawspeed::BitStreamCacheLeftInRightOut::peek(unsigned int) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/BitStream.h:63
return cache & ((1 << count) - 1);
22fd: 48 8b bb 88 00 00 00 mov 0x88(%rbx),%rdi
2304: e8 00 00 00 00 callq 2309 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x13b9>
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:69
for (int32 x = 0; x < w - 30;) {
2309: e8 00 00 00 00 callq 230e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x13be>
230e: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2315 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x13c5>
2315: ba 1e 00 00 00 mov $0x1e,%edx
231a: 48 8b 73 70 mov 0x70(%rbx),%rsi
231e: e8 00 00 00 00 callq 2323 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x13d3>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:76
while ((sh < 4) && ((0x80 << sh) <= (_max - _min)))
2323: 44 8b 73 44 mov 0x44(%rbx),%r14d
2327: 44 8b 7b 24 mov 0x24(%rbx),%r15d
232b: e8 00 00 00 00 callq 2330 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x13e0>
2330: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2337 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x13e7>
2337: 4c 89 f6 mov %r14,%rsi
233a: 4c 89 fa mov %r15,%rdx
233d: e8 00 00 00 00 callq 2342 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x13f2>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:95
x += ((x & 1) != 0) ? 31 : 1; // Skip to next 32 pixels
2342: 41 89 d6 mov %edx,%r14d
2345: 41 89 c7 mov %eax,%r15d
2348: e8 00 00 00 00 callq 234d <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x13fd>
234d: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2354 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1404>
2354: 4c 89 f6 mov %r14,%rsi
2357: 4c 89 fa mov %r15,%rdx
235a: e8 00 00 00 00 callq 235f <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x140f>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:62
for (uint32 y = t->start; y < t->end; y++) {
235f: 41 89 c6 mov %eax,%r14d
2362: e8 00 00 00 00 callq 2367 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1417>
2367: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 236e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x141e>
236e: ba 01 00 00 00 mov $0x1,%edx
2373: 4c 89 f6 mov %r14,%rsi
2376: e8 00 00 00 00 callq 237b <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x142b>
rawspeed::BitStream<rawspeed::PlainBitPumpTag, rawspeed::BitStreamCacheLeftInRightOut>::setBufferPosition(unsigned int)():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/BitPumpLSB.h:46
pos = newPos;
237b: 48 8b bb 90 00 00 00 mov 0x90(%rbx),%rdi
2382: e8 00 00 00 00 callq 2387 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1437>
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/BitPumpLSB.h:47
cache.fillLevel = 0;
2387: 48 8b 7b 48 mov 0x48(%rbx),%rdi
238b: e8 00 00 00 00 callq 2390 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1440>
rawspeed::BitStream<rawspeed::PlainBitPumpTag, rawspeed::BitStreamCacheLeftInRightOut>::peekBitsNoFill(unsigned int)():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/io/BitStream.h:170
assert(nbits <= cache.fillLevel);
2390: 48 8b 7b 48 mov 0x48(%rbx),%rdi
2394: e8 00 00 00 00 callq 2399 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1449>
rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:66
uint32 random = bits.peekBits(24);
2399: 48 8b 7b 78 mov 0x78(%rbx),%rdi
239d: e8 00 00 00 00 callq 23a2 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1452>
23a2: eb 06 jmp 23aa <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x145a>
23a4: eb 04 jmp 23aa <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x145a>
23a6: eb 02 jmp 23aa <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x145a>
23a8: eb 00 jmp 23aa <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x145a>
23aa: 49 89 c6 mov %rax,%r14
23ad: 4c 8b 63 38 mov 0x38(%rbx),%r12
23b1: eb 0e jmp 23c1 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1471>
23b3: 49 89 c6 mov %rax,%r14
23b6: 4c 8b 63 38 mov 0x38(%rbx),%r12
23ba: 4c 8b ab a0 00 00 00 mov 0xa0(%rbx),%r13
23c1: 4c 8b 7b 28 mov 0x28(%rbx),%r15
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:97
}
23c5: 41 c6 45 0e f8 movb $0xf8,0xe(%r13)
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:98
}
23ca: 48 8b 7b 60 mov 0x60(%rbx),%rdi
23ce: e8 00 00 00 00 callq 23d3 <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x1483>
23d3: 41 c7 45 04 f8 f8 f8 movl $0xf8f8f8f8,0x4(%r13)
23da: f8
23db: 41 c6 45 08 f8 movb $0xf8,0x8(%r13)
23e0: 49 c7 07 0e 36 e0 45 movq $0x45e0360e,(%r15)
23e7: 4d 85 e4 test %r12,%r12
23ea: 74 22 je 240e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x14be>
23ec: 48 b8 f5 f5 f5 f5 f5 movabs $0xf5f5f5f5f5f5f5f5,%rax
23f3: f5 f5 f5
23f6: 49 89 45 00 mov %rax,0x0(%r13)
23fa: 49 89 45 08 mov %rax,0x8(%r13)
23fe: 49 8b 44 24 78 mov 0x78(%r12),%rax
2403: c6 00 00 movb $0x0,(%rax)
2406: 4c 89 f7 mov %r14,%rdi
2409: e8 00 00 00 00 callq 240e <rawspeed::SonyArw2Decompressor::decompressThreaded(rawspeed::RawDecompressorThread const*) const+0x14be>
240e: c5 f8 57 c0 vxorps %xmm0,%xmm0,%xmm0
2412: c4 c1 78 11 45 00 vmovups %xmm0,0x0(%r13)
2418: 4c 89 f7 mov %r14,%rdi
241b: e8 00 00 00 00 callq 2420 <asan.module_ctor>
0000000000002420 <asan.module_ctor>:
asan.module_ctor():
2420: 50 push %rax
2421: e8 00 00 00 00 callq 2426 <asan.module_ctor+0x6>
2426: e8 00 00 00 00 callq 242b <asan.module_ctor+0xb>
242b: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2432 <asan.module_ctor+0x12>
2432: be 27 00 00 00 mov $0x27,%esi
2437: e8 00 00 00 00 callq 243c <asan.module_ctor+0x1c>
243c: 58 pop %rax
243d: c3 retq
243e: 66 90 xchg %ax,%ax
0000000000002440 <asan.module_dtor>:
asan.module_dtor():
2440: 50 push %rax
2441: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2448 <asan.module_dtor+0x8>
2448: be 27 00 00 00 mov $0x27,%esi
244d: e8 00 00 00 00 callq 2452 <asan.module_dtor+0x12>
2452: 58 pop %rax
2453: c3 retq
Disassembly of section .gcc_except_table:
0000000000000000 <GCC_except_table0>:
GCC_except_table0():
0: ff 9b 5d 03 5b 00 lcall *0x5b035d(%rbx)
6: 00 00 add %al,(%rax)
8: 00 29 add %ch,(%rcx)
a: 08 00 or %al,(%rax)
c: 00 00 add %al,(%rax)
e: 00 00 add %al,(%rax)
10: 00 00 add %al,(%rax)
12: 29 08 sub %ecx,(%rax)
14: 00 00 add %al,(%rax)
16: 10 00 adc %al,(%rax)
18: 00 00 add %al,(%rax)
1a: 9f lahf
1b: 0e (bad)
1c: 00 00 add %al,(%rax)
1e: 00 39 add %bh,(%rcx)
20: 08 00 or %al,(%rax)
22: 00 8c 02 00 00 00 00 add %cl,0x0(%rdx,%rax,1)
29: 00 00 add %al,(%rax)
2b: 00 c5 add %al,%ch
2d: 0a 00 or (%rax),%al
2f: 00 15 00 00 00 95 add %dl,-0x6b000000(%rip) # ffffffff95000035 <asan.module_dtor+0xffffffff94ffdbf5>
35: 0e (bad)
36: 00 00 add %al,(%rax)
38: 00 da add %bl,%dl
3a: 0a 00 or (%rax),%al
3c: 00 40 02 add %al,0x2(%rax)
3f: 00 00 add %al,(%rax)
41: 00 00 add %al,(%rax)
43: 00 00 add %al,(%rax)
45: 00 1a add %bl,(%rdx)
47: 0d 00 00 18 00 or $0x180000,%eax
4c: 00 00 add %al,(%rax)
4e: 9a (bad)
4f: 0e (bad)
50: 00 00 add %al,(%rax)
52: 00 32 add %dh,(%rdx)
54: 0d 00 00 17 02 or $0x2170000,%eax
59: 00 00 add %al,(%rax)
5b: 00 00 add %al,(%rax)
5d: 00 00 add %al,(%rax)
...
0000000000000060 <GCC_except_table4>:
GCC_except_table4():
60: ff 9b 29 03 27 00 lcall *0x270329(%rbx)
66: 00 00 add %al,(%rax)
68: 00 8f 01 00 00 00 add %cl,0x1(%rdi)
6e: 00 00 add %al,(%rax)
70: 00 00 add %al,(%rax)
72: 8f 01 popq (%rcx)
74: 00 00 add %al,(%rax)
76: 1b 00 sbb (%rax),%eax
78: 00 00 add %al,(%rax)
7a: d9 01 flds (%rcx)
7c: 00 00 add %al,(%rax)
7e: 00 aa 01 00 00 a9 add %ch,-0x56ffffff(%rdx)
...
000000000000008c <GCC_except_table6>:
GCC_except_table6():
8c: ff 9b ea 80 80 00 lcall *0x8080ea(%rbx)
92: 03 68 00 add 0x0(%rax),%ebp
95: 00 00 add %al,(%rax)
97: 00 18 add %bl,(%rax)
99: 08 00 or %al,(%rax)
9b: 00 00 add %al,(%rax)
9d: 00 00 add %al,(%rax)
9f: 00 00 add %al,(%rax)
a1: 18 08 sbb %cl,(%rax)
a3: 00 00 add %al,(%rax)
a5: 0d 00 00 00 5a or $0x5a000000,%eax
aa: 14 00 adc $0x0,%al
ac: 00 00 add %al,(%rax)
ae: b0 08 mov $0x8,%al
b0: 00 00 add %al,(%rax)
b2: 16 (bad)
b3: 00 00 add %al,(%rax)
b5: 00 58 14 add %bl,0x14(%rax)
b8: 00 00 add %al,(%rax)
ba: 00 c6 add %al,%dh
bc: 08 00 or %al,(%rax)
be: 00 10 add %dl,(%rax)
c0: 00 00 add %al,(%rax)
c2: 00 56 14 add %dl,0x14(%rsi)
c5: 00 00 add %al,(%rax)
c7: 00 d6 add %dl,%dh
c9: 08 00 or %al,(%rax)
cb: 00 10 add %dl,(%rax)
cd: 00 00 add %al,(%rax)
cf: 00 54 14 00 add %dl,0x0(%rsp,%rdx,1)
d3: 00 00 add %al,(%rax)
d5: e6 08 out %al,$0x8
d7: 00 00 add %al,(%rax)
d9: 0f 00 00 sldt (%rax)
dc: 00 52 14 add %dl,0x14(%rdx)
df: 00 00 add %al,(%rax)
e1: 00 9a 09 00 00 8c add %bl,-0x73fffff7(%rdx)
e7: 01 00 add %eax,(%rax)
e9: 00 63 14 add %ah,0x14(%rbx)
ec: 00 00 add %al,(%rax)
ee: 00 26 add %ah,(%rsi)
f0: 0b 00 or (%rax),%eax
f2: 00 aa 09 00 00 00 add %ch,0x9(%rdx)
f8: 00 00 add %al,(%rax)
...
00000000000000fc <GCC_except_table11>:
GCC_except_table11():
fc: ff 9b 29 03 27 00 lcall *0x270329(%rbx)
102: 00 00 add %al,(%rax)
104: 00 f8 add %bh,%al
...
10e: f8 clc
10f: 00 00 add %al,(%rax)
111: 00 0d 00 00 00 b5 add %cl,-0x4b000000(%rip) # ffffffffb5000117 <asan.module_dtor+0xffffffffb4ffdcd7>
117: 01 00 add %eax,(%rax)
119: 00 00 add %al,(%rax)
11b: 05 01 00 00 08 add $0x8000001,%eax
120: 01 00 add %eax,(%rax)
122: 00 00 add %al,(%rax)
124: 00 00 add %al,(%rax)
...
0000000000000128 <GCC_except_table13>:
GCC_except_table13():
128: ff 9b 29 03 27 00 lcall *0x270329(%rbx)
12e: 00 00 add %al,(%rax)
130: 00 71 00 add %dh,0x0(%rcx)
133: 00 00 add %al,(%rax)
135: 00 00 add %al,(%rax)
137: 00 00 add %al,(%rax)
139: 00 71 00 add %dh,0x0(%rcx)
13c: 00 00 add %al,(%rax)
13e: 0a 00 or (%rax),%al
140: 00 00 add %al,(%rax)
142: ce (bad)
143: 00 00 add %al,(%rax)
145: 00 00 add %al,(%rax)
147: 7b 00 jnp 149 <GCC_except_table13+0x21>
149: 00 00 add %al,(%rax)
14b: 66 00 00 data16 add %al,(%rax)
14e: 00 00 add %al,(%rax)
150: 00 00 add %al,(%rax)
...
0000000000000154 <GCC_except_table14>:
GCC_except_table14():
154: ff 9b 29 03 27 00 lcall *0x270329(%rbx)
15a: 00 00 add %al,(%rax)
15c: 00 8f 01 00 00 00 add %cl,0x1(%rdi)
162: 00 00 add %al,(%rax)
164: 00 00 add %al,(%rax)
166: 8f 01 popq (%rcx)
168: 00 00 add %al,(%rax)
16a: 1b 00 sbb (%rax),%eax
16c: 00 00 add %al,(%rax)
16e: d9 01 flds (%rcx)
170: 00 00 add %al,(%rax)
172: 00 aa 01 00 00 a9 add %ch,-0x56ffffff(%rdx)
...
0000000000000180 <GCC_except_table18>:
GCC_except_table18():
180: ff 9b 29 03 27 00 lcall *0x270329(%rbx)
186: 00 00 add %al,(%rax)
188: 00 9d 00 00 00 00 add %bl,0x0(%rbp)
18e: 00 00 add %al,(%rax)
190: 00 00 add %al,(%rax)
192: 9d popfq
193: 00 00 add %al,(%rax)
195: 00 16 add %dl,(%rsi)
197: 00 00 add %al,(%rax)
199: 00 e5 add %ah,%ch
19b: 00 00 add %al,(%rax)
19d: 00 00 add %al,(%rax)
19f: b3 00 mov $0x0,%bl
1a1: 00 00 add %al,(%rax)
1a3: 45 00 00 add %r8b,(%r8)
1a6: 00 00 add %al,(%rax)
1a8: 00 00 add %al,(%rax)
...
00000000000001ac <GCC_except_table27>:
GCC_except_table27():
1ac: ff 9b a2 80 80 00 lcall *0x8080a2(%rbx)
1b2: 03 1a add (%rdx),%ebx
1b4: 05 01 00 00 05 add $0x5000001,%eax
1b9: 00 00 add %al,(%rax)
1bb: 00 3f add %bh,(%rdi)
1bd: 02 00 add (%rax),%al
1bf: 00 01 add %al,(%rcx)
1c1: 0a 01 or (%rcx),%al
1c3: 00 00 add %al,(%rax)
1c5: 45 01 00 add %r8d,(%r8)
1c8: 00 00 add %al,(%rax)
1ca: 00 00 add %al,(%rax)
1cc: 00 00 add %al,(%rax)
1ce: 01 00 add %eax,(%rax)
1d0: 00 00 add %al,(%rax)
...
Disassembly of section .group:
0000000000000000 <.group>:
SonyArw2Decompressor():
/home/lebedevri/rawspeed/build-Clang-SANITIZE/../src/librawspeed/decompressors/SonyArw2Decompressor.cpp:36
: AbstractParallelizedDecompressor(img) {
0: 01 00 add %eax,(%rax)
2: 00 00 add %al,(%rax)
4: 06 (bad)
5: 00 00