Make SyzyAsan support the allocation > 1GB

syzygy/agent/asan/block.h

 // Copyright 2014 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 94 matching lines @@
 // Various constants for identifying the beginnings of regions of memory.
 static const uint16_t kBlockHeaderMagic = 0xCA80;
 
 // Various constants used for filling regions of memory.
 static const uint8_t kBlockHeaderPaddingByte = 0x1C;
 static const uint8_t kBlockTrailerPaddingByte = 0xC3;
 static const uint8_t kBlockFloodFillByte = 0xFD;
 
 // The number of bits in the checksum field. This is parameterized so that
 // it can be referred to by the checksumming code.
-static const size_t kBlockHeaderChecksumBits = 14;
+static constexpr size_t kBlockHeaderChecksumBits = 13;
+
+// The number of bits used to store the size of an allocation.
+static constexpr size_t kBlockBodySizeBits = 31;
 
 // The state of an Asan block. These are in the order that reflects the typical
 // lifespan of an allocation.
 enum BlockState {
   // The block is allocated and valid for reading/writing.
   ALLOCATED_BLOCK,
   // The block has been quarantined, and not valid for reading/writing.
   // While in the quarantine it is still allocated as far as the underlying
   // heap is concerned, and won't be reclaimed.
   QUARANTINED_BLOCK,
@@ skipping 24 matching lines @@
     unsigned state : 2;
     // If this bit is positive then header padding is present. The size of the
     // header padding is encoded in the padding itself.
     unsigned has_header_padding : 1;
     // If this bit is positive then trailer padding in excess of
     // kShadowRatio/2 is present, and the size of the trailer padding itself
     // will be encoded in these bytes. Otherwise it is implicit as
     // (kShadowRatio / 2) - (body_size % (kShadowRatio / 2)).
     unsigned has_excess_trailer_padding : 1;
     // The size of the body of the allocation, in bytes.
-    unsigned body_size : 30;
+    unsigned body_size : kBlockBodySizeBits;
   };
   // TODO(loskutov): replace pointers with something more compact.
   // The allocation stack of this block.
   const common::StackCapture* alloc_stack;
   // The free stack of this block (NULL if not yet quarantined/freed).
   const common::StackCapture* free_stack;
 };
 #pragma pack(pop)
 static_assert((sizeof(BlockHeader) % kShadowRatio) == 0,
               "Invalid BlockHeader mod size.");
@@ skipping 346 matching lines @@
 typedef base::Callback<void(EXCEPTION_POINTERS*)> OnExceptionCallback;
 void SetOnExceptionCallback(OnExceptionCallback callback);
 void ClearOnExceptionCallback();
 
 }  // namespace asan
 }  // namespace agent
 
 #include "syzygy/agent/asan/block_impl.h"
 
 #endif  // SYZYGY_AGENT_ASAN_BLOCK_H_