[asan] Fix shifting compiler warnings when compiler in 64-bits

[etienneb]

Summary

The MSVC compiler complains about implicit conversion of 32-bits constant to
64-bit when using this shiting pattern 1 << (<64-bit expr>).

[etienneb]

nit

[wang0109]

LGTM

[rnk]

LLP64 strikes again. =P

I wonder if sanitizer_common.h should have this in it instead and use it everywhere instead of ((uptr)1): enum : uptr { UPtrOne = 1 };. Seems like a style question for Kostya.

[etienneb]

In D21524#462485, @rnk wrote:

LLP64 strikes again. =P

I wonder if sanitizer_common.h should have this in it instead and use it everywhere instead of ((uptr)1): enum : uptr { UPtrOne = 1 };. Seems like a style question for Kostya.

Or, we could have a specific macro for address space shifting.

#define SHIFT(offset) (((uptr)1) << (offset))

With a better name :)

[etienneb]

kcc@ ? Could you tell me your coding-style preference to fix these shifting issues.
I'll fix them.

[rnk]

lgtm

Let's fix the warnings now and Kostya can tell us how he'd rather write these checks when he gets back if he has an opinion.

lib/asan/asan_fake_stack.h

public:
 
   // CTOR: create the FakeStack as a single mmap-ed object.
   static FakeStack *Create(uptr stack_size_log);
 
   void Destroy(int tid);
 
   // stack_size_log is at least 15 (stack_size >= 32K).
   static uptr SizeRequiredForFlags(uptr stack_size_log) {
-    return 1UL << (stack_size_log + 1 - kMinStackFrameSizeLog);
+    return ((uptr)1) << (stack_size_log + 1 - kMinStackFrameSizeLog);
   }
 
   // Each size class occupies stack_size bytes.
   static uptr SizeRequiredForFrames(uptr stack_size_log) {
-    return (1ULL << stack_size_log) * kNumberOfSizeClasses;
+    return (((uptr)1) << stack_size_log) * kNumberOfSizeClasses;
   }
 
   // Number of bytes requires for the whole object.
   static uptr RequiredSize(uptr stack_size_log) {
     return kFlagsOffset + SizeRequiredForFlags(stack_size_log) +
            SizeRequiredForFrames(stack_size_log);
   }
 
   // Offset of the given flag from the first flag.
   // The flags for class 0 begin at offset  000000000
   // The flags for class 1 begin at offset  100000000
   // ....................2................  110000000
   // ....................3................  111000000
   // and so on.
   static uptr FlagsOffset(uptr stack_size_log, uptr class_id) {
     uptr t = kNumberOfSizeClasses - 1 - class_id;
-    const uptr all_ones = (1 << (kNumberOfSizeClasses - 1)) - 1;
+    const uptr all_ones = (((uptr)1) << (kNumberOfSizeClasses - 1)) - 1;
     return ((all_ones >> t) << t) << (stack_size_log - 15);
   }
 
   static uptr NumberOfFrames(uptr stack_size_log, uptr class_id) {
-    return 1UL << (stack_size_log - kMinStackFrameSizeLog - class_id);
+    return ((uptr)1) << (stack_size_log - kMinStackFrameSizeLog - class_id);
   }
 
   // Divide n by the numbe of frames in size class.
   static uptr ModuloNumberOfFrames(uptr stack_size_log, uptr class_id, uptr n) {
     return n & (NumberOfFrames(stack_size_log, class_id) - 1);
   }
 
   // The the pointer to the flags of the given class_id.
   u8 *GetFlags(uptr stack_size_log, uptr class_id) {
     return reinterpret_cast<u8 *>(this) + kFlagsOffset +
            FlagsOffset(stack_size_log, class_id);
   }
 
   // Get frame by class_id and pos.
   u8 *GetFrame(uptr stack_size_log, uptr class_id, uptr pos) {
     return reinterpret_cast<u8 *>(this) + kFlagsOffset +
            SizeRequiredForFlags(stack_size_log) +
-           (1 << stack_size_log) * class_id + BytesInSizeClass(class_id) * pos;
+           ((uptr)1 << stack_size_log) * class_id +
+           BytesInSizeClass(class_id) * pos;
   }
 
   // Allocate the fake frame.
   FakeFrame *Allocate(uptr stack_size_log, uptr class_id, uptr real_stack);
 
   // Deallocate the fake frame: read the saved flag address and write 0 there.
   static void Deallocate(uptr x, uptr class_id) {
     **SavedFlagPtr(x, class_id) = 0;
   }
 
   // Poison the entire FakeStack's shadow with the magic value.
   void PoisonAll(u8 magic);
 
   // Return the beginning of the FakeFrame or 0 if the address is not ours.
   uptr AddrIsInFakeStack(uptr addr, uptr *frame_beg, uptr *frame_end);
   USED uptr AddrIsInFakeStack(uptr addr) {
     uptr t1, t2;
     return AddrIsInFakeStack(addr, &t1, &t2);
   }
 
   // Number of bytes in a fake frame of this size class.
   static uptr BytesInSizeClass(uptr class_id) {
-    return 1UL << (class_id + kMinStackFrameSizeLog);
+    return ((uptr)1) << (class_id + kMinStackFrameSizeLog);
   }
 
   // The fake frame is guaranteed to have a right redzone.
   // We use the last word of that redzone to store the address of the flag
   // that corresponds to the current frame to make faster deallocation.
   static u8 **SavedFlagPtr(uptr x, uptr class_id) {
     return reinterpret_cast<u8 **>(x + BytesInSizeClass(class_id) - sizeof(x));
   }
 
   uptr stack_size_log() const { return stack_size_log_; }
 
   void HandleNoReturn();
   void GC(uptr real_stack);
 
   void ForEachFakeFrame(RangeIteratorCallback callback, void *arg);
 
  private:
   FakeStack() { }
   static const uptr kFlagsOffset = 4096;  // This is were the flags begin.
   // Must match the number of uses of DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID
   COMPILER_CHECK(kNumberOfSizeClasses == 11);
-  static const uptr kMaxStackMallocSize = 1 << kMaxStackFrameSizeLog;
+  static const uptr kMaxStackMallocSize = ((uptr)1) << kMaxStackFrameSizeLog;
 
   uptr hint_position_[kNumberOfSizeClasses];
   uptr stack_size_log_;
   // a bit is set if something was allocated from the corresponding size class.
   bool needs_gc_;
 };
 
 FakeStack *GetTLSFakeStack();
 void SetTLSFakeStack(FakeStack *fs);
 
 }  // namespace __asan
 
 #endif  // ASAN_FAKE_STACK_H

lib/asan/asan_fake_stack.cc

 static const u64 kAllocaRedzoneSize = 32UL;
 static const u64 kAllocaRedzoneMask = 31UL;
 
 // For small size classes inline PoisonShadow for better performance.
 ALWAYS_INLINE void SetShadow(uptr ptr, uptr size, uptr class_id, u64 magic) {
   CHECK_EQ(SHADOW_SCALE, 3);  // This code expects SHADOW_SCALE=3.
   u64 *shadow = reinterpret_cast<u64*>(MemToShadow(ptr));
   if (class_id <= 6) {
-    for (uptr i = 0; i < (1U << class_id); i++) {
+    for (uptr i = 0; i < (((uptr)1) << class_id); i++) {
       shadow[i] = magic;
       // Make sure this does not become memset.
       SanitizerBreakOptimization(nullptr);
     }
   } else {
     // The size class is too big, it's cheaper to poison only size bytes.
     PoisonShadow(ptr, size, static_cast<u8>(magic));
   }

 uptr FakeStack::AddrIsInFakeStack(uptr ptr, uptr *frame_beg, uptr *frame_end) {
   uptr stack_size_log = this->stack_size_log();
   uptr beg = reinterpret_cast<uptr>(GetFrame(stack_size_log, 0, 0));
   uptr end = reinterpret_cast<uptr>(this) + RequiredSize(stack_size_log);
   if (ptr < beg || ptr >= end) return 0;
   uptr class_id = (ptr - beg) >> stack_size_log;
   uptr base = beg + (class_id << stack_size_log);
   CHECK_LE(base, ptr);
-  CHECK_LT(ptr, base + (1UL << stack_size_log));
+  CHECK_LT(ptr, base + (((uptr)1) << stack_size_log));
   uptr pos = (ptr - base) >> (kMinStackFrameSizeLog + class_id);
   uptr res = base + pos * BytesInSizeClass(class_id);
   *frame_end = res + BytesInSizeClass(class_id);
   *frame_beg = res + sizeof(FakeFrame);
   return res;
 }
 
 void FakeStack::HandleNoReturn() {

lib/asan/asan_poisoning.cc

void __sanitizer_annotate_contiguous_container(const void *beg_p,
   uptr granularity = SHADOW_GRANULARITY;
   if (!(beg <= old_mid && beg <= new_mid && old_mid <= end && new_mid <= end &&
         IsAligned(beg, granularity))) {
     GET_STACK_TRACE_FATAL_HERE;
     ReportBadParamsToAnnotateContiguousContainer(beg, end, old_mid, new_mid,
                                                  &stack);
   }
   CHECK_LE(end - beg,
-           FIRST_32_SECOND_64(1UL << 30, 1UL << 34)); // Sanity check.
+           FIRST_32_SECOND_64(1UL << 30, 1ULL << 34)); // Sanity check.
 
   uptr a = RoundDownTo(Min(old_mid, new_mid), granularity);
   uptr c = RoundUpTo(Max(old_mid, new_mid), granularity);
   uptr d1 = RoundDownTo(old_mid, granularity);
   // uptr d2 = RoundUpTo(old_mid, granularity);
   // Currently we should be in this state:
   // [a, d1) is good, [d2, c) is bad, [d1, d2) is partially good.
   // Make a quick sanity check that we are indeed in this state.