[lsan] [mips] adding support of lsan for mips64/mips64el arch

[sdkie]

Summary

Mostly changes are specific to MIPS architecture to support leak sanitizer

[earthdok]

Thanks for working on this. We are unlikely to accept patches that enable LSan on 32-bit architectures. Experiments on x86 and ARM have shown that the smaller address space makes leak detection very unreliable, to the point where it's difficult to even test the tool. See e.g. the discussion at https://code.google.com/p/address-sanitizer/issues/detail?id=294

In-depth review of the 64-bit part of the patch will follow.

[earthdok]

Actually it just dawned me that there is no MIPS64 support in this patch, so there's nothing to review. I did not realize this until I was halfway through reviewing it, so I'll post those comments anyway.

lib/lsan/lsan_allocator.cc

32

This is not right. This field must be wide enough to hold kMaxAllowedMallocSize (3*2^30).

lib/lsan/lsan_common.cc

146

Why can't this be a constant like on x86_64? Maybe a slightly smaller one if 16k is too much. I don't think you can get any measurable performance improvement from fine-tuning this.

lib/sanitizer_common/sanitizer_linux.cc

557

I don't get it. How does it work then?

904

Please actually implement clone(). There is a comment above the x86_64 implementation explaining why it is needed.

[sdkie]

Thanks for your comments. I will try to update the patch for MIPS64.
Few people are also working on 32-bit MSAN and 32-bit TSAN for MIPS.
can anyone please comment on them, as we don't see i386 implementation of those sanitizers also.

[earthdok]

+ eugenis, dvyukov for MSan, TSan

I believe a 32-bit TSan would also be a problem.

[eugenis]

32-bit MSan is theoretically possible, but due to the size of the shadow mapping it may be challenging to find a working memory layout. You would also end up with very low available memory for the application.

[dvyukov]

In D5616#7, @kumarsukhani wrote:

Few people are also working on 32-bit MSAN and 32-bit TSAN for MIPS.
can anyone please comment on them, as we don't see i386 implementation of those sanitizers also.

Comment on what exactly?
Generally 32-bit tsan would be nice. But there is obviously a problem with address space size, e.g. currently address range just for traces is larger than whole 32-bit address space. I am also concerned about potential significant increase in code size and complexity.
Discuss design up-front here:
https://groups.google.com/forum/#!forum/thread-sanitizer

[kcc]

msan and especially tsan are very hard on 32-bit.
Please do not even attempt 32-bit MIPS tsan/msan before making them work on
64-bit MIPS (should be easy)
*and* on 32-bit x86 (hard, complex, low value/priority, the resulting tool
will be very restricted).

asan on 32-bit MIPS is a different story -- it should be easy.

--kcc

[sdkie]

It will be great if someone will add this details on http://compiler-rt.llvm.org.

@kcc: @mohit.bhakkad has already submitted 32-bt msan patch http://reviews.llvm.org/D5672.
He actually got good results with it.

[sdkie]

@pcc: I tried DFSAN for 32-bit MIPS and got 5 test cases pass out of 7.
Any plans to accept 32-bit DFSAN patches ?

[sdkie]

made changes for 64-bit MIPS architectures

[sdkie]

lib/sanitizer_common/sanitizer_linux.cc

906

@earthdok: After the basic support for mips64 is merged, I will start working on implementing clone in assembly.
Btw using syscall(clone,..) is not a good option for this?

[sdkie]

@earthdok: whether we should check for 'mips64' instead of 'mips' as we are anyways not supporting 32-bit mips for LSAN?

[sdkie]

minor change in CanBeAHeapPointer, the virtual addressable bits for mips are 40 and not 39

[earthdok]

Sorry, I haven't had the time to review this yet. I'll take a look this week.

[earthdok]

How did you test this patch?

In D5616#23, @kumarsukhani wrote:

@earthdok: whether we should check for 'mips64' instead of 'mips' as we are anyways not supporting 32-bit mips for LSAN?

That would be more consistent, yes (we do check for __x86_64__).
Is __mips64__ the right symbol? __mips64 seems to be more prevalent, and https://code.google.com/p/android/issues/detail?id=75904 suggests __mips64__ may not be defined when building with gcc.

lib/lsan/lsan_allocator.cc

28

(SANITIZER_WORDSIZE == 64) is unnecessary, please remove it.

lib/lsan/lsan_common.cc

147

please remove (SANITIZER_WORDSIZE == 64)

lib/sanitizer_common/sanitizer_linux.cc

906

Please leave a TODO, then.

Btw using syscall(clone,..) is not a good option for this?

It wouldn't work at all. We'd crash when returning from syscall() in the child process, because we're now in the beginning of a new stack and there isn't a previous stack frame to return to.

lib/sanitizer_common/sanitizer_linux_libcdep.cc

257

Why do you need this? Just write to descr_addr.

263

const uptr kTlsTcbOffset
const uptr kTlsPreTcbSize

303

Is this correct? I thought in variant 2 the static TLS was located before the TCB?

[sdkie]

minor fixes as per comments of earthdok

[sdkie]

How did you test this patch?

I just ran the testcases of lsan on mips rpe-100 board, and majority of LeakSanitizer-Standalone test cases are working.

Is this correct? I thought in variant 2 the static TLS was located before the TCB?

Sorry, it was a typing mistake. MIPS uses variant 1

[sdkie]

changed 'AppendPointer' function to print 40 bits for mips64 instead of 48 bits

[samsonov]

lib/lsan/lsan_common.cc

147

typo: shouldn't this be __mips64?

lib/sanitizer_common/sanitizer_printf.cc

118 ↗

(On Diff #15521)

Please introduce a named constant for 10/12 instead with a comment.

[earthdok]

In D5616#32, @kumarsukhani wrote:

How did you test this patch?

I just ran the testcases of lsan on mips rpe-100 board, and majority of LeakSanitizer-Standalone test cases are working.

Which tests are failing and why? And what about LeakSanitizer-AddressSanitizer?

(I imagine at least use_tls_pthread_specific_static.cc would be failing because of the incorrect value of kTlsPreTcbSize.)

lib/sanitizer_common/sanitizer_linux_libcdep.cc

257

Comment indentation should match code indentation.

259

This comment doesn't give the complete picture. How about:

"MIPS uses TLS variant I. The thread pointer (in hardware register $29) points to the end of the TCB + 0x7000. The pthread_descr structure is immediately in front of the TCB. kTlsPreTcbSize includes the size of the TCB and the size of pthread_descr."

262

This can't be correct. How did you obtain this constant?
In glibc sources we have:

95 # define TLS_PRE_TCB_SIZE \
96 (sizeof (struct pthread) \
97 + ((sizeof (tcbhead_t) + TLS_TCB_ALIGN - 1) & ~(TLS_TCB_ALIGN - 1)))

tcbhead_t alone is 16 bytes. struct pthread is much bigger.

This also needs a test, like the one we have for kThreadDescriptorSize. The size of struct pthread will change between glibc versions.

304

I don't think this gives the correct TLS size. Your kTlsPreTcbSize above is too small, so *addr as you're currently computing it is too big. So if *addr is incorrect, *size can't be correct - otherwise we would be accessing past the end of the TLS and LSan would crash.

Probably you need something like

*size = GetTlsSize() + kTlsPreTcbSize;

or

*size = GetTlsSize() + kTlsPreTcbSize + kTlsTcbOffset;

I can't say what exactly without digging into glibc sources. Could you please do that?

[sdkie]

Which tests are failing and why?

Following test cases are failing:

1. suppressions_default.cc
2. suppressions_file.cc
3. swapcontext.cc
4. use_tls_pthread_specific_dynamic.cc
5. use_tls_pthread_specific_static.cc

And what about LeakSanitizer-AddressSanitizer?

asan is not yet supported for mips64, I am simultaneously working on it.
I will submit its patch soon.

I can't say what exactly without digging into glibc sources. Could you please do that?

Thanks for your comments. I will try to fix the addr and size of TLS.
Actually, I have very limited knowledge of TLS, So I will be really thankful if anyone is ready to help me.

[sdkie]

• updated TLS addr and size
• introduced SANITIZER_POINTER_FORMAT_LENGTH variable

[sdkie]

@kcc @earthdok: any comments on current revision ?
I will soon update this revision to change SanitizerAllocator64 to SanitizerAllocator32.

[sdkie]

using SanitizerAllocator32 instead of SanitizerAllocator64 for mips64 as its address space is just 40-bit

[earthdok]

lib/sanitizer_common/sanitizer_linux.cc

900–907

Where did clone go?

lib/sanitizer_common/sanitizer_linux_libcdep.cc

206

please move this #ifdef into the if block at line 201:

#if defined(__x86_64__) || defined(__i386__)
if (..)
val = ...
else if (...)
val = ...
#elif defined(__mips__)
val = ...
#endif

208

How did you obtain those numbers?

We need some kind of test for those, similar to SanitizerLinux.ThreadDescriptorSize (but taking into account the actual TLS layout on MIPS).

257

Please remove the blank lines here and below.

261

s/"//

263

Only this constant is part of the ABI. kTcbHead and kTlsTcbAlign could theoretically change, so we need to test them as well.

Instead of ThreadDescriptorSize(), we probably want to expose TlsPreTcbSize(). But please figure out what the test will look like before making this change.

266

This naming style is used for constants. s/kThreadPointer/thread_pointer/ and please move this closer to the asm block.

268

const

lib/sanitizer_common/sanitizer_printf.cc

116 ↗

(On Diff #15920)

Accidental change?

[sdkie]

minor fixes as per comment of earthdok

[sdkie]

lib/sanitizer_common/sanitizer_linux.cc

900–907

It was a mistake

lib/sanitizer_common/sanitizer_linux_libcdep.cc

208

I obtained .i file by compiling GLIBC 2.19-13 (same which is available on my board), and calculated those values

263

can we use test of minor number, the way x86_64 has done ?

lib/sanitizer_common/sanitizer_printf.cc

116 ↗

(On Diff #15920)

no that change is already merged in http://reviews.llvm.org/D6024 patch

[earthdok]

lib/sanitizer_common/sanitizer_linux_libcdep.cc

263

That's how you guess the size. But you still need a testcase to check that your guess is correct. Take a look at lib/sanitizer_common/tests/sanitizer_linux_test.cc, specifically TEST(SanitizerLinux, ThreadDescriptorSize).

[earthdok]

Also, please take note of test/asan/lit.cfg and test/asan/Unit/lit.site.cfg.in. Those configs enable leak detection in ASan tests on x86_64. Please make sure that is the case for MIPS as well.

[sdkie]

Also, please take note of test/asan/lit.cfg and test/asan/Unit/lit.site.cfg.in. Those configs enable leak detection in ASan tests on x86_64. Please make sure that is the case for MIPS as well.

Thanks, I will submit lsan testing patch separately once this patch is accepted.

lib/sanitizer_common/sanitizer_linux_libcdep.cc

263

how to run this tests on x86_64 ?
I think so this tests doesn't execute when I run

make check-all

[earthdok]

lib/sanitizer_common/sanitizer_linux_libcdep.cc

263

"check-all" includes this testcase. You can verify by adding an invalid assertion to the test - check-all will fail.

The smallest subset that includes this test case is "check-sanitizer"

Note that the test case itself is under #ifdef x86_64/i386

[sdkie]

I doubt whether its really working.
Even after doing following change 'make check-lsan' is working fine on x86_64

TEST(SanitizerLinux, ThreadDescriptorSize) {
   pthread_t tid;
   void *result;
-  ASSERT_EQ(0, pthread_create(&tid, 0, thread_descriptor_size_test_func, 0));
-  ASSERT_EQ(0, pthread_join(tid, &result));
+  ASSERT_EQ(1, pthread_create(&tid, 0, thread_descriptor_size_test_func, 0));
+  ASSERT_EQ(1, pthread_join(tid, &result));
   EXPECT_EQ((uptr)result, ThreadDescriptorSize());
 }

[earthdok]

In D5616#57, @kumarsukhani wrote:

I doubt whether its really working.
Even after doing following change 'make check-lsan' is working fine on x86_64

check-lsan doesn't run this test. check-sanitizer does.

[sdkie]

@earthdok: with check-sanitizer also I see no failures because of above changes in assertion.

Can you please commit this current version of patch ? if no more changes are require
I will update lib/sanitizer_common/tests/sanitizer_linux_test.cc file so that same check works for mips.
What do you think ?

[sdkie]

And compiler-rt master build is not clean, I am getting following failures on x86_64:

Failing Tests (14):

  AddressSanitizer32 :: TestCases/Linux/interface_symbols_linux.c
  AddressSanitizer32 :: TestCases/default_blacklist.cc
  AddressSanitizer32 :: TestCases/lsan_annotations.cc
  AddressSanitizer64 :: TestCases/Linux/interface_symbols_linux.c
  AddressSanitizer64 :: TestCases/default_blacklist.cc
  DataFlowSanitizer :: basic.c
  DataFlowSanitizer :: custom.cc
  DataFlowSanitizer :: dump_labels.c
  DataFlowSanitizer :: fncall.c
  DataFlowSanitizer :: label_count.c
  DataFlowSanitizer :: propagate.c
  DataFlowSanitizer :: vararg.c
  DataFlowSanitizer :: write_callback.c
  MemorySanitizer :: default_blacklist.cc

Expected Passes    : 708
Expected Failures  : 15
Unsupported Tests  : 194
Unexpected Failures: 14

[earthdok]

Something must be wrong with your checkout. For me ninja check-sanitizer starts failing when I reverse the assertions in the test.

In D5616#59, @kumarsukhani wrote:

@earthdok: with check-sanitizer also I see no failures because of above changes in assertion.

Can you please commit this current version of patch ? if no more changes are require
I will update lib/sanitizer_common/tests/sanitizer_linux_test.cc file so that same check works for mips.
What do you think ?

I'm sorry, I'm not comfortable committing without this test. This has caused far too many issues in the past.

By the way, I looked at the Glibc sources and it turns out your TLS calculation is incorrect even if ThreadDescriptorSize() is correct. Consider _dl_allocate_tls_storage():

332 #if TLS_DTV_AT_TP
333   /* Memory layout is:
334      [ TLS_PRE_TCB_SIZE ] [ TLS_TCB_SIZE ] [ TLS blocks ]
335                           ^ This should be returned.  */
336   size += (TLS_PRE_TCB_SIZE + GL(dl_tls_static_align) - 1)
337           & ~(GL(dl_tls_static_align) - 1);
338 #endif

The size we get from _dl_get_tls_static_info is GL(dl_tls_static_align). This means that the upper TLS boundary as you compute it is off by TLS_PRE_TCB_SIZE.

We have very few tests for this stuff so please make sure you understand thoroughly how TLS is laid out - don't just rely on tests passing.

[sdkie]

Something must be wrong with your checkout. For me ninja check-sanitizer starts failing when I reverse the assertions in the test.

I am actually running make check-sanitizer. I am not sure what is the difference between them.
Today I first build clang/llvm from master, and then did testing using compiler-rt master branch.

Thanks for you comment, it will surely help me to fix TLS calculation.

[earthdok]

In D5616#62, @kumarsukhani wrote:

Something must be wrong with your checkout. For me ninja check-sanitizer starts failing when I reverse the assertions in the test.

I am actually running make check-sanitizer. I am not sure what is the difference between them.

Hmm. What commands do you use to configure and build?

Today I first build clang/llvm from master, and then did testing using compiler-rt master branch.

Thanks for you comment, it will surely help me to fix TLS calculation.

Please actually look at the source and don't rely on my comments, I may have missed something.

[sdkie]

What commands do you use to configure and build?

CC=clang CXX=clang++  cmake ../compiler-rt -DLLVM_CONFIG_PATH=/home/kms/LLVM_x86/install/bin/llvm-config  -DCOMPILER_RT_INSTALL_PATH=/home/kms/LLVM_x86/install/lib/clang/3.6.0
make install
make check-all

Clang path : /home/kms/LLVM_x86/install/bin/clang
make check-sanitizer output: https://gist.github.com/SDkie/6d2013b72ea67d77d094

[earthdok]

In D5616#64, @kumarsukhani wrote:

make check-sanitizer output: https://gist.github.com/SDkie/6d2013b72ea67d77d094

Yeah, this doesn't look right. In your log it runs only the LIT tests from compiler-rt/test/sanitizer_common/. But there are many more unit tests under compiler-rt/lib/sanitizer_common/test/ which check-sanitizer is also supposed to run.

samsonov@, do you have any idea about this?

[sdkie]

Yeah, this doesn't look right. In your log it runs only the LIT tests from compiler-rt/test/sanitizer_common/.

Yes, make check-* runs only LIT tests

[samsonov]

Right, you'd have to enable sanitizer_common unit tests by baking support for mips64 to lib/sanitizer_common/tests/CMakeLists.txt.

[earthdok]

In D5616#67, @samsonov wrote:

Right, you'd have to enable sanitizer_common unit tests by baking support for mips64 to lib/sanitizer_common/tests/CMakeLists.txt.

We're talking about x86_64.

[sdkie]

@earthdok: can you share your configure and build commands/scripts ?
So that I can get those test cases running.

[earthdok]

I'm actually doing a bootstrap build so it's a bit complicated. But it shouldn't matter, something like this should work just as well (assuming you have g++ 4.8 installed):

cmake ../llvm/ -G Ninja -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=True
ninja check-sanitizer

Which commands are you using?

[sdkie]

I am using following commands:

CC=clang CXX=clang++  cmake ../compiler-rt -DLLVM_CONFIG_PATH=/home/kms/LLVM_x86/install/bin/llvm-config  -DCOMPILER_RT_INSTALL_PATH=/home/kms/LLVM_x86/install/lib/clang/3.6.0
make
make install
make check-sanitizer

[earthdok]

Ah, I see. You're doing a standalone compiler-rt build, whereas I'm building from the LLVM tree. Apparently there's a bug in the test configuration for standalone builds. Alexey will take a look at it today - you can either wait for him to fix it, or checkout LLVM and do an in-tree build.

[samsonov]

If you're running a standalone compiler-rt build, you'd also have to pass -DCOMPILER_RT_INCLUDE_TESTS=ON to enable unit tests.

[sdkie]

updated TLS part after studying Glibc code

[sdkie]

@earthdok: I am not sure if mips stores the value of pthread struct size anywhere the way x86 does to write a UNIT test for pthread struct size.
Btw why x86_64 is using the hard codes values, even though they have direct access to pthread structure size?

[earthdok]

In D5616#76, @kumarsukhani wrote:

@earthdok: I am not sure if mips stores the value of pthread struct size anywhere the way x86 does to write a UNIT test for pthread struct size.
Btw why x86_64 is using the hard codes values, even though they have direct access to pthread structure size?

The test that we have for x86_64 doesn't read the size from the struct. Rather, it relies on assumptions regarding how the TCB is positioned relative to the beginning of the stack. We could use that method to actually determine the TCB size at runtime. However: 1) it requires spawning a thread, which is pretty awkward and intrusive to user code and 2) we would have no way of knowing if those assumptions no longer held true.

If the size was stored in the struct itself, that would certainly make things easier, but to the best of my knowledge it isn't.

lib/sanitizer_common/sanitizer_linux_libcdep.cc

200

No need to introduce a separate constant, just return this.

267

Let's drop "get", to be consistent with ThreadSelfOffset(), ThreadDescriptorSize().

334

There's already a "|| defined(mips)" above, so you will never hit this branch.

335

const uptr kDlTlsStaticAlign

336

Why not do this calculation once in InitTlsSize().

339

You're breaking compilation on every arch other than x86-64 and MIPS. Why?

[sdkie]

updated patch as per suggestions of earthdok

[sdkie]

@earthdok: did you got time to look at my new patch?
Actually I am going on a long holiday after couple of day, @mohit.bhakkad and @Sagar will continue my work.

[earthdok]

Sorry about the long wait. I had a long vacation as well.

The changes in the last patch look ok. However, as we discussed, this CL still needs a test before I can accept it.

lib/sanitizer_common/sanitizer_linux_libcdep.cc

170

whitespace after "-", indent

[slthakur]

Hi @earthdok,

As per my understanding of the TLS memory layout and the TLS part required for sanitizers, we need to get the range of static TLS area in GetTls ().

X86_64 uses tls variant 2 and TLS_TCB_AT_TP is set to 1 in tls.h. So the size we get from __dl_tls_get_static_info () includes the thread descriptor size along with size of static TLS area as per the following code in elf/dl-tls.c:

223  GL(dl_tls_static_used) = offset;
224  GL(dl_tls_static_size) = (roundup (offset + TLS_STATIC_SURPLUS, max_align)
225			    + TLS_TCB_SIZE);

Therefore we need the Thread Descriptor Size, so that we can exclude it from the size we get from __dl_tls_get_static_info ().

But MIPS uses TLS variant 1 and TLS_DTV_AT_TP is set to 1 in tls.h. So the size we get from __dl_tls_get_static_info () is only the size of static TLS area and does not include the thread descriptor size as per the following code in elf/dl-tls.c:

267  GL(dl_tls_static_used) = offset;
268  GL(dl_tls_static_size) = roundup (offset + TLS_STATIC_SURPLUS,
269				    TLS_TCB_ALIGN);

Also when we read from hardware register $29 and subtract 0x7000 from it we reach to the start of static TLS (which is also end of TCB for TLS variant 1).
Therefore we already have the start address and size of static TLS area so we don't require TlsPreTcbSize () and ThreadDescriptorSize () at all for MIPS.

Documents refered :

[1] http://www.akkadia.org/drepper/tls.pdf
[2] http://www.linux-mips.org/wiki/NPTL

[earthdok]

Hi!

The point of confusion here is whether the TCB is considered a part of TLS or not. From LSan's point of view, we have to include the TCB in the rootset. One reason is because thread-specific storage (i.e. pointers stored using pthread_setspecific()) is only reachable through a static array which is a part of the TCB structure. So LSan includes the TCB into the TLS.

In D5616#109055, @Sagar wrote:

X86_64 uses tls variant 2 and TLS_TCB_AT_TP is set to 1 in tls.h. So the size we get from __dl_tls_get_static_info () includes the thread descriptor size along with size of static TLS area as per the following code in elf/dl-tls.c:

223  GL(dl_tls_static_used) = offset;
224  GL(dl_tls_static_size) = (roundup (offset + TLS_STATIC_SURPLUS, max_align)
225			    + TLS_TCB_SIZE);

Therefore we need the Thread Descriptor Size, so that we can exclude it from the size we get from __dl_tls_get_static_info ().

This is not strictly true. The size we get is correct; it's the offset that is shifted by ThreadDescriptorSize. Take a look at the code in sanitizer_linux_libcdep.cc:

264 # if defined(x86_64) || defined(i386)
265 *addr = ThreadSelf();
266 *size = GetTlsSize();
267 *addr -= *size;
268 *addr += ThreadDescriptorSize();

The size we get is the TLS size, including the TCB. We do not adjust it. But ThreadSelf() points at the beginning of the TCB, which is located at the very end of the TLS.

This is of course not relevant to MIPS, just making sure you have a clear picture.

But MIPS uses TLS variant 1 and TLS_DTV_AT_TP is set to 1 in tls.h. So the size we get from __dl_tls_get_static_info () is only the size of static TLS area and does not include the thread descriptor size as per the following code in elf/dl-tls.c:

267  GL(dl_tls_static_used) = offset;
268  GL(dl_tls_static_size) = roundup (offset + TLS_STATIC_SURPLUS,
269				    TLS_TCB_ALIGN);

Also when we read from hardware register $29 and subtract 0x7000 from it we reach to the start of static TLS (which is also end of TCB for TLS variant 1).
Therefore we already have the start address and size of static TLS area so we don't require TlsPreTcbSize () and ThreadDescriptorSize () at all for MIPS.

As discussed above, we still need to adjust the address to point to the beginning of the TCB.

[slthakur]

Hi @earthdok,

I have created a new patch http://reviews.llvm.org/D7013.
http://reviews.llvm.org/D7013 includes the changes in this patch and the test case required for it.

[sdkie]

please check http://reviews.llvm.org/D7013 for further updates on this patch

cmake/config-ix.cmake

 endfunction()
 
 # Arhcitectures supported by compiler-rt libraries.
 filter_available_targets(SANITIZER_COMMON_SUPPORTED_ARCH
   x86_64 i386 i686 powerpc64 powerpc64le arm aarch64 mips mips64 mipsel mips64el)
 filter_available_targets(ASAN_SUPPORTED_ARCH
   x86_64 i386 i686 powerpc64 powerpc64le arm mips mipsel mips64 mips64el)
 filter_available_targets(DFSAN_SUPPORTED_ARCH x86_64 mips64 mips64el)
-filter_available_targets(LSAN_SUPPORTED_ARCH x86_64)
+filter_available_targets(LSAN_SUPPORTED_ARCH x86_64 mips64 mips64el)
 # LSan common files should be available on all architectures supported
 # by other sanitizers (even if they build into dummy object files).
 filter_available_targets(LSAN_COMMON_SUPPORTED_ARCH
   ${SANITIZER_COMMON_SUPPORTED_ARCH})
 filter_available_targets(MSAN_SUPPORTED_ARCH x86_64 mips64 mips64el)
 filter_available_targets(PROFILE_SUPPORTED_ARCH x86_64 i386 i686 arm mips mips64
   mipsel mips64el aarch64 powerpc64 powerpc64le)
 filter_available_targets(TSAN_SUPPORTED_ARCH x86_64)

lib/lsan/lsan_allocator.cc

 #include "sanitizer_common/sanitizer_stackdepot.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "lsan_common.h"
 
 extern "C" void *memset(void *ptr, int value, uptr num);
 
 namespace __lsan {
 
-static const uptr kMaxAllowedMallocSize = 8UL << 30;
-static const uptr kAllocatorSpace = 0x600000000000ULL;
-static const uptr kAllocatorSize  =  0x40000000000ULL;  // 4T.
-
 struct ChunkMetadata {
   bool allocated : 8;  // Must be first.
   ChunkTag tag : 2;
   uptr requested_size : 54;
   u32 stack_trace_id;
 };
 
+#if defined(__mips64)
+static const uptr kMaxAllowedMallocSize = 4UL << 30;
+static const uptr kRegionSizeLog = 20;
+static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
+typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
+typedef CompactSizeClassMap SizeClassMap;
+typedef SizeClassAllocator32<0, SANITIZER_MMAP_RANGE_SIZE,
+sizeof(ChunkMetadata), SizeClassMap, kRegionSizeLog,
+ByteMap> PrimaryAllocator;
+#else
+static const uptr kMaxAllowedMallocSize = 8UL << 30;
+static const uptr kAllocatorSpace = 0x600000000000ULL;
+static const uptr kAllocatorSize  =  0x40000000000ULL;  // 4T.
 typedef SizeClassAllocator64<kAllocatorSpace, kAllocatorSize,
         sizeof(ChunkMetadata), DefaultSizeClassMap> PrimaryAllocator;
+#endif
+
 typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
 typedef LargeMmapAllocator<> SecondaryAllocator;
 typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
           SecondaryAllocator> Allocator;
 
 static Allocator allocator;
 static THREADLOCAL AllocatorCache cache;
 

lib/lsan/lsan_common.h

 #define LSAN_COMMON_H
 
 #include "sanitizer_common/sanitizer_allocator.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_internal_defs.h"
 #include "sanitizer_common/sanitizer_platform.h"
 #include "sanitizer_common/sanitizer_symbolizer.h"
 
-#if SANITIZER_LINUX && defined(__x86_64__) && (SANITIZER_WORDSIZE == 64)
+#if SANITIZER_LINUX && (defined(__x86_64__) || defined(__mips64)) \
+                    && (SANITIZER_WORDSIZE == 64)
 #define CAN_SANITIZE_LEAKS 1
 #else
 #define CAN_SANITIZE_LEAKS 0
 #endif
 
 namespace __lsan {
 
 // Chunk tags.

lib/lsan/lsan_common.cc

 
 static inline bool CanBeAHeapPointer(uptr p) {
   // Since our heap is located in mmap-ed memory, we can assume a sensible lower
   // bound on heap addresses.
   const uptr kMinAddress = 4 * 4096;
   if (p < kMinAddress) return false;
 #ifdef __x86_64__
   // Accept only canonical form user-space addresses.
   return ((p >> 47) == 0);
+#elif defined(__mips64)
+  return ((p >> 40) == 0);
 #else
   return true;
 #endif
 }
 
 // Scans the memory range, looking for byte patterns that point into allocator
 // chunks. Marks those chunks with |tag| and adds them to |frontier|.
 // There are two usage modes for this function: finding reachable or ignored

lib/sanitizer_common/sanitizer_linux.h

 // Linux-only syscalls.
 #if SANITIZER_LINUX
 uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5);
 // Used only by sanitizer_stoptheworld. Signal handlers that are actually used
 // (like the process-wide error reporting SEGV handler) must use
 // internal_sigaction instead.
 int internal_sigaction_norestorer(int signum, const void *act, void *oldact);
 void internal_sigdelset(__sanitizer_sigset_t *set, int signum);
-#if defined(__x86_64__)
+#if defined(__x86_64__) || defined(__mips__)
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr);
 #endif
 #endif  // SANITIZER_LINUX
 
 // This class reads thread IDs from /proc/<pid>/task using only syscalls.
 class ThreadLister {
  public:

lib/sanitizer_common/sanitizer_linux.cc

 // Syscall wrappers.
 uptr internal_ptrace(int request, int pid, void *addr, void *data) {
   return internal_syscall(SYSCALL(ptrace), request, pid, (uptr)addr,
                           (uptr)data);
 }
 
 uptr internal_waitpid(int pid, int *status, int options) {
   return internal_syscall(SYSCALL(wait4), pid, (uptr)status, options,
                           0 /* rusage */);
 }
 
 uptr internal_getpid() {
   return internal_syscall(SYSCALL(getpid));
 }
 
 uptr internal_getppid() {
   return internal_syscall(SYSCALL(getppid));
__asm__ __volatile__(
                        : "a"(SYSCALL(clone)), "i"(SYSCALL(exit)),
                          "S"(child_stack),
                          "D"(flags),
                          "d"(parent_tidptr),
                          "r"(r8),
                          "r"(r10)
                        : "rsp", "memory", "r11", "rcx");
   return res;
 }
+#elif defined(__mips__)
+// TODO(kumarsukhani): clone function is to be rewritten in assembly
+uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
+                    int *parent_tidptr, void *newtls, int *child_tidptr) {
+  return clone(fn, child_stack, flags, arg, parent_tidptr,
+               newtls, child_tidptr);
+}
 #endif  // defined(__x86_64__) && SANITIZER_LINUX
 
 #if SANITIZER_ANDROID
 static atomic_uint8_t android_log_initialized;
 
 void AndroidLogInit() {
   atomic_store(&android_log_initialized, 1, memory_order_release);
 }

lib/sanitizer_common/sanitizer_linux_libcdep.cc

 #endif
 
 #ifdef __i386__
 # define DL_INTERNAL_FUNCTION __attribute__((regparm(3), stdcall))
 #else
 # define DL_INTERNAL_FUNCTION
 #endif
 
+#if defined(__mips__)
+uptr TlsPreTcbSize() {
+  const uptr kTcbHead = 16;
+  const uptr kTlsTcbAlign = 16;
+  return ((ThreadDescriptorSize() + kTcbHead + kTlsTcbAlign - 1) &
+                                              ~(kTlsTcbAlign -1));
+}
+#endif
+
 void InitTlsSize() {
 #if !SANITIZER_FREEBSD && !SANITIZER_ANDROID
   typedef void (*get_tls_func)(size_t*, size_t*) DL_INTERNAL_FUNCTION;
   get_tls_func get_tls;
   void *get_tls_static_info_ptr = dlsym(RTLD_NEXT, "_dl_get_tls_static_info");
   CHECK_EQ(sizeof(get_tls), sizeof(get_tls_static_info_ptr));
   internal_memcpy(&get_tls, &get_tls_static_info_ptr,
                   sizeof(get_tls_static_info_ptr));
   CHECK_NE(get_tls, 0);
   size_t tls_size = 0;
   size_t tls_align = 0;
   get_tls(&tls_size, &tls_align);
+#if defined(__mips__)
+  uptr kDlTlsStaticAlign = 16;
+  g_tls_size = ((tls_size + TlsPreTcbSize() + kDlTlsStaticAlign -1)
+                & ~(kDlTlsStaticAlign - 1));
+#else
   g_tls_size = tls_size;
+#endif
 #endif  // !SANITIZER_FREEBSD && !SANITIZER_ANDROID
 }
 
-#if (defined(__x86_64__) || defined(__i386__)) && SANITIZER_LINUX
+#if (defined(__x86_64__) || defined(__i386__) || defined(__mips__)) \
+     && SANITIZER_LINUX
 // sizeof(struct thread) from glibc.
 static atomic_uintptr_t kThreadDescriptorSize;
 
 uptr ThreadDescriptorSize() {
   uptr val = atomic_load(&kThreadDescriptorSize, memory_order_relaxed);
   if (val)
     return val;
 #ifdef _CS_GNU_LIBC_VERSION
   char buf[64];
   uptr len = confstr(_CS_GNU_LIBC_VERSION, buf, sizeof(buf));
   if (len < sizeof(buf) && internal_strncmp(buf, "glibc 2.", 8) == 0) {
     char *end;
     int minor = internal_simple_strtoll(buf + 8, &end, 10);
     if (end != buf + 8 && (*end == '\0' || *end == '.')) {
       /* sizeof(struct thread) values from various glibc versions.  */
+#if defined(__x86_64__) || defined(__i386__)
       if (SANITIZER_X32)
         val = 1728;  // Assume only one particular version for x32.
       else if (minor <= 3)
         val = FIRST_32_SECOND_64(1104, 1696);
       else if (minor == 4)
         val = FIRST_32_SECOND_64(1120, 1728);
       else if (minor == 5)
         val = FIRST_32_SECOND_64(1136, 1728);
       else if (minor <= 9)
         val = FIRST_32_SECOND_64(1136, 1712);
       else if (minor == 10)
         val = FIRST_32_SECOND_64(1168, 1776);
       else if (minor <= 12)
         val = FIRST_32_SECOND_64(1168, 2288);
       else
         val = FIRST_32_SECOND_64(1216, 2304);
+#elif defined(__mips__)
+      // TODO(kumarsukhani): add more values as per different glibc versions
+      val = FIRST_32_SECOND_64(1152, 1760);
+#endif
     }
     if (val)
       atomic_store(&kThreadDescriptorSize, val, memory_order_relaxed);
     return val;
   }
 #endif
   return 0;
 }
 
 // The offset at which pointer to self is located in the thread descriptor.
 const uptr kThreadSelfOffset = FIRST_32_SECOND_64(8, 16);
 
 uptr ThreadSelfOffset() {
   return kThreadSelfOffset;
 }
 
 uptr ThreadSelf() {
   uptr descr_addr;
 # if defined(__i386__)
   asm("mov %%gs:%c1,%0" : "=r"(descr_addr) : "i"(kThreadSelfOffset));
 # elif defined(__x86_64__)
   asm("mov %%fs:%c1,%0" : "=r"(descr_addr) : "i"(kThreadSelfOffset));
+# elif defined(__mips__)
+  // MIPS uses TLS variant I. The thread pointer (in hardware register $29)
+  // points to the end of the TCB + 0x7000. The pthread_descr structure is
+  // immediately in front of the TCB. kTlsPreTcbSize includes the size of the
+  // TCB and the size of pthread_descr
+  const uptr kTlsTcbOffset = 0x7000;
+  uptr thread_pointer;
+  asm volatile(".set push;\
+                .set mips32r2;\
+                rdhwr %0,$29;\
+                .set\tpop" : "=r" (thread_pointer));
+  descr_addr = thread_pointer - kTlsTcbOffset - TlsPreTcbSize();
 # else
 #  error "unsupported CPU arch"
 # endif
   return descr_addr;
 }
-#endif  // (defined(__x86_64__) || defined(__i386__)) && SANITIZER_LINUX
-
+#endif  // (defined(__x86_64__) || defined(__i386__) || defined(__mips__)) \
+        //  && SANITIZER_LINUX
 #if SANITIZER_FREEBSD
 static void **ThreadSelfSegbase() {
   void **segbase = 0;
 # if defined(__i386__)
   // sysarch(I386_GET_GSBASE, segbase);
   __asm __volatile("mov %%gs:0, %0" : "=r" (segbase));
 # elif defined(__x86_64__)
   // sysarch(AMD64_GET_FSBASE, segbase);

 
 static void GetTls(uptr *addr, uptr *size) {
 #if SANITIZER_LINUX
 # if defined(__x86_64__) || defined(__i386__)
   *addr = ThreadSelf();
   *size = GetTlsSize();
   *addr -= *size;
   *addr += ThreadDescriptorSize();
+# elif defined(__mips__)
+  *addr = ThreadSelf();
+  *size = GetTlsSize();
 # else
   *addr = 0;
   *size = 0;
 # endif
 #elif SANITIZER_FREEBSD
   void** segbase = ThreadSelfSegbase();
   *addr = 0;
   *size = 0;

 
 uptr GetTlsSize() {
 #if SANITIZER_FREEBSD
   uptr addr, size;
   GetTls(&addr, &size);
   return size;
 #else
   return g_tls_size;
 #endif
 }
 
 void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
                           uptr *tls_addr, uptr *tls_size) {
   GetTls(tls_addr, tls_size);
 
   uptr stack_top, stack_bottom;
   GetThreadStackTopAndBottom(main, &stack_top, &stack_bottom);
   *stk_addr = stack_bottom;
   *stk_size = stack_top - stack_bottom;
 
   if (!main) {
     // If stack and tls intersect, make them non-intersecting.

lib/sanitizer_common/sanitizer_platform_limits_posix.h

 #endif
 #if defined(__mips__) && (SANITIZER_WORDSIZE == 32)
     int sa_resv[1];
 #endif
   };
 
 #if SANITIZER_FREEBSD
   typedef __sanitizer_sigset_t __sanitizer_kernel_sigset_t;
+#elif defined(__mips__)
+  struct __sanitizer_kernel_sigset_t {
+    u8 sig[16];
+  };
 #else
   struct __sanitizer_kernel_sigset_t {
     u8 sig[8];
   };
 #endif
 
   // Linux system headers define the 'sa_handler' and 'sa_sigaction' macros.
   struct __sanitizer_kernel_sigaction_t {

lib/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc

 //===-- sanitizer_stoptheworld_linux_libcdep.cc ---------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // See sanitizer_stoptheworld.h for details.
 // This implementation was inspired by Markus Gutschke's linuxthreads.cc.
 //
 //===----------------------------------------------------------------------===//
 
 
 #include "sanitizer_platform.h"
-#if SANITIZER_LINUX && defined(__x86_64__)
+#if SANITIZER_LINUX && (defined(__x86_64__) || defined(__mips__))
 
 #include "sanitizer_stoptheworld.h"
 
 #include "sanitizer_platform_limits_posix.h"
 
 #include <errno.h>
 #include <sched.h> // for CLONE_* definitions
 #include <stddef.h>
int SuspendedThreadsList::GetRegistersAndSP(uptr index,
   return 0;
 }
 
 uptr SuspendedThreadsList::RegisterCount() {
   return sizeof(regs_struct) / sizeof(uptr);
 }
 }  // namespace __sanitizer
 
-#endif  // SANITIZER_LINUX && defined(__x86_64__)
+#endif  // SANITIZER_LINUX && (defined(__x86_64__) || defined(__mips__))