[scudo][standalone] Add new mallopt options.

[cferris]

Summary

This adds the code to support calling mallopt and converting the
options to the internal Option enum.

[cryptoad]

compiler-rt/lib/scudo/standalone/wrappers_c.inc

180

gcc complains that it can't convert the enum to an int.

[cferris]

Fixed Option definition.

[cferris]

Move new tests to only be executed on SCUDO_ANDROID.

[cferris]

Now with the correct name.

compiler-rt/lib/scudo/standalone/tests/wrappers_c_test.cpp

TEST(ScudoWrappersCTest, MallOpt) {
   EXPECT_EQ(errno, 0);
 
   EXPECT_EQ(mallopt(M_PURGE, 0), 1);
 
   EXPECT_EQ(mallopt(M_DECAY_TIME, 1), 1);
   EXPECT_EQ(mallopt(M_DECAY_TIME, 0), 1);
   EXPECT_EQ(mallopt(M_DECAY_TIME, 1), 1);
   EXPECT_EQ(mallopt(M_DECAY_TIME, 0), 1);
+
+  if (SCUDO_ANDROID) {
+    EXPECT_EQ(mallopt(M_CACHE_COUNT_MAX, 100), 1);
+    EXPECT_EQ(mallopt(M_CACHE_SIZE_MAX, 1024 * 1024 * 2), 1);
+    EXPECT_EQ(mallopt(M_TSDS_COUNT_MAX, 10), 1);
+  }
 }
 #endif
 
 TEST(ScudoWrappersCTest, OtherAlloc) {
 #if !SCUDO_FUCHSIA
   const size_t PageSize = sysconf(_SC_PAGESIZE);
 
   void *P = pvalloc(Size);

compiler-rt/lib/scudo/standalone/wrappers_c.inc

 }
 
 void SCUDO_PREFIX(malloc_postinit)() {
   SCUDO_ALLOCATOR.initGwpAsan();
   pthread_atfork(SCUDO_PREFIX(malloc_disable), SCUDO_PREFIX(malloc_enable),
                  SCUDO_PREFIX(malloc_enable));
 }
 
-INTERFACE WEAK int SCUDO_PREFIX(mallopt)(int param, UNUSED int value) {
+INTERFACE WEAK int SCUDO_PREFIX(mallopt)(int param, int value) {
   if (param == M_DECAY_TIME) {
     if (SCUDO_ANDROID) {
       if (value == 0) {
         // Will set the release values to their minimum values.
         value = INT32_MIN;
       } else {
         // Will set the release values to their maximum values.
         value = INT32_MAX;
       }
     }
 
     SCUDO_ALLOCATOR.setOption(scudo::Option::ReleaseInterval,
                               static_cast<scudo::sptr>(value));
     return 1;
   } else if (param == M_PURGE) {
     SCUDO_ALLOCATOR.releaseToOS();
     return 1;
-  } else if (param == M_MEMTAG_TUNING) {
-    return SCUDO_ALLOCATOR.setOption(scudo::Option::MemtagTuning,
-                                     static_cast<scudo::sptr>(value));
-  }
+  } else {
+    scudo::Option option;
+    switch (param) {
+    case M_MEMTAG_TUNING:
+      option = scudo::Option::MemtagTuning;
+      break;
+    case M_CACHE_COUNT_MAX:
+      option = scudo::Option::MaxCacheEntriesCount;
+      break;
+    case M_CACHE_SIZE_MAX:
+      option = scudo::Option::MaxCacheEntrySize;
+      break;
+    case M_TSDS_COUNT_MAX:
+      option = scudo::Option::MaxTSDsCount;
+      break;
+    default:
       return 0;
     }
+    return SCUDO_ALLOCATOR.setOption(option, static_cast<scudo::sptr>(value));
+  }
+}
 
 INTERFACE WEAK void *SCUDO_PREFIX(aligned_alloc)(size_t alignment,
                                                  size_t size) {
   if (UNLIKELY(scudo::checkAlignedAllocAlignmentAndSize(alignment, size))) {
     if (SCUDO_ALLOCATOR.canReturnNull()) {
       errno = EINVAL;
       return nullptr;
     }