1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "aarch64_cg.h"
17 #include "mir_builder.h"
18 #include "becommon.h"
19 #include "label_creation.h"
20 #include "alignment.h"
21
22 namespace maplebe {
23 #include "immvalid.def"
24 #define DEFINE_MOP(...) {__VA_ARGS__},
25 const InsnDesc AArch64CG::kMd[kMopLast] = {
26 #include "abstract_mmir.def"
27 #include "aarch64_md.def"
28 };
29 #undef DEFINE_MOP
30
31 std::array<std::array<const std::string, kAllRegNum>, kIntRegTypeNum> AArch64CG::intRegNames = {
32 std::array<const std::string, kAllRegNum> {
33 "err", "err0", "err1", "err2", "err3", "err4", "err5", "err6", "err7",
34 "err8", "err9", "err10", "err11", "err12", "err13", "err14", "err15", "err16",
35 "err17", "err18", "err19", "err20", "err21", "err22", "err23", "err24", "err25",
36 "err26", "err27", "err28", "err", "err", "err", "errsp", "errzr", /* x29 is fp */
37 "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7", "b8",
38 "b9", "b10", "b11", "b12", "b13", "b14", "b15", "b16", "b17",
39 "b18", "b19", "b20", "b21", "b22", "b23", "b24", "b25", "b26",
40 "b27", "b28", "b29", "b30", "b31", "errMaxRegNum", "rflag"},
41 std::array<const std::string, kAllRegNum> {
42 "err", "err0", "err1", "err2", "err3", "err4", "err5", "err6", "err7",
43 "err8", "err9", "err10", "err11", "err12", "err13", "err14", "err15", "err16",
44 "err17", "err18", "err19", "err20", "err21", "err22", "err23", "err24", "err25",
45 "err26", "err27", "err28", "err29", "err30", "err31", "errsp", "errzr", /* x29 is fp */
46 "h0", "h1", "h2", "h3", "h4", "h5", "h6", "h7", "h8",
47 "h9", "h10", "h11", "h12", "h13", "h14", "h15", "h16", "h17",
48 "h18", "h19", "h20", "h21", "h22", "h23", "h24", "h25", "h26",
49 "h27", "h28", "h29", "h30", "h31", "errMaxRegNum", "rflag"},
50 std::array<const std::string, kAllRegNum> {
51 "err", "w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7", "w8", "w9", "w10",
52 "w11", "w12", "w13", "w14", "w15", "w16", "w17", "w18", "w19", "w20", "w21", "w22",
53 "w23", "w24", "w25", "w26", "w27", "w28", "w29", "err", "err", "wsp", "wzr", /* x29 is fp */
54 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9", "s10", "s11",
55 "s12", "s13", "s14", "s15", "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
56 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31", "errMaxRegNum", "rflag"},
57 std::array<const std::string, kAllRegNum> {
58 "err", "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "x9",
59 "x10", "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "x19", "x20",
60 "x21", "x22", "x23", "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x29" /* use X40 when debug */,
61 "sp", "xzr", /* x29 is fp */
62 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "d10",
63 "d11", "d12", "d13", "d14", "d15", "d16", "d17", "d18", "d19", "d20", "d21",
64 "d22", "d23", "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31", "errMaxRegNum",
65 "rflag"},
66 std::array<const std::string, kAllRegNum> {
67 "err", "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "x9",
68 "x10", "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "x19", "x20",
69 "x21", "x22", "x23", "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x29" /* use X40 when debug */,
70 "sp", "xzr", /* x29 is fp */
71 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7", "q8", "q9", "q10",
72 "q11", "q12", "q13", "q14", "q15", "q16", "q17", "q18", "q19", "q20", "q21",
73 "q22", "q23", "q24", "q25", "q26", "q27", "q28", "q29", "q30", "q31", "errMaxRegNum",
74 "rflag"}};
75
76 std::array<const std::string, kAllRegNum> AArch64CG::vectorRegNames = {
77 "err", "err0", "err1", "err2", "err3", "err4", "err5", "err6", "err7", "err8", "err9", "err10", "err11", "err12",
78 "err13", "err14", "err15", "err16", "err17", "err18", "err19", "err20", "err21", "err22",
79 /* x29 is fp, err40 is fp before RA */
80 "err23", "err24", "err25", "err26", "err27", "err28", "err29", "err30", "errsp", "errzr", "err40", "v0", "v1", "v2",
81 "v3", "v4", "v5", "v6", "v7", "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15", "v16", "v17", "v18", "v19",
82 "v20", "v21", "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31", "errMaxRegNum", "rflag"};
83
IsExclusiveFunc(MIRFunction & mirFunc)84 bool AArch64CG::IsExclusiveFunc(MIRFunction &mirFunc)
85 {
86 const std::string &funcName = mirFunc.GetName();
87 for (const auto &it : ehExclusiveNameVec) {
88 if (it.compare(funcName) == 0) {
89 return true;
90 }
91 }
92 return false;
93 }
94 namespace wordsMap {
95 /*
96 * Generate object maps.
97 *
98 * 1. each class record its GCTIB in method meta (not read only meta)
99 * 2. GCTIB include: header protoType; n bitmap word; bitmap word
100 * 3. each reference word(4 or 8 bytes) is represented by 2 bits
101 * 00: not ref
102 * 01: normal ref
103 * 10: weak ref
104 * 11: unowned ref
105 *
106 * For example, if a scalar object has five ptr fields at offsets 24, 40(weak),
107 * 64(unowned), the generated code will be like:
108 *
109 * MCC_GCTIB__xxx:
110 * .long 0x40 // object has child reference
111 * .long 1 // one word in the bitmap
112 * .quad 0b110000100001000000
113 * ...
114 */
115 const uint32 kRefWordsPerMapWord = 32; /* contains bitmap for 32 ref words in 64 bits */
116 const uint32 kLogRefWordsPerMapWord = 5;
117 #ifdef USE_32BIT_REF
118 const uint32 kReferenceWordSize = 4;
119 const uint32 kLog2ReferenceWordSize = 2;
120 #else
121 const uint32 kReferenceWordSize = 8;
122 const uint32 kLog2ReferenceWordSize = 3;
123 #endif
124 const uint32 kInMapWordOffsetMask = ((kReferenceWordSize * kRefWordsPerMapWord) - 1);
125 const uint32 kInMapWordIndexShift = (kLog2ReferenceWordSize - 1);
126 const uint32 kMapWordIndexShift = (kLog2ReferenceWordSize + kLogRefWordsPerMapWord);
127
128 const uint64 kRefBits = 1;
129 const uint64 kWeakRefBits = 2;
130 const uint64 kUnownedRefBits = 3;
131
132 /*
133 * Give a structrue type, calculate its bitmap_vector
134 */
GetGCTIBBitMapWords(const BECommon & beCommon,MIRStructType & stType,std::vector<uint64> & bitmapWords)135 static void GetGCTIBBitMapWords(const BECommon &beCommon, MIRStructType &stType, std::vector<uint64> &bitmapWords)
136 {
137 bitmapWords.clear();
138 if (stType.GetKind() == kTypeClass) {
139 uint64 curBitmap = 0;
140 uint32 curBitmapIndex = 0;
141 uint32 prevOffset = 0;
142 for (const auto &fieldInfo : beCommon.GetJClassLayout(static_cast<MIRClassType &>(stType))) {
143 if (fieldInfo.IsRef()) {
144 uint32 curOffset = fieldInfo.GetOffset();
145 /* skip meta field */
146 if (curOffset == 0) {
147 continue;
148 }
149 CHECK_FATAL((curOffset > prevOffset) || (prevOffset == 0), "not ascending offset");
150 uint32 wordIndex = curOffset >> kMapWordIndexShift;
151 if (wordIndex > curBitmapIndex) {
152 bitmapWords.emplace_back(curBitmap);
153 for (uint32 i = curBitmapIndex + 1; i < wordIndex; i++) {
154 bitmapWords.emplace_back(0);
155 }
156 curBitmap = 0;
157 curBitmapIndex = wordIndex;
158 }
159 uint32 bitOffset = (curOffset & kInMapWordOffsetMask) >> kInMapWordIndexShift;
160 if (CGOptions::IsGCOnly()) {
161 /* ignore unowned/weak when GCONLY is enabled. */
162 curBitmap |= (kRefBits << bitOffset);
163 } else if (fieldInfo.IsUnowned()) {
164 curBitmap |= (kUnownedRefBits << bitOffset);
165 } else if (fieldInfo.IsWeak()) {
166 curBitmap |= (kWeakRefBits << bitOffset);
167 } else {
168 /* ref */
169 curBitmap |= (kRefBits << bitOffset);
170 }
171 prevOffset = curOffset;
172 }
173 }
174 if (curBitmap != 0) {
175 bitmapWords.emplace_back(curBitmap);
176 }
177 } else if (stType.GetKind() != kTypeInterface) {
178 /* interface doesn't have reference fields */
179 CHECK_FATAL(false, "GetGCTIBBitMapWords unexpected type");
180 }
181 }
182 } // namespace wordsMap
183
IsTargetInsn(MOperator mOp) const184 bool AArch64CG::IsTargetInsn(MOperator mOp) const
185 {
186 return (mOp > MOP_undef && mOp <= MOP_nop);
187 }
IsClinitInsn(MOperator mOp) const188 bool AArch64CG::IsClinitInsn(MOperator mOp) const
189 {
190 return (mOp == MOP_clinit || mOp == MOP_clinit_tail || mOp == MOP_adrp_ldr);
191 }
IsPseudoInsn(MOperator mOp) const192 bool AArch64CG::IsPseudoInsn(MOperator mOp) const
193 {
194 return (mOp >= MOP_pseudo_param_def_x && mOp < MOP_nop);
195 }
196
IsEffectiveCopy(Insn & insn) const197 bool AArch64CG::IsEffectiveCopy(Insn &insn) const
198 {
199 MOperator mOp = insn.GetMachineOpcode();
200 if (mOp >= MOP_xmovrr && mOp <= MOP_xvmovrv) {
201 return true;
202 }
203 if (mOp == MOP_vmovuu || mOp == MOP_vmovvv) {
204 return true;
205 }
206 if ((mOp >= MOP_xaddrrr && mOp <= MOP_ssub) || (mOp >= MOP_xlslrri6 && mOp <= MOP_wlsrrrr)) {
207 Operand &opnd2 = insn.GetOperand(kInsnThirdOpnd);
208 if (opnd2.IsIntImmediate()) {
209 auto &immOpnd = static_cast<ImmOperand &>(opnd2);
210 if (immOpnd.IsZero()) {
211 return true;
212 }
213 }
214 }
215 if (mOp > MOP_xmulrrr && mOp <= MOP_xvmuld) {
216 Operand &opnd2 = insn.GetOperand(kInsnThirdOpnd);
217 if (opnd2.IsIntImmediate()) {
218 auto &immOpnd = static_cast<ImmOperand &>(opnd2);
219 if (immOpnd.GetValue() == 1) {
220 return true;
221 }
222 }
223 }
224 return false;
225 }
226
DumpTargetOperand(Operand & opnd,const OpndDesc & opndDesc) const227 void AArch64CG::DumpTargetOperand(Operand &opnd, const OpndDesc &opndDesc) const
228 {
229 A64OpndDumpVisitor visitor(opndDesc);
230 opnd.Accept(visitor);
231 }
232
233 /*
234 * Find if there exist same GCTIB (both rcheader and bitmap are same)
235 * for different class. If ture reuse, if not emit and record new GCTIB.
236 */
FindOrCreateRepresentiveSym(std::vector<uint64> & bitmapWords,uint32 rcHeader,const std::string & name)237 void AArch64CG::FindOrCreateRepresentiveSym(std::vector<uint64> &bitmapWords, uint32 rcHeader, const std::string &name)
238 {
239 GCTIBKey *key = memPool->New<GCTIBKey>(allocator, rcHeader, bitmapWords);
240 const std::string &gcTIBName = GCTIB_PREFIX_STR + name;
241 MapleUnorderedMap<GCTIBKey *, GCTIBPattern *, Hasher, EqualFn>::const_iterator iter = keyPatternMap.find(key);
242 if (iter == keyPatternMap.end() || gcTIBName.compare("MCC_GCTIB__Ljava_2Flang_2FObject_3B") == 0) {
243 /* Emit the GCTIB label for the class */
244 GCTIBPattern *ptn = memPool->New<GCTIBPattern>(*key, *memPool);
245
246 if (gcTIBName.compare("MCC_GCTIB__Ljava_2Flang_2FObject_3B") == 0) {
247 ptn->SetName("MCC_GCTIB__Ljava_2Flang_2FObject_3B");
248 }
249 (void)keyPatternMap.insert(std::make_pair(key, ptn));
250 (void)symbolPatternMap.insert(std::make_pair(gcTIBName, ptn));
251
252 /* Emit GCTIB pattern */
253 std::string ptnString = "\t.type " + ptn->GetName() + ", %object\n" + "\t.data\n" + "\t.align 3\n";
254
255 MIRSymbol *gcTIBSymbol = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
256 GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::GetInternalNameLiteral(gcTIBName)));
257 if (gcTIBSymbol != nullptr && gcTIBSymbol->GetStorageClass() == kScFstatic) {
258 ptnString += "\t.local ";
259 } else {
260 ptnString += "\t.global ";
261 }
262
263 Emitter *emitter = GetEmitter();
264 emitter->Emit(ptnString);
265 emitter->Emit(ptn->GetName());
266 emitter->Emit("\n");
267
268 /* Emit the GCTIB pattern label for the class */
269 emitter->Emit(ptn->GetName());
270 emitter->Emit(":\n");
271
272 emitter->Emit("\t.long ");
273 emitter->EmitHexUnsigned(rcHeader);
274 emitter->Emit("\n");
275
276 /* generate n_bitmap word */
277 emitter->Emit("\t.long "); /* AArch64-specific. Generate a 64-bit value. */
278 emitter->EmitDecUnsigned(bitmapWords.size());
279 emitter->Emit("\n");
280
281 /* Emit each bitmap word */
282 for (const auto &bitmapWord : bitmapWords) {
283 if (!CGOptions::IsQuiet()) {
284 LogInfo::MapleLogger() << " bitmap_word: 0x" << bitmapWord << " " << PRIx64 << "\n";
285 }
286 emitter->Emit("\t.quad "); /* AArch64-specific. Generate a 64-bit value. */
287 emitter->EmitHexUnsigned(bitmapWord);
288 emitter->Emit("\n");
289 }
290 if (gcTIBSymbol != nullptr && gcTIBSymbol->GetStorageClass() != kScFstatic) {
291 /* add local symbol REF_XXX to every global GCTIB symbol */
292 CreateRefSymForGlobalPtn(*ptn);
293 keyPatternMap[key] = ptn;
294 }
295 } else {
296 (void)symbolPatternMap.insert(make_pair(gcTIBName, iter->second));
297 }
298 }
299
300 /*
301 * Add local symbol REF_XXX to global GCTIB symbol,
302 * and replace the global GCTIBPattern in keyPatternMap.
303 */
CreateRefSymForGlobalPtn(GCTIBPattern & ptn) const304 void AArch64CG::CreateRefSymForGlobalPtn(GCTIBPattern &ptn) const
305 {
306 const std::string &refPtnString = REF_PREFIX_STR + ptn.GetName();
307 const std::string &ptnString = "\t.type " + refPtnString + ", %object\n" + "\t.data\n" + "\t.align 3\n" +
308 "\t.local " + refPtnString + "\n" + refPtnString + ":\n" + "\t.quad " +
309 ptn.GetName() + "\n";
310 Emitter *emitter = GetEmitter();
311 emitter->Emit(ptnString);
312 ptn.SetName(refPtnString);
313 }
314
FindGCTIBPatternName(const std::string & name) const315 std::string AArch64CG::FindGCTIBPatternName(const std::string &name) const
316 {
317 auto iter = symbolPatternMap.find(name);
318 if (iter == symbolPatternMap.end()) {
319 CHECK_FATAL(false, "No GCTIB pattern found for symbol: %s", name.c_str());
320 }
321 return iter->second->GetName();
322 }
323
GenerateObjectMaps(BECommon & beCommon)324 void AArch64CG::GenerateObjectMaps(BECommon &beCommon)
325 {
326 if (!CGOptions::IsQuiet()) {
327 LogInfo::MapleLogger() << "DEBUG: Generating object maps...\n";
328 }
329
330 for (auto &tyId : GetMIRModule()->GetClassList()) {
331 if (!CGOptions::IsQuiet()) {
332 LogInfo::MapleLogger() << "Class tyIdx: " << tyId << "\n";
333 }
334 TyIdx tyIdx(tyId);
335 MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
336 DEBUG_ASSERT(ty != nullptr, "ty nullptr check");
337 /* Only emit GCTIB for classes owned by this module */
338 DEBUG_ASSERT(ty->IsStructType(), "ty isn't MIRStructType* in AArch64CG::GenerateObjectMaps");
339 MIRStructType *strTy = static_cast<MIRStructType *>(ty);
340 if (!strTy->IsLocal()) {
341 continue;
342 }
343
344 GStrIdx nameIdx = ty->GetNameStrIdx();
345
346 const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(nameIdx);
347
348 /* Emit for a class */
349 if (!CGOptions::IsQuiet()) {
350 LogInfo::MapleLogger() << " name: " << name << "\n";
351 }
352
353 std::vector<uint64> bitmapWords;
354 wordsMap::GetGCTIBBitMapWords(beCommon, *strTy, bitmapWords);
355 /* fill specific header according to the size of bitmapWords */
356 uint32 rcHeader = (!bitmapWords.empty()) ? 0x40 : 0;
357 FindOrCreateRepresentiveSym(bitmapWords, rcHeader, name);
358 }
359 }
360
EnrollTargetPhases(MaplePhaseManager * pm) const361 void AArch64CG::EnrollTargetPhases(MaplePhaseManager *pm) const
362 {
363 if (!GetMIRModule()->IsCModule()) {
364 CGOptions::DisableCGSSA();
365 }
366 #include "aarch64_phases.def"
367 }
368
BuildPhiInsn(RegOperand & defOpnd,Operand & listParam)369 Insn &AArch64CG::BuildPhiInsn(RegOperand &defOpnd, Operand &listParam)
370 {
371 DEBUG_ASSERT(defOpnd.IsRegister(), "build SSA on register operand");
372 CHECK_FATAL(defOpnd.IsOfIntClass() || defOpnd.IsOfFloatOrSIMDClass(), " unknown operand type ");
373 bool is64bit = defOpnd.GetSize() == k64BitSize;
374 MOperator mop = MOP_nop;
375 if (defOpnd.GetSize() == k128BitSize) {
376 DEBUG_ASSERT(defOpnd.IsOfFloatOrSIMDClass(), "unexpect 128bit int operand in aarch64");
377 mop = MOP_xvphivd;
378 } else {
379 mop = defOpnd.IsOfIntClass() ? is64bit ? MOP_xphirr : MOP_wphirr : is64bit ? MOP_xvphid : MOP_xvphis;
380 }
381 DEBUG_ASSERT(mop != MOP_nop, "unexpect 128bit int operand in aarch64");
382 return GetCurCGFuncNoConst()->GetInsnBuilder()->BuildInsn(mop, defOpnd, listParam);
383 }
384
CreatePhiOperand(MemPool & mp,MapleAllocator & mAllocator)385 PhiOperand &AArch64CG::CreatePhiOperand(MemPool &mp, MapleAllocator &mAllocator)
386 {
387 return *mp.New<PhiOperand>(mAllocator);
388 }
389 } /* namespace maplebe */
390