Skip to content

Instantly share code, notes, and snippets.

@LebedevRI

LebedevRI/gist:e06bdfbde47319d1c15f65bd1ebf1f47

Created Dec 27, 2017
Star
Embed
What would you like to do?
Learn more about clone URLs
Download ZIP
Raw
gistfile1.txt
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