mirror of
https://github.com/chromium/crashpad.git
synced 2025-03-09 22:26:06 +00:00
af594c8deb
While making crashpad_minidump_test run in Chromium’s try- and buildbots (https://crbug.com/779790), crashes in the MinidumpThreadWriter.OneThread_AMD64_Stack test were observed in 32-bit x86 Windows builds produced by Clang in the release configuration. These crashes occurred in crashpad::test::InitializeMinidumpContextAMD64, which heap-allocates a MinidumpContextAMD64Writer object. These objects have an alignment requirement of 16, based on the alignment requirement of their MinidumpContextAMD64 member. Although this problem was never observed with MSVC, Clang was making use of the known strict alignment and producing code that depended on it. This code crashed if the requirement was not met. MSVC had raised a warning about this usage (C4316), but the warning was disabled as it did not appear to have any ill effect on code produced by that compiler. The problem surfaced in test code, but heap-allocated MinidumpContextAMD64Writer objects are created in non-test code as well. The impact is limited, because a 32-bit Windows Crashpad handler would not have a need to allocate one of these objects. As a fix, MinidumpContextAMD64Writer is given a custom allocation function (a static “operator new()” member and matching “operator delete()”) that returns properly aligned memory. Change-Id: I0cb924da91716eb01b88ec2ae952a69262cc2de6 Reviewed-on: https://chromium-review.googlesource.com/746539 Reviewed-by: Leonard Mosescu <mosescu@chromium.org>
77 lines
2.0 KiB
C++
77 lines
2.0 KiB
C++
// Copyright 2015 The Crashpad Authors. 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,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include "util/stdlib/aligned_allocator.h"
|
|
|
|
#include <algorithm>
|
|
|
|
#include "build/build_config.h"
|
|
|
|
#if defined(OS_POSIX)
|
|
#include <stdlib.h>
|
|
#elif defined(OS_WIN)
|
|
#include <malloc.h>
|
|
#include <xutility>
|
|
#endif // OS_POSIX
|
|
|
|
namespace {
|
|
|
|
// Throws std::bad_alloc() by calling an internal function provided by the C++
|
|
// library to do so. This works even if C++ exceptions are disabled, causing
|
|
// program termination if uncaught.
|
|
void ThrowBadAlloc() {
|
|
#if defined(OS_POSIX)
|
|
// This works with both libc++ and libstdc++.
|
|
std::__throw_bad_alloc();
|
|
#elif defined(OS_WIN)
|
|
std::_Xbad_alloc();
|
|
#endif // OS_POSIX
|
|
}
|
|
|
|
} // namespace
|
|
|
|
namespace crashpad {
|
|
|
|
void* AlignedAllocate(size_t alignment, size_t size) {
|
|
#if defined(OS_POSIX)
|
|
// posix_memalign() requires that alignment be at least sizeof(void*), so the
|
|
// power-of-2 check needs to happen before potentially changing the alignment.
|
|
if (alignment == 0 || alignment & (alignment - 1)) {
|
|
ThrowBadAlloc();
|
|
}
|
|
|
|
void* pointer;
|
|
if (posix_memalign(&pointer, std::max(alignment, sizeof(void*)), size) != 0) {
|
|
ThrowBadAlloc();
|
|
}
|
|
#elif defined(OS_WIN)
|
|
void* pointer = _aligned_malloc(size, alignment);
|
|
if (pointer == nullptr) {
|
|
ThrowBadAlloc();
|
|
}
|
|
#endif // OS_POSIX
|
|
|
|
return pointer;
|
|
}
|
|
|
|
void AlignedFree(void* pointer) {
|
|
#if defined(OS_POSIX)
|
|
free(pointer);
|
|
#elif defined(OS_WIN)
|
|
_aligned_free(pointer);
|
|
#endif // OS_POSIX
|
|
}
|
|
|
|
} // namespace crashpad
|