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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
/*
* Copyright (C) 2011 The Android Open Source Project
*
* 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.
*/
#ifndef ART_SRC_COMPILER_DEX_COMPILER_UTILITY_H_
#define ART_SRC_COMPILER_DEX_COMPILER_UTILITY_H_
#include <stdint.h>
#include <stddef.h>
#include "compiler_enums.h"
namespace art {
struct CompilationUnit;
// Each arena page has some overhead, so take a few bytes off.
#define ARENA_DEFAULT_SIZE ((2 * 1024 * 1024) - 256)
// Type of allocation for memory tuning.
enum oat_alloc_kind {
kAllocMisc,
kAllocBB,
kAllocLIR,
kAllocMIR,
kAllocDFInfo,
kAllocGrowableList,
kAllocGrowableBitMap,
kAllocDalvikToSSAMap,
kAllocDebugInfo,
kAllocSuccessor,
kAllocRegAlloc,
kAllocData,
kAllocPredecessors,
kNumAllocKinds
};
// Type of growable list for memory tuning.
enum oat_list_kind {
kListMisc = 0,
kListBlockList,
kListSSAtoDalvikMap,
kListDfsOrder,
kListDfsPostOrder,
kListDomPostOrderTraversal,
kListThrowLaunchPads,
kListSuspendLaunchPads,
kListSwitchTables,
kListFillArrayData,
kListSuccessorBlocks,
kListPredecessors,
kNumListKinds
};
// Type of growable bitmap for memory tuning.
enum oat_bit_map_kind {
kBitMapMisc = 0,
kBitMapUse,
kBitMapDef,
kBitMapLiveIn,
kBitMapBMatrix,
kBitMapDominators,
kBitMapIDominated,
kBitMapDomFrontier,
kBitMapPhi,
kBitMapTmpBlocks,
kBitMapInputBlocks,
kBitMapRegisterV,
kBitMapTempSSARegisterV,
kBitMapNullCheck,
kBitMapTmpBlockV,
kBitMapPredecessors,
kNumBitMapKinds
};
// Allocate the initial memory block for arena-based allocation.
bool HeapInit(CompilationUnit* cu);
// Uncomment to collect memory usage statistics.
//#define WITH_MEMSTATS
struct ArenaMemBlock {
size_t block_size;
size_t bytes_allocated;
ArenaMemBlock *next;
char ptr[0];
};
void* NewMem(CompilationUnit* cu, size_t size, bool zero, oat_alloc_kind kind);
void ArenaReset(CompilationUnit *cu);
struct GrowableList {
GrowableList() : num_allocated(0), num_used(0), elem_list(NULL) {
}
size_t num_allocated;
size_t num_used;
uintptr_t* elem_list;
#ifdef WITH_MEMSTATS
oat_list_kind kind;
#endif
};
struct GrowableListIterator {
GrowableList* list;
size_t idx;
size_t size;
};
/*
* Expanding bitmap, used for tracking resources. Bits are numbered starting
* from zero. All operations on a BitVector are unsynchronized.
*/
struct ArenaBitVector {
bool expandable; // expand bitmap if we run out?
uint32_t storage_size; // current size, in 32-bit words.
uint32_t* storage;
#ifdef WITH_MEMSTATS
oat_bit_map_kind kind; // for memory use tuning.
#endif
};
// Handy iterator to walk through the bit positions set to 1.
struct ArenaBitVectorIterator {
ArenaBitVector* p_bits;
uint32_t idx;
uint32_t bit_size;
};
#define GET_ELEM_N(LIST, TYPE, N) ((reinterpret_cast<TYPE*>(LIST->elem_list)[N]))
#define BLOCK_NAME_LEN 80
// Forward declarations
struct BasicBlock;
struct CompilationUnit;
struct LIR;
struct RegLocation;
struct MIR;
enum BBType;
void CompilerInitGrowableList(CompilationUnit* cu, GrowableList* g_list,
size_t init_length, oat_list_kind kind = kListMisc);
void ReallocGrowableList(CompilationUnit* cu, GrowableList* g_list, size_t new_length);
void InsertGrowableList(CompilationUnit* cu, GrowableList* g_list, uintptr_t elem);
void DeleteGrowableList(GrowableList* g_list, uintptr_t elem);
void GrowableListIteratorInit(GrowableList* g_list, GrowableListIterator* iterator);
uintptr_t GrowableListIteratorNext(GrowableListIterator* iterator);
uintptr_t GrowableListGetElement(const GrowableList* g_list, size_t idx);
ArenaBitVector* AllocBitVector(CompilationUnit* cu, unsigned int start_bits, bool expandable,
oat_bit_map_kind = kBitMapMisc);
void BitVectorIteratorInit(ArenaBitVector* p_bits, ArenaBitVectorIterator* iterator);
int BitVectorIteratorNext(ArenaBitVectorIterator* iterator);
bool SetBit(CompilationUnit *cu, ArenaBitVector* p_bits, unsigned int num);
bool ClearBit(ArenaBitVector* p_bits, unsigned int num);
void MarkAllBits(ArenaBitVector* p_bits, bool set);
void DebugBitVector(char* msg, const ArenaBitVector* bv, int length);
bool IsBitSet(const ArenaBitVector* p_bits, unsigned int num);
void ClearAllBits(ArenaBitVector* p_bits);
void SetInitialBits(ArenaBitVector* p_bits, unsigned int num_bits);
void CopyBitVector(ArenaBitVector* dest, const ArenaBitVector* src);
bool IntersectBitVectors(ArenaBitVector* dest, const ArenaBitVector* src1,
const ArenaBitVector* src2);
bool UnifyBitVetors(ArenaBitVector* dest, const ArenaBitVector* src1, const ArenaBitVector* src2);
bool CompareBitVectors(const ArenaBitVector* src1, const ArenaBitVector* src2);
bool TestBitVectors(const ArenaBitVector* src1, const ArenaBitVector* src2);
int CountSetBits(const ArenaBitVector* p_bits);
void DumpLIRInsn(CompilationUnit* cu, LIR* lir, unsigned char* base_addr);
void DumpResourceMask(LIR* lir, uint64_t mask, const char* prefix);
void DumpBlockBitVector(const GrowableList* blocks, char* msg, const ArenaBitVector* bv,
int length);
void GetBlockName(BasicBlock* bb, char* name);
const char* GetShortyFromTargetIdx(CompilationUnit*, int);
void DumpMemStats(CompilationUnit* cu);
void DumpCompilationUnit(CompilationUnit* cu);
BasicBlock* NewMemBB(CompilationUnit* cu, BBType block_type, int block_id);
void AppendMIR(BasicBlock* bb, MIR* mir);
void PrependMIR(BasicBlock* bb, MIR* mir);
void InsertMIRAfter(BasicBlock* bb, MIR* current_mir, MIR* new_mir);
void AppendLIR(CompilationUnit *cu, LIR* lir);
void InsertLIRBefore(LIR* current_lir, LIR* new_lir);
void InsertLIRAfter(LIR* current_lir, LIR* new_lir);
void ReplaceSpecialChars(std::string& str);
char* GetDalvikDisassembly(CompilationUnit* cu, const MIR* mir);
std::string GetSSAName(const CompilationUnit* cu, int ssa_reg);
std::string GetSSANameWithConst(const CompilationUnit* cu, int ssa_reg, bool singles_only);
} // namespace art
#endif // ART_SRC_COMPILER_DEX_COMPILER_UTILITY_H_
|
