TargetDataLayout.cpp Source File (original) (raw)

13#include

14using namespace llvm;

17 if (T.isOSBinFormatGOFF())

18 return "-m:l";

19 if (T.isOSBinFormatMachO())

20 return "-m:o";

21 if ((T.isOSWindows() || T.isUEFI()) && T.isOSBinFormatCOFF())

22 return T.getArch() == Triple::x86 ? "-m:x" : "-m:w";

23 if (T.isOSBinFormatXCOFF())

24 return "-m:a";

25 return "-m:e";

26}

30 std::string Ret;

32 if (TT.isLittleEndian())

34 Ret += "e";

35 else

37 Ret += "E";

42 Ret += "-p:32:32";

46 Ret += "-Fi8";

50 Ret += "-i64:64";

55 Ret += "-f64:32:64";

60 Ret += "-v64:32:64-v128:32:128";

62 Ret += "-v128:64:128";

66 Ret += "-a:0:32";

69 Ret += "-n32";

73 Ret += "-S128";

75 Ret += "-S64";

76 else

77 Ret += "-S32";

79 return Ret;

80}

84 if (TT.isOSBinFormatMachO()) {

86 return "e-m:o-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-"

87 "n32:64-S128-Fn32";

88 return "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-n32:64-S128-"

89 "Fn32";

90 }

91 if (TT.isOSBinFormatCOFF())

92 return "e-m:w-p270:32:32-p271:32:32-p272:64:64-p:64:64-i32:32-i64:64-i128:"

93 "128-n32:64-S128-Fn32";

94 std::string Endian = TT.isLittleEndian() ? "e" : "E";

95 std::string Ptr32 = TT.getEnvironment() == Triple::GNUILP32 ? "-p:32:32" : "";

96 return Endian + "-m:e" + Ptr32 +

97 "-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-"

98 "n32:64-S128-Fn32";

99}

100

101

104 return "E-m:e-p:64:64-i64:64-i128:128-n32:64-S128";

105 else

106 return "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128";

107}

108

110

111

112

113

114 return "e-m:e-S32-p:32:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:32"

115 "-v128:32:32-a:0:32-Fi32-n32";

116}

117

119 if (TT.isLoongArch64())

120 return "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128";

121 assert(TT.isLoongArch32() && "only LA32 and LA64 are currently supported");

122 return "e-m:e-p:32:32-i64:64-n32-S128";

123}

124

126 std::string Ret = "";

127

128 Ret += "E";

129

130

131 Ret += "-m:e";

132

133

134

135

136

137 Ret += "-p:32:16:32";

138

139

140

141 Ret += "-i8:8:8-i16:16:16-i32:16:32";

142

143

144

145

146 Ret += "-n8:16:32";

147

148 Ret += "-a:0:16-S16";

149

150 return Ret;

151}

152

153namespace {

154enum class MipsABI { Unknown, O32, N32, N64 };

155}

156

157

158

159

160

163 return MipsABI::O32;

165 return MipsABI::N32;

167 return MipsABI::N64;

168 if (TT.isABIN32())

169 return MipsABI::N32;

170 assert(ABIName.empty() && "Unknown ABI option for MIPS");

171

172 if (TT.isMIPS64())

173 return MipsABI::N64;

174 return MipsABI::O32;

175}

176

178 std::string Ret;

179 MipsABI ABI = getMipsABI(TT, ABIName);

180

181

182 if (TT.isLittleEndian())

183 Ret += "e";

184 else

185 Ret += "E";

186

187 if (ABI == MipsABI::O32)

188 Ret += "-m:m";

189 else

190 Ret += "-m:e";

191

192

193 if (ABI != MipsABI::N64)

194 Ret += "-p:32:32";

195

196

197

198 Ret += "-i8:8:32-i16:16:32-i64:64";

199

200

201

202

203 if (ABI == MipsABI::N64 || ABI == MipsABI::N32)

204 Ret += "-i128:128-n32:64-S128";

205 else

206 Ret += "-n32-S64";

207

208 return Ret;

209}

210

213 std::string Ret;

214

215

216 if (T.isLittleEndian())

217 Ret = "e";

218 else

219 Ret = "E";

220

222

223

224

226 Ret += "-p:32:32";

227

228

229

230

232 (.isPPC64ELFv2ABI() && ABIName != "elfv2"))) {

233 Ret += "-Fi64";

234 } else if (T.isOSAIX()) {

235 Ret += is64Bit ? "-Fi64" : "-Fi32";

236 } else {

237 Ret += "-Fn32";

238 }

239

240

241

242 Ret += "-i64:64";

243

244

246 Ret += "-i128:128-n32:64";

247 else

248 Ret += "-n32";

249

250

251 if (T.isOSAIX())

252 Ret += "-f64:32:64";

253

254

255

256

257 if (is64Bit && (T.isOSAIX() || T.isOSLinux()))

258 Ret += "-S128-v256:256:256-v512:512:512";

259

260 return Ret;

261}

262

265

266 return "e-m:e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"

267 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1";

268 }

269

270

271

272

273

274

275

276 return "e-m:e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32"

277 "-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-"

278 "v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-"

279 "v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9";

280}

281

283 std::string Ret;

284

285 if (TT.isLittleEndian())

286 Ret += "e";

287 else

288 Ret += "E";

289

290 Ret += "-m:e";

291

292

293 if (TT.isRISCV64()) {

294 Ret += "-p:64:64-i64:64-i128:128";

295 Ret += "-n32:64";

296 } else {

297 assert(TT.isRISCV32() && "only RV32 and RV64 are currently supported");

298 Ret += "-p:32:32-i64:64";

299 Ret += "-n32";

300 }

301

302

304 if (ABI == "ilp32e")

305 Ret += "-S32";

306 else if (ABI == "lp64e")

307 Ret += "-S64";

308 else

309 Ret += "-S128";

310

311 return Ret;

312}

313

315 const bool Is64Bit = T.isSPARC64();

316

317

318 std::string Ret = T.getArch() == Triple::sparcel ? "e" : "E";

319 Ret += "-m:e";

320

321

322 if (!Is64Bit)

323 Ret += "-p:32:32";

324

325

326 Ret += "-i64:64";

327

328

329

330 Ret += "-i128:128";

331

332

333

334 if (Is64Bit)

335 Ret += "-n32:64";

336 else

337 Ret += "-f128:64-n32";

338

339 if (Is64Bit)

340 Ret += "-S128";

341 else

342 Ret += "-S64";

343

344 return Ret;

345}

346

348 std::string Ret;

349

350

351 Ret += "E";

352

353

355

356

357 if (TT.isOSzOS()) {

358

359 Ret += "-p1:32:32";

360 }

361

362

363

364

365 Ret += "-i1:8:16-i8:8:16";

366

367

368 Ret += "-i64:64";

369

370

371 Ret += "-f128:64";

372

373

374

375 Ret += "-v128:64";

376

377

378 Ret += "-a:8:16";

379

380

381 Ret += "-n32:64";

382

383 return Ret;

384}

385

387 bool Is64Bit = TT.isX86_64();

388

389

390 std::string Ret = "e";

391

393

394 if (!Is64Bit || TT.isX32())

395 Ret += "-p:32:32";

396

397

398 Ret += "-p270:32:32-p271:32:32-p272:64:64";

399

400

401

402

403 if (Is64Bit || TT.isOSWindows())

404 Ret += "-i64:64-i128:128";

405 else if (TT.isOSIAMCU())

406 Ret += "-i64:32-f64:32";

407 else

408 Ret += "-i128:128-f64:32:64";

409

410

411 if (TT.isOSIAMCU())

412 ;

413 else if (Is64Bit || TT.isOSDarwin() || TT.isWindowsMSVCEnvironment())

414 Ret += "-f80:128";

415 else

416 Ret += "-f80:32";

417

418 if (TT.isOSIAMCU())

419 Ret += "-f128:32";

420

421

422 if (Is64Bit)

423 Ret += "-n8:16:32:64";

424 else

425 Ret += "-n8:16:32";

426

427

428 if ((!Is64Bit && TT.isOSWindows()) || TT.isOSIAMCU())

429 Ret += "-a:0:32-S32";

430 else

431 Ret += "-S128";

432

433 return Ret;

434}

435

438 std::string Ret = "e";

439

440

441

442

443 if (!Is64Bit)

444 Ret += "-p:32:32-p6:32:32-p7:32:32";

445 else if (ABIName == "shortptr")

446 Ret += "-p3:32:32-p4:32:32-p5:32:32-p6:32:32-p7:32:32";

447 else

448 Ret += "-p6:32:32";

449

450 Ret += "-i64:64-i128:128-i256:256-v16:16-v32:32-n16:32:64";

451

452 return Ret;

453}

454

456 const auto Arch = TT.getArch();

457

458

459

460

461

463 return "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-"

464 "v256:256-v512:512-v1024:1024-n8:16:32:64-G1";

466 return "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-"

467 "v512:512-v1024:1024-n8:16:32:64-G10";

470 return "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-"

471 "v512:512-v1024:1024-n32:64-S32-G1-P4-A0";

473 return "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-"

474 "v512:512-v1024:1024-n8:16:32:64-G1-P9-A0";

475 return "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-"

476 "v512:512-v1024:1024-n8:16:32:64-G1";

477}

478

480

481 return "E"

482 "-m:e"

483 "-p:32:32"

484 "-i64:64"

485 "-a:0:32"

486 "-n32"

487 "-S64";

488}

489

492 ? (TT.isOSEmscripten() ? "e-m:e-p:64:64-p10:8:8-p20:8:8-i64:64-"

493 "i128:128-f128:64-n32:64-S128-ni:1:10:20"

494 : "e-m:e-p:64:64-p10:8:8-p20:8:8-i64:64-"

495 "i128:128-n32:64-S128-ni:1:10:20")

496 : (TT.isOSEmscripten() ? "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-"

497 "i128:128-f128:64-n32:64-S128-ni:1:10:20"

498 : "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-"

499 "i128:128-n32:64-S128-ni:1:10:20");

500}

501

503

504 std::string Ret = "e";

505

506

507 Ret += "-m:e";

508

509

510 Ret += "-i64:64";

511

512

513 Ret += "-n32:64";

514

515

516 Ret += "-S128";

517

518

519

520

521 Ret += "-v64:64:64";

522 Ret += "-v128:64:64";

523 Ret += "-v256:64:64";

524 Ret += "-v512:64:64";

525 Ret += "-v1024:64:64";

526 Ret += "-v2048:64:64";

527 Ret += "-v4096:64:64";

528 Ret += "-v8192:64:64";

529 Ret += "-v16384:64:64";

530

531 return Ret;

532}

533

546 return "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"

547 "f32:32:32-i64:32-f64:32-a:0:32-n32";

549 return "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8:16-a:8";

556

557

558

559 return "e-m:e-p:32:32-i1:32-i8:8-i16:16-i32:32-i64:64-f16:16-"

560 "f32:32-f64:64-n8:16:32:64-v48:16:16-v96:32:32-v192:64:64";

562 return "e-m:e-p:32:32:32-a:0-n16:32-"

563 "i64:64:64-i32:32:32-i16:16:16-i1:8:8-f32:32:32-f64:64:64-"

564 "v32:32:32-v64:64:64-v512:512:512-v1024:1024:1024-v2048:2048:2048";

576 return "e-m:e-p:16:16-i32:16-i64:16-f32:16-f64:16-a:8-n8:16-S16";

602 return "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32-f64:32-a:0:32-n32";

604 return "e-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-n32";

621

630

631

632 return "";

633

635 return "";

636 }

638}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

static std::string computeX86DataLayout(const Triple &TT)

Definition TargetDataLayout.cpp:386

static std::string computeNVPTXDataLayout(const Triple &T, StringRef ABIName)

Definition TargetDataLayout.cpp:436

static std::string computePowerDataLayout(const Triple &T, StringRef ABIName)

Definition TargetDataLayout.cpp:211

static std::string computeSystemZDataLayout(const Triple &TT)

Definition TargetDataLayout.cpp:347

static std::string computeAMDDataLayout(const Triple &TT)

Definition TargetDataLayout.cpp:263

static std::string computeMipsDataLayout(const Triple &TT, StringRef ABIName)

Definition TargetDataLayout.cpp:177

static std::string computeBPFDataLayout(const Triple &TT)

Definition TargetDataLayout.cpp:102

static std::string computeSPIRVDataLayout(const Triple &TT)

Definition TargetDataLayout.cpp:455

static std::string computeWebAssemblyDataLayout(const Triple &TT)

Definition TargetDataLayout.cpp:490

static StringRef getManglingComponent(const Triple &T)

Definition TargetDataLayout.cpp:16

static std::string computeCSKYDataLayout(const Triple &TT)

Definition TargetDataLayout.cpp:109

static std::string computeLanaiDataLayout()

Definition TargetDataLayout.cpp:479

static std::string computeM68kDataLayout(const Triple &TT)

Definition TargetDataLayout.cpp:125

static std::string computeARMDataLayout(const Triple &TT, StringRef ABIName)

Definition TargetDataLayout.cpp:28

static MipsABI getMipsABI(const Triple &TT, StringRef ABIName)

Definition TargetDataLayout.cpp:161

static std::string computeLoongArchDataLayout(const Triple &TT)

Definition TargetDataLayout.cpp:118

static std::string computeVEDataLayout(const Triple &T)

Definition TargetDataLayout.cpp:502

static std::string computeSparcDataLayout(const Triple &T)

Definition TargetDataLayout.cpp:314

static std::string computeRISCVDataLayout(const Triple &TT, StringRef ABIName)

Definition TargetDataLayout.cpp:282

static std::string computeAArch64DataLayout(const Triple &TT)

Definition TargetDataLayout.cpp:83

static bool is64Bit(const char *name)

StringRef - Represent a constant reference to a string, i.e.

bool starts_with(StringRef Prefix) const

Check if this string starts with the given Prefix.

constexpr bool empty() const

empty - Check if the string is empty.

Triple - Helper class for working with autoconf configuration names.

LLVM_ABI std::string computeDataLayout(StringRef ABIName="") const

Compute the LLVM IR data layout string based on the triple.

Definition TargetDataLayout.cpp:534

ArchType getArch() const

Get the parsed architecture type of this triple.

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

LLVM_ABI LLVM_READONLY ARMABI computeTargetABI(const Triple &TT, StringRef ABIName="")

This is an optimization pass for GlobalISel generic memory operations.