1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#include "core/fxcrt/fx_memory.h"
#include <stdlib.h> // For abort().
#include <limits>
#include "build/build_config.h"
#include "core/fxcrt/fx_safe_types.h"
#include "third_party/base/debug/alias.h"
pdfium::base::PartitionAllocatorGeneric& GetArrayBufferPartitionAllocator() {
static pdfium::base::PartitionAllocatorGeneric s_array_buffer_allocator;
return s_array_buffer_allocator;
}
pdfium::base::PartitionAllocatorGeneric& GetGeneralPartitionAllocator() {
static pdfium::base::PartitionAllocatorGeneric s_general_allocator;
return s_general_allocator;
}
pdfium::base::PartitionAllocatorGeneric& GetStringPartitionAllocator() {
static pdfium::base::PartitionAllocatorGeneric s_string_allocator;
return s_string_allocator;
}
void FXMEM_InitializePartitionAlloc() {
static bool s_partition_allocators_initialized = false;
if (!s_partition_allocators_initialized) {
pdfium::base::PartitionAllocGlobalInit(FX_OutOfMemoryTerminate);
GetArrayBufferPartitionAllocator().init();
GetGeneralPartitionAllocator().init();
GetStringPartitionAllocator().init();
s_partition_allocators_initialized = true;
}
}
void* FXMEM_DefaultAlloc(size_t byte_size) {
return pdfium::base::PartitionAllocGenericFlags(
GetGeneralPartitionAllocator().root(),
pdfium::base::PartitionAllocReturnNull, byte_size, "GeneralPartition");
}
void* FXMEM_DefaultCalloc(size_t num_elems, size_t byte_size) {
return FX_SafeAlloc(num_elems, byte_size);
}
void* FXMEM_DefaultRealloc(void* pointer, size_t new_size) {
return pdfium::base::PartitionReallocGenericFlags(
GetGeneralPartitionAllocator().root(),
pdfium::base::PartitionAllocReturnNull, pointer, new_size,
"GeneralPartition");
}
void FXMEM_DefaultFree(void* pointer) {
pdfium::base::PartitionFree(pointer);
}
NOINLINE void FX_OutOfMemoryTerminate() {
// Convince the linker this should not be folded with similar functions using
// Identical Code Folding.
static int make_this_function_aliased = 0xbd;
pdfium::base::debug::Alias(&make_this_function_aliased);
// Termimate cleanly if we can, else crash at a specific address (0xbd).
abort();
#if !defined(OS_WIN)
reinterpret_cast<void (*)()>(0xbd)();
#endif
}
void* FX_SafeAlloc(size_t num_members, size_t member_size) {
FX_SAFE_SIZE_T total = member_size;
total *= num_members;
if (!total.IsValid())
return nullptr;
constexpr int kFlags = pdfium::base::PartitionAllocReturnNull |
pdfium::base::PartitionAllocZeroFill;
return pdfium::base::PartitionAllocGenericFlags(
GetGeneralPartitionAllocator().root(), kFlags, total.ValueOrDie(),
"GeneralPartition");
}
void* FX_SafeRealloc(void* ptr, size_t num_members, size_t member_size) {
FX_SAFE_SIZE_T size = num_members;
size *= member_size;
if (!size.IsValid())
return nullptr;
return pdfium::base::PartitionReallocGenericFlags(
GetGeneralPartitionAllocator().root(),
pdfium::base::PartitionAllocReturnNull, ptr, size.ValueOrDie(),
"GeneralPartition");
}
void* FX_AllocOrDie(size_t num_members, size_t member_size) {
// TODO(tsepez): See if we can avoid the implicit memset(0).
void* result = FX_SafeAlloc(num_members, member_size);
if (!result)
FX_OutOfMemoryTerminate(); // Never returns.
return result;
}
void* FX_AllocOrDie2D(size_t w, size_t h, size_t member_size) {
if (w >= std::numeric_limits<size_t>::max() / h)
FX_OutOfMemoryTerminate(); // Never returns.
return FX_AllocOrDie(w * h, member_size);
}
void* FX_ReallocOrDie(void* ptr, size_t num_members, size_t member_size) {
void* result = FX_SafeRealloc(ptr, num_members, member_size);
if (!result)
FX_OutOfMemoryTerminate(); // Never returns.
return result;
}
void FX_Free(void* ptr) {
// TODO(palmer): Removing this check exposes crashes when PDFium callers
// attempt to free |nullptr|. Although libc's |free| allows freeing |NULL|, no
// other Partition Alloc callers need this tolerant behavior. Additionally,
// checking for |nullptr| adds a branch to |PartitionFree|, and it's nice to
// not have to have that.
//
// So this check is hiding (what I consider to be) bugs, and we should try to
// fix them. https://bugs.chromium.org/p/pdfium/issues/detail?id=690
if (ptr)
pdfium::base::PartitionFree(ptr);
}
|
