Coverage Report

Created: 2018-08-19 21:11

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/lld/ELF/Arch/AArch64.cpp
Line
Count
Source (jump to first uncovered line)
1
//===- AArch64.cpp --------------------------------------------------------===//
2
//
3
//                             The LLVM Linker
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
10
#include "Symbols.h"
11
#include "SyntheticSections.h"
12
#include "Target.h"
13
#include "Thunks.h"
14
#include "lld/Common/ErrorHandler.h"
15
#include "llvm/Object/ELF.h"
16
#include "llvm/Support/Endian.h"
17
18
using namespace llvm;
19
using namespace llvm::support::endian;
20
using namespace llvm::ELF;
21
using namespace lld;
22
using namespace lld::elf;
23
24
// Page(Expr) is the page address of the expression Expr, defined
25
// as (Expr & ~0xFFF). (This applies even if the machine page size
26
// supported by the platform has a different value.)
27
262
uint64_t elf::getAArch64Page(uint64_t Expr) {
28
262
  return Expr & ~static_cast<uint64_t>(0xFFF);
29
262
}
30
31
namespace {
32
class AArch64 final : public TargetInfo {
33
public:
34
  AArch64();
35
  RelExpr getRelExpr(RelType Type, const Symbol &S,
36
                     const uint8_t *Loc) const override;
37
  RelType getDynRel(RelType Type) const override;
38
  void writeGotPlt(uint8_t *Buf, const Symbol &S) const override;
39
  void writePltHeader(uint8_t *Buf) const override;
40
  void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
41
                int32_t Index, unsigned RelOff) const override;
42
  bool needsThunk(RelExpr Expr, RelType Type, const InputFile *File,
43
                  uint64_t BranchAddr, const Symbol &S) const override;
44
  bool inBranchRange(RelType Type, uint64_t Src, uint64_t Dst) const override;
45
  bool usesOnlyLowPageBits(RelType Type) const override;
46
  void relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const override;
47
  RelExpr adjustRelaxExpr(RelType Type, const uint8_t *Data,
48
                          RelExpr Expr) const override;
49
  void relaxTlsGdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
50
  void relaxTlsGdToIe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
51
  void relaxTlsIeToLe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
52
};
53
} // namespace
54
55
94
AArch64::AArch64() {
56
94
  CopyRel = R_AARCH64_COPY;
57
94
  RelativeRel = R_AARCH64_RELATIVE;
58
94
  IRelativeRel = R_AARCH64_IRELATIVE;
59
94
  GotRel = R_AARCH64_GLOB_DAT;
60
94
  PltRel = R_AARCH64_JUMP_SLOT;
61
94
  TlsDescRel = R_AARCH64_TLSDESC;
62
94
  TlsGotRel = R_AARCH64_TLS_TPREL64;
63
94
  GotEntrySize = 8;
64
94
  GotPltEntrySize = 8;
65
94
  PltEntrySize = 16;
66
94
  PltHeaderSize = 32;
67
94
  DefaultMaxPageSize = 65536;
68
94
69
94
  // It doesn't seem to be documented anywhere, but tls on aarch64 uses variant
70
94
  // 1 of the tls structures and the tcb size is 16.
71
94
  TcbSize = 16;
72
94
  NeedsThunks = true;
73
94
74
94
  // See comment in Arch/ARM.cpp for a more detailed explanation of
75
94
  // ThunkSectionSpacing. For AArch64 the only branches we are permitted to
76
94
  // Thunk have a range of +/- 128 MiB
77
94
  ThunkSectionSpacing = (128 * 1024 * 1024) - 0x30000;
78
94
}
79
80
RelExpr AArch64::getRelExpr(RelType Type, const Symbol &S,
81
431
                            const uint8_t *Loc) const {
82
431
  switch (Type) {
83
431
  case R_AARCH64_TLSDESC_ADR_PAGE21:
84
6
    return R_TLSDESC_PAGE;
85
431
  case R_AARCH64_TLSDESC_LD64_LO12:
86
12
  case R_AARCH64_TLSDESC_ADD_LO12:
87
12
    return R_TLSDESC;
88
12
  case R_AARCH64_TLSDESC_CALL:
89
6
    return R_TLSDESC_CALL;
90
14
  case R_AARCH64_TLSLE_ADD_TPREL_HI12:
91
14
  case R_AARCH64_TLSLE_ADD_TPREL_LO12_NC:
92
14
  case R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC:
93
14
  case R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC:
94
14
  case R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC:
95
14
  case R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC:
96
14
  case R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC:
97
14
    return R_TLS;
98
51
  case R_AARCH64_CALL26:
99
51
  case R_AARCH64_CONDBR19:
100
51
  case R_AARCH64_JUMP26:
101
51
  case R_AARCH64_TSTBR14:
102
51
    return R_PLT_PC;
103
51
  case R_AARCH64_PREL16:
104
31
  case R_AARCH64_PREL32:
105
31
  case R_AARCH64_PREL64:
106
31
  case R_AARCH64_ADR_PREL_LO21:
107
31
  case R_AARCH64_LD_PREL_LO19:
108
31
    return R_PC;
109
88
  case R_AARCH64_ADR_PREL_PG_HI21:
110
88
    return R_PAGE_PC;
111
60
  case R_AARCH64_LD64_GOT_LO12_NC:
112
60
  case R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC:
113
60
    return R_GOT;
114
60
  case R_AARCH64_ADR_GOT_PAGE:
115
11
  case R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21:
116
11
    return R_GOT_PAGE_PC;
117
11
  case R_AARCH64_NONE:
118
1
    return R_NONE;
119
151
  default:
120
151
    return R_ABS;
121
431
  }
122
431
}
123
124
RelExpr AArch64::adjustRelaxExpr(RelType Type, const uint8_t *Data,
125
8
                                 RelExpr Expr) const {
126
8
  if (Expr == R_RELAX_TLS_GD_TO_IE) {
127
4
    if (Type == R_AARCH64_TLSDESC_ADR_PAGE21)
128
1
      return R_RELAX_TLS_GD_TO_IE_PAGE_PC;
129
3
    return R_RELAX_TLS_GD_TO_IE_ABS;
130
3
  }
131
4
  return Expr;
132
4
}
133
134
139
bool AArch64::usesOnlyLowPageBits(RelType Type) const {
135
139
  switch (Type) {
136
139
  default:
137
76
    return false;
138
139
  case R_AARCH64_ADD_ABS_LO12_NC:
139
63
  case R_AARCH64_LD64_GOT_LO12_NC:
140
63
  case R_AARCH64_LDST128_ABS_LO12_NC:
141
63
  case R_AARCH64_LDST16_ABS_LO12_NC:
142
63
  case R_AARCH64_LDST32_ABS_LO12_NC:
143
63
  case R_AARCH64_LDST64_ABS_LO12_NC:
144
63
  case R_AARCH64_LDST8_ABS_LO12_NC:
145
63
  case R_AARCH64_TLSDESC_ADD_LO12:
146
63
  case R_AARCH64_TLSDESC_LD64_LO12:
147
63
  case R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC:
148
63
    return true;
149
139
  }
150
139
}
151
152
11
RelType AArch64::getDynRel(RelType Type) const {
153
11
  if (Type == R_AARCH64_ABS32 || Type == R_AARCH64_ABS64)
154
7
    return Type;
155
4
  return R_AARCH64_NONE;
156
4
}
157
158
22
void AArch64::writeGotPlt(uint8_t *Buf, const Symbol &) const {
159
22
  write64le(Buf, InX::Plt->getVA());
160
22
}
161
162
7
void AArch64::writePltHeader(uint8_t *Buf) const {
163
7
  const uint8_t PltData[] = {
164
7
      0xf0, 0x7b, 0xbf, 0xa9, // stp    x16, x30, [sp,#-16]!
165
7
      0x10, 0x00, 0x00, 0x90, // adrp   x16, Page(&(.plt.got[2]))
166
7
      0x11, 0x02, 0x40, 0xf9, // ldr    x17, [x16, Offset(&(.plt.got[2]))]
167
7
      0x10, 0x02, 0x00, 0x91, // add    x16, x16, Offset(&(.plt.got[2]))
168
7
      0x20, 0x02, 0x1f, 0xd6, // br     x17
169
7
      0x1f, 0x20, 0x03, 0xd5, // nop
170
7
      0x1f, 0x20, 0x03, 0xd5, // nop
171
7
      0x1f, 0x20, 0x03, 0xd5  // nop
172
7
  };
173
7
  memcpy(Buf, PltData, sizeof(PltData));
174
7
175
7
  uint64_t Got = InX::GotPlt->getVA();
176
7
  uint64_t Plt = InX::Plt->getVA();
177
7
  relocateOne(Buf + 4, R_AARCH64_ADR_PREL_PG_HI21,
178
7
              getAArch64Page(Got + 16) - getAArch64Page(Plt + 4));
179
7
  relocateOne(Buf + 8, R_AARCH64_LDST64_ABS_LO12_NC, Got + 16);
180
7
  relocateOne(Buf + 12, R_AARCH64_ADD_ABS_LO12_NC, Got + 16);
181
7
}
182
183
void AArch64::writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr,
184
                       uint64_t PltEntryAddr, int32_t Index,
185
22
                       unsigned RelOff) const {
186
22
  const uint8_t Inst[] = {
187
22
      0x10, 0x00, 0x00, 0x90, // adrp x16, Page(&(.plt.got[n]))
188
22
      0x11, 0x02, 0x40, 0xf9, // ldr  x17, [x16, Offset(&(.plt.got[n]))]
189
22
      0x10, 0x02, 0x00, 0x91, // add  x16, x16, Offset(&(.plt.got[n]))
190
22
      0x20, 0x02, 0x1f, 0xd6  // br   x17
191
22
  };
192
22
  memcpy(Buf, Inst, sizeof(Inst));
193
22
194
22
  relocateOne(Buf, R_AARCH64_ADR_PREL_PG_HI21,
195
22
              getAArch64Page(GotPltEntryAddr) - getAArch64Page(PltEntryAddr));
196
22
  relocateOne(Buf + 4, R_AARCH64_LDST64_ABS_LO12_NC, GotPltEntryAddr);
197
22
  relocateOne(Buf + 8, R_AARCH64_ADD_ABS_LO12_NC, GotPltEntryAddr);
198
22
}
199
200
bool AArch64::needsThunk(RelExpr Expr, RelType Type, const InputFile *File,
201
442
                         uint64_t BranchAddr, const Symbol &S) const {
202
442
  // ELF for the ARM 64-bit architecture, section Call and Jump relocations
203
442
  // only permits range extension thunks for R_AARCH64_CALL26 and
204
442
  // R_AARCH64_JUMP26 relocation types.
205
442
  if (Type != R_AARCH64_CALL26 && 
Type != R_AARCH64_JUMP26417
)
206
361
    return false;
207
81
  uint64_t Dst = (Expr == R_PLT_PC) ? 
S.getPltVA()17
:
S.getVA()64
;
208
81
  return !inBranchRange(Type, BranchAddr, Dst);
209
81
}
210
211
99
bool AArch64::inBranchRange(RelType Type, uint64_t Src, uint64_t Dst) const {
212
99
  if (Type != R_AARCH64_CALL26 && 
Type != R_AARCH64_JUMP2658
)
213
0
    return true;
214
99
  // The AArch64 call and unconditional branch instructions have a range of
215
99
  // +/- 128 MiB.
216
99
  uint64_t Range = 128 * 1024 * 1024;
217
99
  if (Dst > Src) {
218
89
    // Immediate of branch is signed.
219
89
    Range -= 4;
220
89
    return Dst - Src <= Range;
221
89
  }
222
10
  return Src - Dst <= Range;
223
10
}
224
225
135
static void write32AArch64Addr(uint8_t *L, uint64_t Imm) {
226
135
  uint32_t ImmLo = (Imm & 0x3) << 29;
227
135
  uint32_t ImmHi = (Imm & 0x1FFFFC) << 3;
228
135
  uint64_t Mask = (0x3 << 29) | (0x1FFFFC << 3);
229
135
  write32le(L, (read32le(L) & ~Mask) | ImmLo | ImmHi);
230
135
}
231
232
// Return the bits [Start, End] from Val shifted Start bits.
233
// For instance, getBits(0xF0, 4, 8) returns 0xF.
234
135
static uint64_t getBits(uint64_t Val, int Start, int End) {
235
135
  uint64_t Mask = ((uint64_t)1 << (End + 1 - Start)) - 1;
236
135
  return (Val >> Start) & Mask;
237
135
}
238
239
315
static void or32le(uint8_t *P, int32_t V) { write32le(P, read32le(P) | V); }
240
241
// Update the immediate field in a AARCH64 ldr, str, and add instruction.
242
185
static void or32AArch64Imm(uint8_t *L, uint64_t Imm) {
243
185
  or32le(L, (Imm & 0xFFF) << 10);
244
185
}
245
246
524
void AArch64::relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const {
247
524
  switch (Type) {
248
524
  case R_AARCH64_ABS16:
249
13
  case R_AARCH64_PREL16:
250
13
    checkIntUInt(Loc, Val, 16, Type);
251
13
    write16le(Loc, Val);
252
13
    break;
253
16
  case R_AARCH64_ABS32:
254
16
  case R_AARCH64_PREL32:
255
16
    checkIntUInt(Loc, Val, 32, Type);
256
16
    write32le(Loc, Val);
257
16
    break;
258
45
  case R_AARCH64_ABS64:
259
45
  case R_AARCH64_GLOB_DAT:
260
45
  case R_AARCH64_PREL64:
261
45
    write64le(Loc, Val);
262
45
    break;
263
45
  case R_AARCH64_ADD_ABS_LO12_NC:
264
37
    or32AArch64Imm(Loc, Val);
265
37
    break;
266
131
  case R_AARCH64_ADR_GOT_PAGE:
267
131
  case R_AARCH64_ADR_PREL_PG_HI21:
268
131
  case R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21:
269
131
  case R_AARCH64_TLSDESC_ADR_PAGE21:
270
131
    checkInt(Loc, Val, 33, Type);
271
131
    write32AArch64Addr(Loc, Val >> 12);
272
131
    break;
273
131
  case R_AARCH64_ADR_PREL_LO21:
274
4
    checkInt(Loc, Val, 21, Type);
275
4
    write32AArch64Addr(Loc, Val);
276
4
    break;
277
131
  case R_AARCH64_JUMP26:
278
82
    // Normally we would just write the bits of the immediate field, however
279
82
    // when patching instructions for the cpu errata fix -fix-cortex-a53-843419
280
82
    // we want to replace a non-branch instruction with a branch immediate
281
82
    // instruction. By writing all the bits of the instruction including the
282
82
    // opcode and the immediate (0 001 | 01 imm26) we can do this
283
82
    // transformation by placing a R_AARCH64_JUMP26 relocation at the offset of
284
82
    // the instruction we want to patch.
285
82
    write32le(Loc, 0x14000000);
286
82
    LLVM_FALLTHROUGH;
287
104
  case R_AARCH64_CALL26:
288
104
    checkInt(Loc, Val, 28, Type);
289
104
    or32le(Loc, (Val & 0x0FFFFFFC) >> 2);
290
104
    break;
291
82
  case R_AARCH64_CONDBR19:
292
13
  case R_AARCH64_LD_PREL_LO19:
293
13
    checkAlignment(Loc, Val, 4, Type);
294
13
    checkInt(Loc, Val, 21, Type);
295
13
    or32le(Loc, (Val & 0x1FFFFC) << 3);
296
13
    break;
297
13
  case R_AARCH64_LDST8_ABS_LO12_NC:
298
4
  case R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC:
299
4
    or32AArch64Imm(Loc, getBits(Val, 0, 11));
300
4
    break;
301
7
  case R_AARCH64_LDST16_ABS_LO12_NC:
302
7
  case R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC:
303
7
    checkAlignment(Loc, Val, 2, Type);
304
7
    or32AArch64Imm(Loc, getBits(Val, 1, 11));
305
7
    break;
306
7
  case R_AARCH64_LDST32_ABS_LO12_NC:
307
5
  case R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC:
308
5
    checkAlignment(Loc, Val, 4, Type);
309
5
    or32AArch64Imm(Loc, getBits(Val, 2, 11));
310
5
    break;
311
114
  case R_AARCH64_LDST64_ABS_LO12_NC:
312
114
  case R_AARCH64_LD64_GOT_LO12_NC:
313
114
  case R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC:
314
114
  case R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC:
315
114
  case R_AARCH64_TLSDESC_LD64_LO12:
316
114
    checkAlignment(Loc, Val, 8, Type);
317
114
    or32AArch64Imm(Loc, getBits(Val, 3, 11));
318
114
    break;
319
114
  case R_AARCH64_LDST128_ABS_LO12_NC:
320
5
  case R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC:
321
5
    checkAlignment(Loc, Val, 16, Type);
322
5
    or32AArch64Imm(Loc, getBits(Val, 4, 11));
323
5
    break;
324
5
  case R_AARCH64_MOVW_UABS_G0_NC:
325
1
    or32le(Loc, (Val & 0xFFFF) << 5);
326
1
    break;
327
5
  case R_AARCH64_MOVW_UABS_G1_NC:
328
1
    or32le(Loc, (Val & 0xFFFF0000) >> 11);
329
1
    break;
330
5
  case R_AARCH64_MOVW_UABS_G2_NC:
331
1
    or32le(Loc, (Val & 0xFFFF00000000) >> 27);
332
1
    break;
333
5
  case R_AARCH64_MOVW_UABS_G3:
334
2
    or32le(Loc, (Val & 0xFFFF000000000000) >> 43);
335
2
    break;
336
8
  case R_AARCH64_TSTBR14:
337
8
    checkInt(Loc, Val, 16, Type);
338
8
    or32le(Loc, (Val & 0xFFFC) << 3);
339
8
    break;
340
7
  case R_AARCH64_TLSLE_ADD_TPREL_HI12:
341
7
    checkInt(Loc, Val, 24, Type);
342
7
    or32AArch64Imm(Loc, Val >> 12);
343
7
    break;
344
6
  case R_AARCH64_TLSLE_ADD_TPREL_LO12_NC:
345
6
  case R_AARCH64_TLSDESC_ADD_LO12:
346
6
    or32AArch64Imm(Loc, Val);
347
6
    break;
348
6
  default:
349
0
    error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
350
524
  }
351
524
}
352
353
4
void AArch64::relaxTlsGdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const {
354
4
  // TLSDESC Global-Dynamic relocation are in the form:
355
4
  //   adrp    x0, :tlsdesc:v             [R_AARCH64_TLSDESC_ADR_PAGE21]
356
4
  //   ldr     x1, [x0, #:tlsdesc_lo12:v  [R_AARCH64_TLSDESC_LD64_LO12]
357
4
  //   add     x0, x0, :tlsdesc_los:v     [R_AARCH64_TLSDESC_ADD_LO12]
358
4
  //   .tlsdesccall                       [R_AARCH64_TLSDESC_CALL]
359
4
  //   blr     x1
360
4
  // And it can optimized to:
361
4
  //   movz    x0, #0x0, lsl #16
362
4
  //   movk    x0, #0x10
363
4
  //   nop
364
4
  //   nop
365
4
  checkUInt(Loc, Val, 32, Type);
366
4
367
4
  switch (Type) {
368
4
  case R_AARCH64_TLSDESC_ADD_LO12:
369
2
  case R_AARCH64_TLSDESC_CALL:
370
2
    write32le(Loc, 0xd503201f); // nop
371
2
    return;
372
2
  case R_AARCH64_TLSDESC_ADR_PAGE21:
373
1
    write32le(Loc, 0xd2a00000 | (((Val >> 16) & 0xffff) << 5)); // movz
374
1
    return;
375
2
  case R_AARCH64_TLSDESC_LD64_LO12:
376
1
    write32le(Loc, 0xf2800000 | ((Val & 0xffff) << 5)); // movk
377
1
    return;
378
2
  default:
379
0
    llvm_unreachable("unsupported relocation for TLS GD to LE relaxation");
380
4
  }
381
4
}
382
383
4
void AArch64::relaxTlsGdToIe(uint8_t *Loc, RelType Type, uint64_t Val) const {
384
4
  // TLSDESC Global-Dynamic relocation are in the form:
385
4
  //   adrp    x0, :tlsdesc:v             [R_AARCH64_TLSDESC_ADR_PAGE21]
386
4
  //   ldr     x1, [x0, #:tlsdesc_lo12:v  [R_AARCH64_TLSDESC_LD64_LO12]
387
4
  //   add     x0, x0, :tlsdesc_los:v     [R_AARCH64_TLSDESC_ADD_LO12]
388
4
  //   .tlsdesccall                       [R_AARCH64_TLSDESC_CALL]
389
4
  //   blr     x1
390
4
  // And it can optimized to:
391
4
  //   adrp    x0, :gottprel:v
392
4
  //   ldr     x0, [x0, :gottprel_lo12:v]
393
4
  //   nop
394
4
  //   nop
395
4
396
4
  switch (Type) {
397
4
  case R_AARCH64_TLSDESC_ADD_LO12:
398
2
  case R_AARCH64_TLSDESC_CALL:
399
2
    write32le(Loc, 0xd503201f); // nop
400
2
    break;
401
2
  case R_AARCH64_TLSDESC_ADR_PAGE21:
402
1
    write32le(Loc, 0x90000000); // adrp
403
1
    relocateOne(Loc, R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21, Val);
404
1
    break;
405
2
  case R_AARCH64_TLSDESC_LD64_LO12:
406
1
    write32le(Loc, 0xf9400000); // ldr
407
1
    relocateOne(Loc, R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC, Val);
408
1
    break;
409
2
  default:
410
0
    llvm_unreachable("unsupported relocation for TLS GD to LE relaxation");
411
4
  }
412
4
}
413
414
7
void AArch64::relaxTlsIeToLe(uint8_t *Loc, RelType Type, uint64_t Val) const {
415
7
  checkUInt(Loc, Val, 32, Type);
416
7
417
7
  if (Type == R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21) {
418
4
    // Generate MOVZ.
419
4
    uint32_t RegNo = read32le(Loc) & 0x1f;
420
4
    write32le(Loc, (0xd2a00000 | RegNo) | (((Val >> 16) & 0xffff) << 5));
421
4
    return;
422
4
  }
423
3
  if (Type == R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC) {
424
3
    // Generate MOVK.
425
3
    uint32_t RegNo = read32le(Loc) & 0x1f;
426
3
    write32le(Loc, (0xf2800000 | RegNo) | ((Val & 0xffff) << 5));
427
3
    return;
428
3
  }
429
0
  llvm_unreachable("invalid relocation for TLS IE to LE relaxation");
430
0
}
431
432
94
TargetInfo *elf::getAArch64TargetInfo() {
433
94
  static AArch64 Target;
434
94
  return &Target;
435
94
}