~pali/+junk/llvm-toolchain-3.7 : revision 1

1

//===- unittests/IR/MetadataTest.cpp - Metadata unit tests ----------------===//

2

//

3

// The LLVM Compiler Infrastructure

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 "llvm/ADT/STLExtras.h"

11

#include "llvm/IR/Constants.h"

12

#include "llvm/IR/DebugInfo.h"

13

#include "llvm/IR/DebugInfoMetadata.h"

14

#include "llvm/IR/Function.h"

15

#include "llvm/IR/Instructions.h"

16

#include "llvm/IR/LLVMContext.h"

17

#include "llvm/IR/Metadata.h"

18

#include "llvm/IR/Module.h"

19

#include "llvm/IR/ModuleSlotTracker.h"

20

#include "llvm/IR/Type.h"

21

#include "llvm/IR/Verifier.h"

22

#include "llvm/Support/raw_ostream.h"

23

#include "gtest/gtest.h"

24

using namespace llvm;

25

26

namespace {

27

28

TEST(ContextAndReplaceableUsesTest, FromContext) {

29

LLVMContext Context;

30

ContextAndReplaceableUses CRU(Context);

31

EXPECT_EQ(&Context, &CRU.getContext());

32

EXPECT_FALSE(CRU.hasReplaceableUses());

33

EXPECT_FALSE(CRU.getReplaceableUses());

34

}

35

36

TEST(ContextAndReplaceableUsesTest, FromReplaceableUses) {

37

LLVMContext Context;

38

ContextAndReplaceableUses CRU(make_unique<ReplaceableMetadataImpl>(Context));

39

EXPECT_EQ(&Context, &CRU.getContext());

40

EXPECT_TRUE(CRU.hasReplaceableUses());

41

EXPECT_TRUE(CRU.getReplaceableUses());

42

}

43

44

TEST(ContextAndReplaceableUsesTest, makeReplaceable) {

45

LLVMContext Context;

46

ContextAndReplaceableUses CRU(Context);

47

CRU.makeReplaceable(make_unique<ReplaceableMetadataImpl>(Context));

48

EXPECT_EQ(&Context, &CRU.getContext());

49

EXPECT_TRUE(CRU.hasReplaceableUses());

50

EXPECT_TRUE(CRU.getReplaceableUses());

51

}

52

53

TEST(ContextAndReplaceableUsesTest, takeReplaceableUses) {

54

LLVMContext Context;

55

auto ReplaceableUses = make_unique<ReplaceableMetadataImpl>(Context);

56

auto *Ptr = ReplaceableUses.get();

57

ContextAndReplaceableUses CRU(std::move(ReplaceableUses));

58

ReplaceableUses = CRU.takeReplaceableUses();

59

EXPECT_EQ(&Context, &CRU.getContext());

60

EXPECT_FALSE(CRU.hasReplaceableUses());

61

EXPECT_FALSE(CRU.getReplaceableUses());

62

EXPECT_EQ(Ptr, ReplaceableUses.get());

63

}

64

65

class MetadataTest : public testing::Test {

66

public:

67

MetadataTest() : M("test", Context), Counter(0) {}

68

69

protected:

70

LLVMContext Context;

71

Module M;

72

int Counter;

73

74

MDNode *getNode() { return MDNode::get(Context, None); }

75

MDNode *getNode(Metadata *MD) { return MDNode::get(Context, MD); }

76

MDNode *getNode(Metadata *MD1, Metadata *MD2) {

77

Metadata *MDs[] = {MD1, MD2};

78

return MDNode::get(Context, MDs);

79

}

80

81

MDTuple *getTuple() { return MDTuple::getDistinct(Context, None); }

82

DISubroutineType *getSubroutineType() {

83

return DISubroutineType::getDistinct(Context, 0, getNode(nullptr));

84

}

85

DISubprogram *getSubprogram() {

86

return DISubprogram::getDistinct(Context, nullptr, "", "", nullptr, 0,

87

nullptr, false, false, 0, nullptr, 0, 0, 0,

88

0);

89

}

90

DIScopeRef getSubprogramRef() { return getSubprogram()->getRef(); }

91

DIFile *getFile() {

92

return DIFile::getDistinct(Context, "file.c", "/path/to/dir");

93

}

94

DITypeRef getBasicType(StringRef Name) {

95

return DIBasicType::get(Context, dwarf::DW_TAG_unspecified_type, Name)

96

->getRef();

97

}

98

DITypeRef getDerivedType() {

99

return DIDerivedType::getDistinct(Context, dwarf::DW_TAG_pointer_type, "",

100

nullptr, 0, nullptr,

101

getBasicType("basictype"), 1, 2, 0, 0)

102

->getRef();

103

}

104

Constant *getConstant() {

105

return ConstantInt::get(Type::getInt32Ty(Context), Counter++);

106

}

107

ConstantAsMetadata *getConstantAsMetadata() {

108

return ConstantAsMetadata::get(getConstant());

109

}

110

DITypeRef getCompositeType() {

111

return DICompositeType::getDistinct(

112

Context, dwarf::DW_TAG_structure_type, "", nullptr, 0, nullptr,

113

nullptr, 32, 32, 0, 0, nullptr, 0, nullptr, nullptr, "")

114

->getRef();

115

}

116

Function *getFunction(StringRef Name) {

117

return cast<Function>(M.getOrInsertFunction(

118

Name, FunctionType::get(Type::getVoidTy(Context), None, false)));

119

}

120

};

121

typedef MetadataTest MDStringTest;

122

123

// Test that construction of MDString with different value produces different

124

// MDString objects, even with the same string pointer and nulls in the string.

125

TEST_F(MDStringTest, CreateDifferent) {

126

char x[3] = { 'f', 0, 'A' };

127

MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));

128

x[2] = 'B';

129

MDString *s2 = MDString::get(Context, StringRef(&x[0], 3));

130

EXPECT_NE(s1, s2);

131

}

132

133

// Test that creation of MDStrings with the same string contents produces the

134

// same MDString object, even with different pointers.

135

TEST_F(MDStringTest, CreateSame) {

136

char x[4] = { 'a', 'b', 'c', 'X' };

137

char y[4] = { 'a', 'b', 'c', 'Y' };

138

139

MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));

140

MDString *s2 = MDString::get(Context, StringRef(&y[0], 3));

141

EXPECT_EQ(s1, s2);

142

}

143

144

// Test that MDString prints out the string we fed it.

145

TEST_F(MDStringTest, PrintingSimple) {

146

char *str = new char[13];

147

strncpy(str, "testing 1 2 3", 13);

148

MDString *s = MDString::get(Context, StringRef(str, 13));

149

strncpy(str, "aaaaaaaaaaaaa", 13);

150

delete[] str;

151

152

std::string Str;

153

raw_string_ostream oss(Str);

154

s->print(oss);

155

EXPECT_STREQ("!\"testing 1 2 3\"", oss.str().c_str());

156

}

157

158

// Test printing of MDString with non-printable characters.

159

TEST_F(MDStringTest, PrintingComplex) {

160

char str[5] = {0, '\n', '"', '\\', (char)-1};

161

MDString *s = MDString::get(Context, StringRef(str+0, 5));

162

std::string Str;

163

raw_string_ostream oss(Str);

164

s->print(oss);

165

EXPECT_STREQ("!\"\\00\\0A\\22\\5C\\FF\"", oss.str().c_str());

166

}

167

168

typedef MetadataTest MDNodeTest;

169

170

// Test the two constructors, and containing other Constants.

171

TEST_F(MDNodeTest, Simple) {

172

char x[3] = { 'a', 'b', 'c' };

173

char y[3] = { '1', '2', '3' };

174

175

MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));

176

MDString *s2 = MDString::get(Context, StringRef(&y[0], 3));

177

ConstantAsMetadata *CI = ConstantAsMetadata::get(

178

ConstantInt::get(getGlobalContext(), APInt(8, 0)));

179

180

std::vector<Metadata *> V;

181

V.push_back(s1);

182

V.push_back(CI);

183

V.push_back(s2);

184

185

MDNode *n1 = MDNode::get(Context, V);

186

Metadata *const c1 = n1;

187

MDNode *n2 = MDNode::get(Context, c1);

188

Metadata *const c2 = n2;

189

MDNode *n3 = MDNode::get(Context, V);

190

MDNode *n4 = MDNode::getIfExists(Context, V);

191

MDNode *n5 = MDNode::getIfExists(Context, c1);

192

MDNode *n6 = MDNode::getIfExists(Context, c2);

193

EXPECT_NE(n1, n2);

194

EXPECT_EQ(n1, n3);

195

EXPECT_EQ(n4, n1);

196

EXPECT_EQ(n5, n2);

197

EXPECT_EQ(n6, (Metadata *)nullptr);

198

199

EXPECT_EQ(3u, n1->getNumOperands());

200

EXPECT_EQ(s1, n1->getOperand(0));

201

EXPECT_EQ(CI, n1->getOperand(1));

202

EXPECT_EQ(s2, n1->getOperand(2));

203

204

EXPECT_EQ(1u, n2->getNumOperands());

205

EXPECT_EQ(n1, n2->getOperand(0));

206

}

207

208

TEST_F(MDNodeTest, Delete) {

209

Constant *C = ConstantInt::get(Type::getInt32Ty(getGlobalContext()), 1);

210

Instruction *I = new BitCastInst(C, Type::getInt32Ty(getGlobalContext()));

211

212

Metadata *const V = LocalAsMetadata::get(I);

213

MDNode *n = MDNode::get(Context, V);

214

TrackingMDRef wvh(n);

215

216

EXPECT_EQ(n, wvh);

217

218

delete I;

219

}

220

221

TEST_F(MDNodeTest, SelfReference) {

222

// !0 = !{!0}

223

// !1 = !{!0}

224

{

225

auto Temp = MDNode::getTemporary(Context, None);

226

Metadata *Args[] = {Temp.get()};

227

MDNode *Self = MDNode::get(Context, Args);

228

Self->replaceOperandWith(0, Self);

229

ASSERT_EQ(Self, Self->getOperand(0));

230

231

// Self-references should be distinct, so MDNode::get() should grab a

232

// uniqued node that references Self, not Self.

233

Args[0] = Self;

234

MDNode *Ref1 = MDNode::get(Context, Args);

235

MDNode *Ref2 = MDNode::get(Context, Args);

236

EXPECT_NE(Self, Ref1);

237

EXPECT_EQ(Ref1, Ref2);

238

}

239

240

// !0 = !{!0, !{}}

241

// !1 = !{!0, !{}}

242

{

243

auto Temp = MDNode::getTemporary(Context, None);

244

Metadata *Args[] = {Temp.get(), MDNode::get(Context, None)};

245

MDNode *Self = MDNode::get(Context, Args);

246

Self->replaceOperandWith(0, Self);

247

ASSERT_EQ(Self, Self->getOperand(0));

248

249

// Self-references should be distinct, so MDNode::get() should grab a

250

// uniqued node that references Self, not Self itself.

251

Args[0] = Self;

252

MDNode *Ref1 = MDNode::get(Context, Args);

253

MDNode *Ref2 = MDNode::get(Context, Args);

254

EXPECT_NE(Self, Ref1);

255

EXPECT_EQ(Ref1, Ref2);

256

}

257

}

258

259

TEST_F(MDNodeTest, Print) {

260

Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 7);

261

MDString *S = MDString::get(Context, "foo");

262

MDNode *N0 = getNode();

263

MDNode *N1 = getNode(N0);

264

MDNode *N2 = getNode(N0, N1);

265

266

Metadata *Args[] = {ConstantAsMetadata::get(C), S, nullptr, N0, N1, N2};

267

MDNode *N = MDNode::get(Context, Args);

268

269

std::string Expected;

270

{

271

raw_string_ostream OS(Expected);

272

OS << "<" << (void *)N << "> = !{";

273

C->printAsOperand(OS);

274

OS << ", ";

275

S->printAsOperand(OS);

276

OS << ", null";

277

MDNode *Nodes[] = {N0, N1, N2};

278

for (auto *Node : Nodes)

279

OS << ", <" << (void *)Node << ">";

280

OS << "}";

281

}

282

283

std::string Actual;

284

{

285

raw_string_ostream OS(Actual);

286

N->print(OS);

287

}

288

289

EXPECT_EQ(Expected, Actual);

290

}

291

292

#define EXPECT_PRINTER_EQ(EXPECTED, PRINT) \

293

do { \

294

std::string Actual_; \

295

raw_string_ostream OS(Actual_); \

296

PRINT; \

297

OS.flush(); \

298

std::string Expected_(EXPECTED); \

299

EXPECT_EQ(Expected_, Actual_); \

300

} while (false)

301

302

TEST_F(MDNodeTest, PrintTemporary) {

303

MDNode *Arg = getNode();

304

TempMDNode Temp = MDNode::getTemporary(Context, Arg);

305

MDNode *N = getNode(Temp.get());

306

Module M("test", Context);

307

NamedMDNode *NMD = M.getOrInsertNamedMetadata("named");

308

NMD->addOperand(N);

309

310

EXPECT_PRINTER_EQ("!0 = !{!1}", N->print(OS, &M));

311

EXPECT_PRINTER_EQ("!1 = <temporary!> !{!2}", Temp->print(OS, &M));

312

EXPECT_PRINTER_EQ("!2 = !{}", Arg->print(OS, &M));

313

314

// Cleanup.

315

Temp->replaceAllUsesWith(Arg);

316

}

317

318

TEST_F(MDNodeTest, PrintFromModule) {

319

Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 7);

320

MDString *S = MDString::get(Context, "foo");

321

MDNode *N0 = getNode();

322

MDNode *N1 = getNode(N0);

323

MDNode *N2 = getNode(N0, N1);

324

325

Metadata *Args[] = {ConstantAsMetadata::get(C), S, nullptr, N0, N1, N2};

326

MDNode *N = MDNode::get(Context, Args);

327

Module M("test", Context);

328

NamedMDNode *NMD = M.getOrInsertNamedMetadata("named");

329

NMD->addOperand(N);

330

331

std::string Expected;

332

{

333

raw_string_ostream OS(Expected);

334

OS << "!0 = !{";

335

C->printAsOperand(OS);

336

OS << ", ";

337

S->printAsOperand(OS);

338

OS << ", null, !1, !2, !3}";

339

}

340

341

EXPECT_PRINTER_EQ(Expected, N->print(OS, &M));

342

}

343

344

TEST_F(MDNodeTest, PrintFromFunction) {

345

Module M("test", Context);

346

auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);

347

auto *F0 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F0", &M);

348

auto *F1 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F1", &M);

349

auto *BB0 = BasicBlock::Create(Context, "entry", F0);

350

auto *BB1 = BasicBlock::Create(Context, "entry", F1);

351

auto *R0 = ReturnInst::Create(Context, BB0);

352

auto *R1 = ReturnInst::Create(Context, BB1);

353

auto *N0 = MDNode::getDistinct(Context, None);

354

auto *N1 = MDNode::getDistinct(Context, None);

355

R0->setMetadata("md", N0);

356

R1->setMetadata("md", N1);

357

358

EXPECT_PRINTER_EQ("!0 = distinct !{}", N0->print(OS, &M));

359

EXPECT_PRINTER_EQ("!1 = distinct !{}", N1->print(OS, &M));

360

361

ModuleSlotTracker MST(&M);

362

EXPECT_PRINTER_EQ("!0 = distinct !{}", N0->print(OS, MST));

363

EXPECT_PRINTER_EQ("!1 = distinct !{}", N1->print(OS, MST));

364

}

365

366

TEST_F(MDNodeTest, PrintFromMetadataAsValue) {

367

Module M("test", Context);

368

369

auto *Intrinsic =

370

Function::Create(FunctionType::get(Type::getVoidTy(Context),

371

Type::getMetadataTy(Context), false),

372

GlobalValue::ExternalLinkage, "llvm.intrinsic", &M);

373

374

auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);

375

auto *F0 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F0", &M);

376

auto *F1 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F1", &M);

377

auto *BB0 = BasicBlock::Create(Context, "entry", F0);

378

auto *BB1 = BasicBlock::Create(Context, "entry", F1);

379

auto *N0 = MDNode::getDistinct(Context, None);

380

auto *N1 = MDNode::getDistinct(Context, None);

381

auto *MAV0 = MetadataAsValue::get(Context, N0);

382

auto *MAV1 = MetadataAsValue::get(Context, N1);

383

CallInst::Create(Intrinsic, MAV0, "", BB0);

384

CallInst::Create(Intrinsic, MAV1, "", BB1);

385

386

EXPECT_PRINTER_EQ("!0 = distinct !{}", MAV0->print(OS));

387

EXPECT_PRINTER_EQ("!1 = distinct !{}", MAV1->print(OS));

388

EXPECT_PRINTER_EQ("!0", MAV0->printAsOperand(OS, false));

389

EXPECT_PRINTER_EQ("!1", MAV1->printAsOperand(OS, false));

390

EXPECT_PRINTER_EQ("metadata !0", MAV0->printAsOperand(OS, true));

391

EXPECT_PRINTER_EQ("metadata !1", MAV1->printAsOperand(OS, true));

392

393

ModuleSlotTracker MST(&M);

394

EXPECT_PRINTER_EQ("!0 = distinct !{}", MAV0->print(OS, MST));

395

EXPECT_PRINTER_EQ("!1 = distinct !{}", MAV1->print(OS, MST));

396

EXPECT_PRINTER_EQ("!0", MAV0->printAsOperand(OS, false, MST));

397

EXPECT_PRINTER_EQ("!1", MAV1->printAsOperand(OS, false, MST));

398

EXPECT_PRINTER_EQ("metadata !0", MAV0->printAsOperand(OS, true, MST));

399

EXPECT_PRINTER_EQ("metadata !1", MAV1->printAsOperand(OS, true, MST));

400

}

401

#undef EXPECT_PRINTER_EQ

402

403

TEST_F(MDNodeTest, NullOperand) {

404

// metadata !{}

405

MDNode *Empty = MDNode::get(Context, None);

406

407

// metadata !{metadata !{}}

408

Metadata *Ops[] = {Empty};

409

MDNode *N = MDNode::get(Context, Ops);

410

ASSERT_EQ(Empty, N->getOperand(0));

411

412

// metadata !{metadata !{}} => metadata !{null}

413

N->replaceOperandWith(0, nullptr);

414

ASSERT_EQ(nullptr, N->getOperand(0));

415

416

// metadata !{null}

417

Ops[0] = nullptr;

418

MDNode *NullOp = MDNode::get(Context, Ops);

419

ASSERT_EQ(nullptr, NullOp->getOperand(0));

420

EXPECT_EQ(N, NullOp);

421

}

422

423

TEST_F(MDNodeTest, DistinctOnUniquingCollision) {

424

// !{}

425

MDNode *Empty = MDNode::get(Context, None);

426

ASSERT_TRUE(Empty->isResolved());

427

EXPECT_FALSE(Empty->isDistinct());

428

429

// !{!{}}

430

Metadata *Wrapped1Ops[] = {Empty};

431

MDNode *Wrapped1 = MDNode::get(Context, Wrapped1Ops);

432

ASSERT_EQ(Empty, Wrapped1->getOperand(0));

433

ASSERT_TRUE(Wrapped1->isResolved());

434

EXPECT_FALSE(Wrapped1->isDistinct());

435

436

// !{!{!{}}}

437

Metadata *Wrapped2Ops[] = {Wrapped1};

438

MDNode *Wrapped2 = MDNode::get(Context, Wrapped2Ops);

439

ASSERT_EQ(Wrapped1, Wrapped2->getOperand(0));

440

ASSERT_TRUE(Wrapped2->isResolved());

441

EXPECT_FALSE(Wrapped2->isDistinct());

442

443

// !{!{!{}}} => !{!{}}

444

Wrapped2->replaceOperandWith(0, Empty);

445

ASSERT_EQ(Empty, Wrapped2->getOperand(0));

446

EXPECT_TRUE(Wrapped2->isDistinct());

447

EXPECT_FALSE(Wrapped1->isDistinct());

448

}

449

450

TEST_F(MDNodeTest, getDistinct) {

451

// !{}

452

MDNode *Empty = MDNode::get(Context, None);

453

ASSERT_TRUE(Empty->isResolved());

454

ASSERT_FALSE(Empty->isDistinct());

455

ASSERT_EQ(Empty, MDNode::get(Context, None));

456

457

// distinct !{}

458

MDNode *Distinct1 = MDNode::getDistinct(Context, None);

459

MDNode *Distinct2 = MDNode::getDistinct(Context, None);

460

EXPECT_TRUE(Distinct1->isResolved());

461

EXPECT_TRUE(Distinct2->isDistinct());

462

EXPECT_NE(Empty, Distinct1);

463

EXPECT_NE(Empty, Distinct2);

464

EXPECT_NE(Distinct1, Distinct2);

465

466

// !{}

467

ASSERT_EQ(Empty, MDNode::get(Context, None));

468

}

469

470

TEST_F(MDNodeTest, isUniqued) {

471

MDNode *U = MDTuple::get(Context, None);

472

MDNode *D = MDTuple::getDistinct(Context, None);

473

auto T = MDTuple::getTemporary(Context, None);

474

EXPECT_TRUE(U->isUniqued());

475

EXPECT_FALSE(D->isUniqued());

476

EXPECT_FALSE(T->isUniqued());

477

}

478

479

TEST_F(MDNodeTest, isDistinct) {

480

MDNode *U = MDTuple::get(Context, None);

481

MDNode *D = MDTuple::getDistinct(Context, None);

482

auto T = MDTuple::getTemporary(Context, None);

483

EXPECT_FALSE(U->isDistinct());

484

EXPECT_TRUE(D->isDistinct());

485

EXPECT_FALSE(T->isDistinct());

486

}

487

488

TEST_F(MDNodeTest, isTemporary) {

489

MDNode *U = MDTuple::get(Context, None);

490

MDNode *D = MDTuple::getDistinct(Context, None);

491

auto T = MDTuple::getTemporary(Context, None);

492

EXPECT_FALSE(U->isTemporary());

493

EXPECT_FALSE(D->isTemporary());

494

EXPECT_TRUE(T->isTemporary());

495

}

496

497

TEST_F(MDNodeTest, getDistinctWithUnresolvedOperands) {

498

// temporary !{}

499

auto Temp = MDTuple::getTemporary(Context, None);

500

ASSERT_FALSE(Temp->isResolved());

501

502

// distinct !{temporary !{}}

503

Metadata *Ops[] = {Temp.get()};

504

MDNode *Distinct = MDNode::getDistinct(Context, Ops);

505

EXPECT_TRUE(Distinct->isResolved());

506

EXPECT_EQ(Temp.get(), Distinct->getOperand(0));

507

508

// temporary !{} => !{}

509

MDNode *Empty = MDNode::get(Context, None);

510

Temp->replaceAllUsesWith(Empty);

511

EXPECT_EQ(Empty, Distinct->getOperand(0));

512

}

513

514

TEST_F(MDNodeTest, handleChangedOperandRecursion) {

515

// !0 = !{}

516

MDNode *N0 = MDNode::get(Context, None);

517

518

// !1 = !{!3, null}

519

auto Temp3 = MDTuple::getTemporary(Context, None);

520

Metadata *Ops1[] = {Temp3.get(), nullptr};

521

MDNode *N1 = MDNode::get(Context, Ops1);

522

523

// !2 = !{!3, !0}

524

Metadata *Ops2[] = {Temp3.get(), N0};

525

MDNode *N2 = MDNode::get(Context, Ops2);

526

527

// !3 = !{!2}

528

Metadata *Ops3[] = {N2};

529

MDNode *N3 = MDNode::get(Context, Ops3);

530

Temp3->replaceAllUsesWith(N3);

531

532

// !4 = !{!1}

533

Metadata *Ops4[] = {N1};

534

MDNode *N4 = MDNode::get(Context, Ops4);

535

536

// Confirm that the cycle prevented RAUW from getting dropped.

537

EXPECT_TRUE(N0->isResolved());

538

EXPECT_FALSE(N1->isResolved());

539

EXPECT_FALSE(N2->isResolved());

540

EXPECT_FALSE(N3->isResolved());

541

EXPECT_FALSE(N4->isResolved());

542

543

// Create a couple of distinct nodes to observe what's going on.

544

//

545

// !5 = distinct !{!2}

546

// !6 = distinct !{!3}

547

Metadata *Ops5[] = {N2};

548

MDNode *N5 = MDNode::getDistinct(Context, Ops5);

549

Metadata *Ops6[] = {N3};

550

MDNode *N6 = MDNode::getDistinct(Context, Ops6);

551

552

// Mutate !2 to look like !1, causing a uniquing collision (and an RAUW).

553

// This will ripple up, with !3 colliding with !4, and RAUWing. Since !2

554

// references !3, this can cause a re-entry of handleChangedOperand() when !3

555

// is not ready for it.

556

//

557

// !2->replaceOperandWith(1, nullptr)

558

// !2: !{!3, !0} => !{!3, null}

559

// !2->replaceAllUsesWith(!1)

560

// !3: !{!2] => !{!1}

561

// !3->replaceAllUsesWith(!4)

562

N2->replaceOperandWith(1, nullptr);

563

564

// If all has gone well, N2 and N3 will have been RAUW'ed and deleted from

565

// under us. Just check that the other nodes are sane.

566

//

567

// !1 = !{!4, null}

568

// !4 = !{!1}

569

// !5 = distinct !{!1}

570

// !6 = distinct !{!4}

571

EXPECT_EQ(N4, N1->getOperand(0));

572

EXPECT_EQ(N1, N4->getOperand(0));

573

EXPECT_EQ(N1, N5->getOperand(0));

574

EXPECT_EQ(N4, N6->getOperand(0));

575

}

576

577

TEST_F(MDNodeTest, replaceResolvedOperand) {

578

// Check code for replacing one resolved operand with another. If doing this

579

// directly (via replaceOperandWith()) becomes illegal, change the operand to

580

// a global value that gets RAUW'ed.

581

//

582

// Use a temporary node to keep N from being resolved.

583

auto Temp = MDTuple::getTemporary(Context, None);

584

Metadata *Ops[] = {nullptr, Temp.get()};

585

586

MDNode *Empty = MDTuple::get(Context, ArrayRef<Metadata *>());

587

MDNode *N = MDTuple::get(Context, Ops);

588

EXPECT_EQ(nullptr, N->getOperand(0));

589

ASSERT_FALSE(N->isResolved());

590

591

// Check code for replacing resolved nodes.

592

N->replaceOperandWith(0, Empty);

593

EXPECT_EQ(Empty, N->getOperand(0));

594

595

// Check code for adding another unresolved operand.

596

N->replaceOperandWith(0, Temp.get());

597

EXPECT_EQ(Temp.get(), N->getOperand(0));

598

599

// Remove the references to Temp; required for teardown.

600

Temp->replaceAllUsesWith(nullptr);

601

}

602

603

TEST_F(MDNodeTest, replaceWithUniqued) {

604

auto *Empty = MDTuple::get(Context, None);

605

MDTuple *FirstUniqued;

606

{

607

Metadata *Ops[] = {Empty};

608

auto Temp = MDTuple::getTemporary(Context, Ops);

609

EXPECT_TRUE(Temp->isTemporary());

610

611

// Don't expect a collision.

612

auto *Current = Temp.get();

613

FirstUniqued = MDNode::replaceWithUniqued(std::move(Temp));

614

EXPECT_TRUE(FirstUniqued->isUniqued());

615

EXPECT_TRUE(FirstUniqued->isResolved());

616

EXPECT_EQ(Current, FirstUniqued);

617

}

618

{

619

Metadata *Ops[] = {Empty};

620

auto Temp = MDTuple::getTemporary(Context, Ops);

621

EXPECT_TRUE(Temp->isTemporary());

622

623

// Should collide with Uniqued above this time.

624

auto *Uniqued = MDNode::replaceWithUniqued(std::move(Temp));

625

EXPECT_TRUE(Uniqued->isUniqued());

626

EXPECT_TRUE(Uniqued->isResolved());

627

EXPECT_EQ(FirstUniqued, Uniqued);

628

}

629

{

630

auto Unresolved = MDTuple::getTemporary(Context, None);

631

Metadata *Ops[] = {Unresolved.get()};

632

auto Temp = MDTuple::getTemporary(Context, Ops);

633

EXPECT_TRUE(Temp->isTemporary());

634

635

// Shouldn't be resolved.

636

auto *Uniqued = MDNode::replaceWithUniqued(std::move(Temp));

637

EXPECT_TRUE(Uniqued->isUniqued());

638

EXPECT_FALSE(Uniqued->isResolved());

639

640

// Should be a different node.

641

EXPECT_NE(FirstUniqued, Uniqued);

642

643

// Should resolve when we update its node (note: be careful to avoid a

644

// collision with any other nodes above).

645

Uniqued->replaceOperandWith(0, nullptr);

646

EXPECT_TRUE(Uniqued->isResolved());

647

}

648

}

649

650

TEST_F(MDNodeTest, replaceWithUniquedResolvingOperand) {

651

// temp !{}

652

MDTuple *Op = MDTuple::getTemporary(Context, None).release();

653

EXPECT_FALSE(Op->isResolved());

654

655

// temp !{temp !{}}

656

Metadata *Ops[] = {Op};

657

MDTuple *N = MDTuple::getTemporary(Context, Ops).release();

658

EXPECT_FALSE(N->isResolved());

659

660

// temp !{temp !{}} => !{temp !{}}

661

ASSERT_EQ(N, MDNode::replaceWithUniqued(TempMDTuple(N)));

662

EXPECT_FALSE(N->isResolved());

663

664

// !{temp !{}} => !{!{}}

665

ASSERT_EQ(Op, MDNode::replaceWithUniqued(TempMDTuple(Op)));

666

EXPECT_TRUE(Op->isResolved());

667

EXPECT_TRUE(N->isResolved());

668

}

669

670

TEST_F(MDNodeTest, replaceWithUniquedChangingOperand) {

671

// i1* @GV

672

Type *Ty = Type::getInt1PtrTy(Context);

673

std::unique_ptr<GlobalVariable> GV(

674

new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));

675

ConstantAsMetadata *Op = ConstantAsMetadata::get(GV.get());

676

677

// temp !{i1* @GV}

678

Metadata *Ops[] = {Op};

679

MDTuple *N = MDTuple::getTemporary(Context, Ops).release();

680

681

// temp !{i1* @GV} => !{i1* @GV}

682

ASSERT_EQ(N, MDNode::replaceWithUniqued(TempMDTuple(N)));

683

ASSERT_TRUE(N->isUniqued());

684

685

// !{i1* @GV} => !{null}

686

GV.reset();

687

ASSERT_TRUE(N->isUniqued());

688

Metadata *NullOps[] = {nullptr};

689

ASSERT_EQ(N, MDTuple::get(Context, NullOps));

690

}

691

692

TEST_F(MDNodeTest, replaceWithDistinct) {

693

{

694

auto *Empty = MDTuple::get(Context, None);

695

Metadata *Ops[] = {Empty};

696

auto Temp = MDTuple::getTemporary(Context, Ops);

697

EXPECT_TRUE(Temp->isTemporary());

698

699

// Don't expect a collision.

700

auto *Current = Temp.get();

701

auto *Distinct = MDNode::replaceWithDistinct(std::move(Temp));

702

EXPECT_TRUE(Distinct->isDistinct());

703

EXPECT_TRUE(Distinct->isResolved());

704

EXPECT_EQ(Current, Distinct);

705

}

706

{

707

auto Unresolved = MDTuple::getTemporary(Context, None);

708

Metadata *Ops[] = {Unresolved.get()};

709

auto Temp = MDTuple::getTemporary(Context, Ops);

710

EXPECT_TRUE(Temp->isTemporary());

711

712

// Don't expect a collision.

713

auto *Current = Temp.get();

714

auto *Distinct = MDNode::replaceWithDistinct(std::move(Temp));

715

EXPECT_TRUE(Distinct->isDistinct());

716

EXPECT_TRUE(Distinct->isResolved());

717

EXPECT_EQ(Current, Distinct);

718

719

// Cleanup; required for teardown.

720

Unresolved->replaceAllUsesWith(nullptr);

721

}

722

}

723

724

TEST_F(MDNodeTest, replaceWithPermanent) {

725

Metadata *Ops[] = {nullptr};

726

auto Temp = MDTuple::getTemporary(Context, Ops);

727

auto *T = Temp.get();

728

729

// U is a normal, uniqued node that references T.

730

auto *U = MDTuple::get(Context, T);

731

EXPECT_TRUE(U->isUniqued());

732

733

// Make Temp self-referencing.

734

Temp->replaceOperandWith(0, T);

735

736

// Try to uniquify Temp. This should, despite the name in the API, give a

737

// 'distinct' node, since self-references aren't allowed to be uniqued.

738

//

739

// Since it's distinct, N should have the same address as when it was a

740

// temporary (i.e., be equal to T not U).

741

auto *N = MDNode::replaceWithPermanent(std::move(Temp));

742

EXPECT_EQ(N, T);

743

EXPECT_TRUE(N->isDistinct());

744

745

// U should be the canonical unique node with N as the argument.

746

EXPECT_EQ(U, MDTuple::get(Context, N));

747

EXPECT_TRUE(U->isUniqued());

748

749

// This temporary should collide with U when replaced, but it should still be

750

// uniqued.

751

EXPECT_EQ(U, MDNode::replaceWithPermanent(MDTuple::getTemporary(Context, N)));

752

EXPECT_TRUE(U->isUniqued());

753

754

// This temporary should become a new uniqued node.

755

auto Temp2 = MDTuple::getTemporary(Context, U);

756

auto *V = Temp2.get();

757

EXPECT_EQ(V, MDNode::replaceWithPermanent(std::move(Temp2)));

758

EXPECT_TRUE(V->isUniqued());

759

EXPECT_EQ(U, V->getOperand(0));

760

}

761

762

TEST_F(MDNodeTest, deleteTemporaryWithTrackingRef) {

763

TrackingMDRef Ref;

764

EXPECT_EQ(nullptr, Ref.get());

765

{

766

auto Temp = MDTuple::getTemporary(Context, None);

767

Ref.reset(Temp.get());

768

EXPECT_EQ(Temp.get(), Ref.get());

769

}

770

EXPECT_EQ(nullptr, Ref.get());

771

}

772

773

typedef MetadataTest DILocationTest;

774

775

TEST_F(DILocationTest, Overflow) {

776

DISubprogram *N = getSubprogram();

777

{

778

DILocation *L = DILocation::get(Context, 2, 7, N);

779

EXPECT_EQ(2u, L->getLine());

780

EXPECT_EQ(7u, L->getColumn());

781

}

782

unsigned U16 = 1u << 16;

783

{

784

DILocation *L = DILocation::get(Context, UINT32_MAX, U16 - 1, N);

785

EXPECT_EQ(UINT32_MAX, L->getLine());

786

EXPECT_EQ(U16 - 1, L->getColumn());

787

}

788

{

789

DILocation *L = DILocation::get(Context, UINT32_MAX, U16, N);

790

EXPECT_EQ(UINT32_MAX, L->getLine());

791

EXPECT_EQ(0u, L->getColumn());

792

}

793

{

794

DILocation *L = DILocation::get(Context, UINT32_MAX, U16 + 1, N);

795

EXPECT_EQ(UINT32_MAX, L->getLine());

796

EXPECT_EQ(0u, L->getColumn());

797

}

798

}

799

800

TEST_F(DILocationTest, getDistinct) {

801

MDNode *N = getSubprogram();

802

DILocation *L0 = DILocation::getDistinct(Context, 2, 7, N);

803

EXPECT_TRUE(L0->isDistinct());

804

DILocation *L1 = DILocation::get(Context, 2, 7, N);

805

EXPECT_FALSE(L1->isDistinct());

806

EXPECT_EQ(L1, DILocation::get(Context, 2, 7, N));

807

}

808

809

TEST_F(DILocationTest, getTemporary) {

810

MDNode *N = MDNode::get(Context, None);

811

auto L = DILocation::getTemporary(Context, 2, 7, N);

812

EXPECT_TRUE(L->isTemporary());

813

EXPECT_FALSE(L->isResolved());

814

}

815

816

typedef MetadataTest GenericDINodeTest;

817

818

TEST_F(GenericDINodeTest, get) {

819

StringRef Header = "header";

820

auto *Empty = MDNode::get(Context, None);

821

Metadata *Ops1[] = {Empty};

822

auto *N = GenericDINode::get(Context, 15, Header, Ops1);

823

EXPECT_EQ(15u, N->getTag());

824

EXPECT_EQ(2u, N->getNumOperands());

825

EXPECT_EQ(Header, N->getHeader());

826

EXPECT_EQ(MDString::get(Context, Header), N->getOperand(0));

827

EXPECT_EQ(1u, N->getNumDwarfOperands());

828

EXPECT_EQ(Empty, N->getDwarfOperand(0));

829

EXPECT_EQ(Empty, N->getOperand(1));

830

ASSERT_TRUE(N->isUniqued());

831

832

EXPECT_EQ(N, GenericDINode::get(Context, 15, Header, Ops1));

833

834

N->replaceOperandWith(1, nullptr);

835

EXPECT_EQ(15u, N->getTag());

836

EXPECT_EQ(Header, N->getHeader());

837

EXPECT_EQ(nullptr, N->getDwarfOperand(0));

838

ASSERT_TRUE(N->isUniqued());

839

840

Metadata *Ops2[] = {nullptr};

841

EXPECT_EQ(N, GenericDINode::get(Context, 15, Header, Ops2));

842

843

N->replaceDwarfOperandWith(0, Empty);

844

EXPECT_EQ(15u, N->getTag());

845

EXPECT_EQ(Header, N->getHeader());

846

EXPECT_EQ(Empty, N->getDwarfOperand(0));

847

ASSERT_TRUE(N->isUniqued());

848

EXPECT_EQ(N, GenericDINode::get(Context, 15, Header, Ops1));

849

850

TempGenericDINode Temp = N->clone();

851

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

852

}

853

854

TEST_F(GenericDINodeTest, getEmptyHeader) {

855

// Canonicalize !"" to null.

856

auto *N = GenericDINode::get(Context, 15, StringRef(), None);

857

EXPECT_EQ(StringRef(), N->getHeader());

858

EXPECT_EQ(nullptr, N->getOperand(0));

859

}

860

861

typedef MetadataTest DISubrangeTest;

862

863

TEST_F(DISubrangeTest, get) {

864

auto *N = DISubrange::get(Context, 5, 7);

865

EXPECT_EQ(dwarf::DW_TAG_subrange_type, N->getTag());

866

EXPECT_EQ(5, N->getCount());

867

EXPECT_EQ(7, N->getLowerBound());

868

EXPECT_EQ(N, DISubrange::get(Context, 5, 7));

869

EXPECT_EQ(DISubrange::get(Context, 5, 0), DISubrange::get(Context, 5));

870

871

TempDISubrange Temp = N->clone();

872

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

873

}

874

875

TEST_F(DISubrangeTest, getEmptyArray) {

876

auto *N = DISubrange::get(Context, -1, 0);

877

EXPECT_EQ(dwarf::DW_TAG_subrange_type, N->getTag());

878

EXPECT_EQ(-1, N->getCount());

879

EXPECT_EQ(0, N->getLowerBound());

880

EXPECT_EQ(N, DISubrange::get(Context, -1, 0));

881

}

882

883

typedef MetadataTest DIEnumeratorTest;

884

885

TEST_F(DIEnumeratorTest, get) {

886

auto *N = DIEnumerator::get(Context, 7, "name");

887

EXPECT_EQ(dwarf::DW_TAG_enumerator, N->getTag());

888

EXPECT_EQ(7, N->getValue());

889

EXPECT_EQ("name", N->getName());

890

EXPECT_EQ(N, DIEnumerator::get(Context, 7, "name"));

891

892

EXPECT_NE(N, DIEnumerator::get(Context, 8, "name"));

893

EXPECT_NE(N, DIEnumerator::get(Context, 7, "nam"));

894

895

TempDIEnumerator Temp = N->clone();

896

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

897

}

898

899

typedef MetadataTest DIBasicTypeTest;

900

901

TEST_F(DIBasicTypeTest, get) {

902

auto *N =

903

DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33, 26, 7);

904

EXPECT_EQ(dwarf::DW_TAG_base_type, N->getTag());

905

EXPECT_EQ("special", N->getName());

906

EXPECT_EQ(33u, N->getSizeInBits());

907

EXPECT_EQ(26u, N->getAlignInBits());

908

EXPECT_EQ(7u, N->getEncoding());

909

EXPECT_EQ(0u, N->getLine());

910

EXPECT_EQ(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,

911

26, 7));

912

913

EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_unspecified_type,

914

"special", 33, 26, 7));

915

EXPECT_NE(N,

916

DIBasicType::get(Context, dwarf::DW_TAG_base_type, "s", 33, 26, 7));

917

EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 32,

918

26, 7));

919

EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,

920

25, 7));

921

EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,

922

26, 6));

923

924

TempDIBasicType Temp = N->clone();

925

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

926

}

927

928

TEST_F(DIBasicTypeTest, getWithLargeValues) {

929

auto *N = DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special",

930

UINT64_MAX, UINT64_MAX - 1, 7);

931

EXPECT_EQ(UINT64_MAX, N->getSizeInBits());

932

EXPECT_EQ(UINT64_MAX - 1, N->getAlignInBits());

933

}

934

935

TEST_F(DIBasicTypeTest, getUnspecified) {

936

auto *N =

937

DIBasicType::get(Context, dwarf::DW_TAG_unspecified_type, "unspecified");

938

EXPECT_EQ(dwarf::DW_TAG_unspecified_type, N->getTag());

939

EXPECT_EQ("unspecified", N->getName());

940

EXPECT_EQ(0u, N->getSizeInBits());

941

EXPECT_EQ(0u, N->getAlignInBits());

942

EXPECT_EQ(0u, N->getEncoding());

943

EXPECT_EQ(0u, N->getLine());

944

}

945

946

typedef MetadataTest DITypeTest;

947

948

TEST_F(DITypeTest, clone) {

949

// Check that DIType has a specialized clone that returns TempDIType.

950

DIType *N = DIBasicType::get(Context, dwarf::DW_TAG_base_type, "int", 32, 32,

951

dwarf::DW_ATE_signed);

952

953

TempDIType Temp = N->clone();

954

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

955

}

956

957

TEST_F(DITypeTest, setFlags) {

958

// void (void)

959

Metadata *TypesOps[] = {nullptr};

960

Metadata *Types = MDTuple::get(Context, TypesOps);

961

962

DIType *D = DISubroutineType::getDistinct(Context, 0u, Types);

963

EXPECT_EQ(0u, D->getFlags());

964

D->setFlags(DINode::FlagRValueReference);

965

EXPECT_EQ(DINode::FlagRValueReference, D->getFlags());

966

D->setFlags(0u);

967

EXPECT_EQ(0u, D->getFlags());

968

969

TempDIType T = DISubroutineType::getTemporary(Context, 0u, Types);

970

EXPECT_EQ(0u, T->getFlags());

971

T->setFlags(DINode::FlagRValueReference);

972

EXPECT_EQ(DINode::FlagRValueReference, T->getFlags());

973

T->setFlags(0u);

974

EXPECT_EQ(0u, T->getFlags());

975

}

976

977

typedef MetadataTest DIDerivedTypeTest;

978

979

TEST_F(DIDerivedTypeTest, get) {

980

DIFile *File = getFile();

981

DIScopeRef Scope = getSubprogramRef();

982

DITypeRef BaseType = getBasicType("basic");

983

MDTuple *ExtraData = getTuple();

984

985

auto *N = DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "something",

986

File, 1, Scope, BaseType, 2, 3, 4, 5, ExtraData);

987

EXPECT_EQ(dwarf::DW_TAG_pointer_type, N->getTag());

988

EXPECT_EQ("something", N->getName());

989

EXPECT_EQ(File, N->getFile());

990

EXPECT_EQ(1u, N->getLine());

991

EXPECT_EQ(Scope, N->getScope());

992

EXPECT_EQ(BaseType, N->getBaseType());

993

EXPECT_EQ(2u, N->getSizeInBits());

994

EXPECT_EQ(3u, N->getAlignInBits());

995

EXPECT_EQ(4u, N->getOffsetInBits());

996

EXPECT_EQ(5u, N->getFlags());

997

EXPECT_EQ(ExtraData, N->getExtraData());

998

EXPECT_EQ(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,

999

"something", File, 1, Scope, BaseType, 2, 3,

1000

4, 5, ExtraData));

1001

1002

EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_reference_type,

1003

"something", File, 1, Scope, BaseType, 2, 3,

1004

4, 5, ExtraData));

1005

EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "else",

1006

File, 1, Scope, BaseType, 2, 3, 4, 5,

1007

ExtraData));

1008

EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,

1009

"something", getFile(), 1, Scope, BaseType, 2,

1010

3, 4, 5, ExtraData));

1011

EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,

1012

"something", File, 2, Scope, BaseType, 2, 3,

1013

4, 5, ExtraData));

1014

EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,

1015

"something", File, 1, getSubprogramRef(),

1016

BaseType, 2, 3, 4, 5, ExtraData));

1017

EXPECT_NE(N, DIDerivedType::get(

1018

Context, dwarf::DW_TAG_pointer_type, "something", File, 1,

1019

Scope, getBasicType("basic2"), 2, 3, 4, 5, ExtraData));

1020

EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,

1021

"something", File, 1, Scope, BaseType, 3, 3,

1022

4, 5, ExtraData));

1023

EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,

1024

"something", File, 1, Scope, BaseType, 2, 2,

1025

4, 5, ExtraData));

1026

EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,

1027

"something", File, 1, Scope, BaseType, 2, 3,

1028

5, 5, ExtraData));

1029

EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,

1030

"something", File, 1, Scope, BaseType, 2, 3,

1031

4, 4, ExtraData));

1032

EXPECT_NE(N, DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type,

1033

"something", File, 1, Scope, BaseType, 2, 3,

1034

4, 5, getTuple()));

1035

1036

TempDIDerivedType Temp = N->clone();

1037

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

1038

}

1039

1040

TEST_F(DIDerivedTypeTest, getWithLargeValues) {

1041

DIFile *File = getFile();

1042

DIScopeRef Scope = getSubprogramRef();

1043

DITypeRef BaseType = getBasicType("basic");

1044

MDTuple *ExtraData = getTuple();

1045

1046

auto *N = DIDerivedType::get(Context, dwarf::DW_TAG_pointer_type, "something",

1047

File, 1, Scope, BaseType, UINT64_MAX,

1048

UINT64_MAX - 1, UINT64_MAX - 2, 5, ExtraData);

1049

EXPECT_EQ(UINT64_MAX, N->getSizeInBits());

1050

EXPECT_EQ(UINT64_MAX - 1, N->getAlignInBits());

1051

EXPECT_EQ(UINT64_MAX - 2, N->getOffsetInBits());

1052

}

1053

1054

typedef MetadataTest DICompositeTypeTest;

1055

1056

TEST_F(DICompositeTypeTest, get) {

1057

unsigned Tag = dwarf::DW_TAG_structure_type;

1058

StringRef Name = "some name";

1059

DIFile *File = getFile();

1060

unsigned Line = 1;

1061

DIScopeRef Scope = getSubprogramRef();

1062

DITypeRef BaseType = getCompositeType();

1063

uint64_t SizeInBits = 2;

1064

uint64_t AlignInBits = 3;

1065

uint64_t OffsetInBits = 4;

1066

unsigned Flags = 5;

1067

MDTuple *Elements = getTuple();

1068

unsigned RuntimeLang = 6;

1069

DITypeRef VTableHolder = getCompositeType();

1070

MDTuple *TemplateParams = getTuple();

1071

StringRef Identifier = "some id";

1072

1073

auto *N = DICompositeType::get(Context, Tag, Name, File, Line, Scope,

1074

BaseType, SizeInBits, AlignInBits,

1075

OffsetInBits, Flags, Elements, RuntimeLang,

1076

VTableHolder, TemplateParams, Identifier);

1077

EXPECT_EQ(Tag, N->getTag());

1078

EXPECT_EQ(Name, N->getName());

1079

EXPECT_EQ(File, N->getFile());

1080

EXPECT_EQ(Line, N->getLine());

1081

EXPECT_EQ(Scope, N->getScope());

1082

EXPECT_EQ(BaseType, N->getBaseType());

1083

EXPECT_EQ(SizeInBits, N->getSizeInBits());

1084

EXPECT_EQ(AlignInBits, N->getAlignInBits());

1085

EXPECT_EQ(OffsetInBits, N->getOffsetInBits());

1086

EXPECT_EQ(Flags, N->getFlags());

1087

EXPECT_EQ(Elements, N->getElements().get());

1088

EXPECT_EQ(RuntimeLang, N->getRuntimeLang());

1089

EXPECT_EQ(VTableHolder, N->getVTableHolder());

1090

EXPECT_EQ(TemplateParams, N->getTemplateParams().get());

1091

EXPECT_EQ(Identifier, N->getIdentifier());

1092

1093

EXPECT_EQ(N, DICompositeType::get(Context, Tag, Name, File, Line, Scope,

1094

BaseType, SizeInBits, AlignInBits,

1095

OffsetInBits, Flags, Elements, RuntimeLang,

1096

VTableHolder, TemplateParams, Identifier));

1097

1098

EXPECT_NE(N, DICompositeType::get(Context, Tag + 1, Name, File, Line, Scope,

1099

BaseType, SizeInBits, AlignInBits,

1100

OffsetInBits, Flags, Elements, RuntimeLang,

1101

VTableHolder, TemplateParams, Identifier));

1102

EXPECT_NE(N, DICompositeType::get(Context, Tag, "abc", File, Line, Scope,

1103

BaseType, SizeInBits, AlignInBits,

1104

OffsetInBits, Flags, Elements, RuntimeLang,

1105

VTableHolder, TemplateParams, Identifier));

1106

EXPECT_NE(N, DICompositeType::get(Context, Tag, Name, getFile(), Line, Scope,

1107

BaseType, SizeInBits, AlignInBits,

1108

OffsetInBits, Flags, Elements, RuntimeLang,

1109

VTableHolder, TemplateParams, Identifier));

1110

EXPECT_NE(N, DICompositeType::get(Context, Tag, Name, File, Line + 1, Scope,

1111

BaseType, SizeInBits, AlignInBits,

1112

OffsetInBits, Flags, Elements, RuntimeLang,

1113

VTableHolder, TemplateParams, Identifier));

1114

EXPECT_NE(N, DICompositeType::get(

1115

Context, Tag, Name, File, Line, getSubprogramRef(), BaseType,

1116

SizeInBits, AlignInBits, OffsetInBits, Flags, Elements,

1117

RuntimeLang, VTableHolder, TemplateParams, Identifier));

1118

EXPECT_NE(N, DICompositeType::get(

1119

Context, Tag, Name, File, Line, Scope, getBasicType("other"),

1120

SizeInBits, AlignInBits, OffsetInBits, Flags, Elements,

1121

RuntimeLang, VTableHolder, TemplateParams, Identifier));

1122

EXPECT_NE(N, DICompositeType::get(Context, Tag, Name, File, Line, Scope,

1123

BaseType, SizeInBits + 1, AlignInBits,

1124

OffsetInBits, Flags, Elements, RuntimeLang,

1125

VTableHolder, TemplateParams, Identifier));

1126

EXPECT_NE(N, DICompositeType::get(Context, Tag, Name, File, Line, Scope,

1127

BaseType, SizeInBits, AlignInBits + 1,

1128

OffsetInBits, Flags, Elements, RuntimeLang,

1129

VTableHolder, TemplateParams, Identifier));

1130

EXPECT_NE(N, DICompositeType::get(

1131

Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,

1132

AlignInBits, OffsetInBits + 1, Flags, Elements, RuntimeLang,

1133

VTableHolder, TemplateParams, Identifier));

1134

EXPECT_NE(N, DICompositeType::get(

1135

Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,

1136

AlignInBits, OffsetInBits, Flags + 1, Elements, RuntimeLang,

1137

VTableHolder, TemplateParams, Identifier));

1138

EXPECT_NE(N, DICompositeType::get(

1139

Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,

1140

AlignInBits, OffsetInBits, Flags, getTuple(), RuntimeLang,

1141

VTableHolder, TemplateParams, Identifier));

1142

EXPECT_NE(N, DICompositeType::get(

1143

Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,

1144

AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang + 1,

1145

VTableHolder, TemplateParams, Identifier));

1146

EXPECT_NE(N, DICompositeType::get(

1147

Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,

1148

AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,

1149

getCompositeType(), TemplateParams, Identifier));

1150

EXPECT_NE(N, DICompositeType::get(Context, Tag, Name, File, Line, Scope,

1151

BaseType, SizeInBits, AlignInBits,

1152

OffsetInBits, Flags, Elements, RuntimeLang,

1153

VTableHolder, getTuple(), Identifier));

1154

EXPECT_NE(N, DICompositeType::get(Context, Tag, Name, File, Line, Scope,

1155

BaseType, SizeInBits, AlignInBits,

1156

OffsetInBits, Flags, Elements, RuntimeLang,

1157

VTableHolder, TemplateParams, "other"));

1158

1159

// Be sure that missing identifiers get null pointers.

1160

EXPECT_FALSE(DICompositeType::get(Context, Tag, Name, File, Line, Scope,

1161

BaseType, SizeInBits, AlignInBits,

1162

OffsetInBits, Flags, Elements, RuntimeLang,

1163

VTableHolder, TemplateParams, "")

1164

->getRawIdentifier());

1165

EXPECT_FALSE(DICompositeType::get(Context, Tag, Name, File, Line, Scope,

1166

BaseType, SizeInBits, AlignInBits,

1167

OffsetInBits, Flags, Elements, RuntimeLang,

1168

VTableHolder, TemplateParams)

1169

->getRawIdentifier());

1170

1171

TempDICompositeType Temp = N->clone();

1172

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

1173

}

1174

1175

TEST_F(DICompositeTypeTest, getWithLargeValues) {

1176

unsigned Tag = dwarf::DW_TAG_structure_type;

1177

StringRef Name = "some name";

1178

DIFile *File = getFile();

1179

unsigned Line = 1;

1180

DIScopeRef Scope = getSubprogramRef();

1181

DITypeRef BaseType = getCompositeType();

1182

uint64_t SizeInBits = UINT64_MAX;

1183

uint64_t AlignInBits = UINT64_MAX - 1;

1184

uint64_t OffsetInBits = UINT64_MAX - 2;

1185

unsigned Flags = 5;

1186

MDTuple *Elements = getTuple();

1187

unsigned RuntimeLang = 6;

1188

DITypeRef VTableHolder = getCompositeType();

1189

MDTuple *TemplateParams = getTuple();

1190

StringRef Identifier = "some id";

1191

1192

auto *N = DICompositeType::get(Context, Tag, Name, File, Line, Scope,

1193

BaseType, SizeInBits, AlignInBits,

1194

OffsetInBits, Flags, Elements, RuntimeLang,

1195

VTableHolder, TemplateParams, Identifier);

1196

EXPECT_EQ(SizeInBits, N->getSizeInBits());

1197

EXPECT_EQ(AlignInBits, N->getAlignInBits());

1198

EXPECT_EQ(OffsetInBits, N->getOffsetInBits());

1199

}

1200

1201

TEST_F(DICompositeTypeTest, replaceOperands) {

1202

unsigned Tag = dwarf::DW_TAG_structure_type;

1203

StringRef Name = "some name";

1204

DIFile *File = getFile();

1205

unsigned Line = 1;

1206

DIScopeRef Scope = getSubprogramRef();

1207

DITypeRef BaseType = getCompositeType();

1208

uint64_t SizeInBits = 2;

1209

uint64_t AlignInBits = 3;

1210

uint64_t OffsetInBits = 4;

1211

unsigned Flags = 5;

1212

unsigned RuntimeLang = 6;

1213

StringRef Identifier = "some id";

1214

1215

auto *N = DICompositeType::get(

1216

Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits,

1217

OffsetInBits, Flags, nullptr, RuntimeLang, nullptr, nullptr, Identifier);

1218

1219

auto *Elements = MDTuple::getDistinct(Context, None);

1220

EXPECT_EQ(nullptr, N->getElements().get());

1221

N->replaceElements(Elements);

1222

EXPECT_EQ(Elements, N->getElements().get());

1223

N->replaceElements(nullptr);

1224

EXPECT_EQ(nullptr, N->getElements().get());

1225

1226

DITypeRef VTableHolder = getCompositeType();

1227

EXPECT_EQ(nullptr, N->getVTableHolder());

1228

N->replaceVTableHolder(VTableHolder);

1229

EXPECT_EQ(VTableHolder, N->getVTableHolder());

1230

N->replaceVTableHolder(nullptr);

1231

EXPECT_EQ(nullptr, N->getVTableHolder());

1232

1233

auto *TemplateParams = MDTuple::getDistinct(Context, None);

1234

EXPECT_EQ(nullptr, N->getTemplateParams().get());

1235

N->replaceTemplateParams(TemplateParams);

1236

EXPECT_EQ(TemplateParams, N->getTemplateParams().get());

1237

N->replaceTemplateParams(nullptr);

1238

EXPECT_EQ(nullptr, N->getTemplateParams().get());

1239

}

1240

1241

typedef MetadataTest DISubroutineTypeTest;

1242

1243

TEST_F(DISubroutineTypeTest, get) {

1244

unsigned Flags = 1;

1245

MDTuple *TypeArray = getTuple();

1246

1247

auto *N = DISubroutineType::get(Context, Flags, TypeArray);

1248

EXPECT_EQ(dwarf::DW_TAG_subroutine_type, N->getTag());

1249

EXPECT_EQ(Flags, N->getFlags());

1250

EXPECT_EQ(TypeArray, N->getTypeArray().get());

1251

EXPECT_EQ(N, DISubroutineType::get(Context, Flags, TypeArray));

1252

1253

EXPECT_NE(N, DISubroutineType::get(Context, Flags + 1, TypeArray));

1254

EXPECT_NE(N, DISubroutineType::get(Context, Flags, getTuple()));

1255

1256

TempDISubroutineType Temp = N->clone();

1257

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

1258

1259

// Test always-empty operands.

1260

EXPECT_EQ(nullptr, N->getScope());

1261

EXPECT_EQ(nullptr, N->getFile());

1262

EXPECT_EQ("", N->getName());

1263

EXPECT_EQ(nullptr, N->getBaseType());

1264

EXPECT_EQ(nullptr, N->getVTableHolder());

1265

EXPECT_EQ(nullptr, N->getTemplateParams().get());

1266

EXPECT_EQ("", N->getIdentifier());

1267

}

1268

1269

typedef MetadataTest DIFileTest;

1270

1271

TEST_F(DIFileTest, get) {

1272

StringRef Filename = "file";

1273

StringRef Directory = "dir";

1274

auto *N = DIFile::get(Context, Filename, Directory);

1275

1276

EXPECT_EQ(dwarf::DW_TAG_file_type, N->getTag());

1277

EXPECT_EQ(Filename, N->getFilename());

1278

EXPECT_EQ(Directory, N->getDirectory());

1279

EXPECT_EQ(N, DIFile::get(Context, Filename, Directory));

1280

1281

EXPECT_NE(N, DIFile::get(Context, "other", Directory));

1282

EXPECT_NE(N, DIFile::get(Context, Filename, "other"));

1283

1284

TempDIFile Temp = N->clone();

1285

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

1286

}

1287

1288

TEST_F(DIFileTest, ScopeGetFile) {

1289

// Ensure that DIScope::getFile() returns itself.

1290

DIScope *N = DIFile::get(Context, "file", "dir");

1291

EXPECT_EQ(N, N->getFile());

1292

}

1293

1294

typedef MetadataTest DICompileUnitTest;

1295

1296

TEST_F(DICompileUnitTest, get) {

1297

unsigned SourceLanguage = 1;

1298

DIFile *File = getFile();

1299

StringRef Producer = "some producer";

1300

bool IsOptimized = false;

1301

StringRef Flags = "flag after flag";

1302

unsigned RuntimeVersion = 2;

1303

StringRef SplitDebugFilename = "another/file";

1304

unsigned EmissionKind = 3;

1305

MDTuple *EnumTypes = getTuple();

1306

MDTuple *RetainedTypes = getTuple();

1307

MDTuple *Subprograms = getTuple();

1308

MDTuple *GlobalVariables = getTuple();

1309

MDTuple *ImportedEntities = getTuple();

1310

uint64_t DWOId = 0xc0ffee;

1311

auto *N = DICompileUnit::get(

1312

Context, SourceLanguage, File, Producer, IsOptimized, Flags,

1313

RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,

1314

RetainedTypes, Subprograms, GlobalVariables, ImportedEntities, DWOId);

1315

1316

EXPECT_EQ(dwarf::DW_TAG_compile_unit, N->getTag());

1317

EXPECT_EQ(SourceLanguage, N->getSourceLanguage());

1318

EXPECT_EQ(File, N->getFile());

1319

EXPECT_EQ(Producer, N->getProducer());

1320

EXPECT_EQ(IsOptimized, N->isOptimized());

1321

EXPECT_EQ(Flags, N->getFlags());

1322

EXPECT_EQ(RuntimeVersion, N->getRuntimeVersion());

1323

EXPECT_EQ(SplitDebugFilename, N->getSplitDebugFilename());

1324

EXPECT_EQ(EmissionKind, N->getEmissionKind());

1325

EXPECT_EQ(EnumTypes, N->getEnumTypes().get());

1326

EXPECT_EQ(RetainedTypes, N->getRetainedTypes().get());

1327

EXPECT_EQ(Subprograms, N->getSubprograms().get());

1328

EXPECT_EQ(GlobalVariables, N->getGlobalVariables().get());

1329

EXPECT_EQ(ImportedEntities, N->getImportedEntities().get());

1330

EXPECT_EQ(DWOId, N->getDWOId());

1331

EXPECT_EQ(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,

1332

IsOptimized, Flags, RuntimeVersion,

1333

SplitDebugFilename, EmissionKind, EnumTypes,

1334

RetainedTypes, Subprograms, GlobalVariables,

1335

ImportedEntities, DWOId));

1336

1337

EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage + 1, File, Producer,

1338

IsOptimized, Flags, RuntimeVersion,

1339

SplitDebugFilename, EmissionKind, EnumTypes,

1340

RetainedTypes, Subprograms, GlobalVariables,

1341

ImportedEntities, DWOId));

1342

EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, getFile(), Producer,

1343

IsOptimized, Flags, RuntimeVersion,

1344

SplitDebugFilename, EmissionKind, EnumTypes,

1345

RetainedTypes, Subprograms, GlobalVariables,

1346

ImportedEntities, DWOId));

1347

EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, "other",

1348

IsOptimized, Flags, RuntimeVersion,

1349

SplitDebugFilename, EmissionKind, EnumTypes,

1350

RetainedTypes, Subprograms, GlobalVariables,

1351

ImportedEntities, DWOId));

1352

EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,

1353

!IsOptimized, Flags, RuntimeVersion,

1354

SplitDebugFilename, EmissionKind, EnumTypes,

1355

RetainedTypes, Subprograms, GlobalVariables,

1356

ImportedEntities, DWOId));

1357

EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,

1358

IsOptimized, "other", RuntimeVersion,

1359

SplitDebugFilename, EmissionKind, EnumTypes,

1360

RetainedTypes, Subprograms, GlobalVariables,

1361

ImportedEntities, DWOId));

1362

EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,

1363

IsOptimized, Flags, RuntimeVersion + 1,

1364

SplitDebugFilename, EmissionKind, EnumTypes,

1365

RetainedTypes, Subprograms, GlobalVariables,

1366

ImportedEntities, DWOId));

1367

EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,

1368

IsOptimized, Flags, RuntimeVersion, "other",

1369

EmissionKind, EnumTypes, RetainedTypes,

1370

Subprograms, GlobalVariables,

1371

ImportedEntities, DWOId));

1372

EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,

1373

IsOptimized, Flags, RuntimeVersion,

1374

SplitDebugFilename, EmissionKind + 1,

1375

EnumTypes, RetainedTypes, Subprograms,

1376

GlobalVariables, ImportedEntities, DWOId));

1377

EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,

1378

IsOptimized, Flags, RuntimeVersion,

1379

SplitDebugFilename, EmissionKind, getTuple(),

1380

RetainedTypes, Subprograms, GlobalVariables,

1381

ImportedEntities, DWOId));

1382

EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,

1383

IsOptimized, Flags, RuntimeVersion,

1384

SplitDebugFilename, EmissionKind, EnumTypes,

1385

getTuple(), Subprograms, GlobalVariables,

1386

ImportedEntities, DWOId));

1387

EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,

1388

IsOptimized, Flags, RuntimeVersion,

1389

SplitDebugFilename, EmissionKind, EnumTypes,

1390

RetainedTypes, getTuple(), GlobalVariables,

1391

ImportedEntities, DWOId));

1392

EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,

1393

IsOptimized, Flags, RuntimeVersion,

1394

SplitDebugFilename, EmissionKind, EnumTypes,

1395

RetainedTypes, Subprograms, getTuple(),

1396

ImportedEntities, DWOId));

1397

EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,

1398

IsOptimized, Flags, RuntimeVersion,

1399

SplitDebugFilename, EmissionKind, EnumTypes,

1400

RetainedTypes, Subprograms, GlobalVariables,

1401

getTuple(), DWOId));

1402

EXPECT_NE(N, DICompileUnit::get(Context, SourceLanguage, File, Producer,

1403

IsOptimized, Flags, RuntimeVersion,

1404

SplitDebugFilename, EmissionKind, EnumTypes,

1405

RetainedTypes, Subprograms, GlobalVariables,

1406

ImportedEntities, DWOId + 1));

1407

1408

TempDICompileUnit Temp = N->clone();

1409

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

1410

}

1411

1412

TEST_F(DICompileUnitTest, replaceArrays) {

1413

unsigned SourceLanguage = 1;

1414

DIFile *File = getFile();

1415

StringRef Producer = "some producer";

1416

bool IsOptimized = false;

1417

StringRef Flags = "flag after flag";

1418

unsigned RuntimeVersion = 2;

1419

StringRef SplitDebugFilename = "another/file";

1420

unsigned EmissionKind = 3;

1421

MDTuple *EnumTypes = MDTuple::getDistinct(Context, None);

1422

MDTuple *RetainedTypes = MDTuple::getDistinct(Context, None);

1423

MDTuple *ImportedEntities = MDTuple::getDistinct(Context, None);

1424

uint64_t DWOId = 0xc0ffee;

1425

auto *N = DICompileUnit::get(

1426

Context, SourceLanguage, File, Producer, IsOptimized, Flags,

1427

RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,

1428

RetainedTypes, nullptr, nullptr, ImportedEntities, DWOId);

1429

1430

auto *Subprograms = MDTuple::getDistinct(Context, None);

1431

EXPECT_EQ(nullptr, N->getSubprograms().get());

1432

N->replaceSubprograms(Subprograms);

1433

EXPECT_EQ(Subprograms, N->getSubprograms().get());

1434

N->replaceSubprograms(nullptr);

1435

EXPECT_EQ(nullptr, N->getSubprograms().get());

1436

1437

auto *GlobalVariables = MDTuple::getDistinct(Context, None);

1438

EXPECT_EQ(nullptr, N->getGlobalVariables().get());

1439

N->replaceGlobalVariables(GlobalVariables);

1440

EXPECT_EQ(GlobalVariables, N->getGlobalVariables().get());

1441

N->replaceGlobalVariables(nullptr);

1442

EXPECT_EQ(nullptr, N->getGlobalVariables().get());

1443

}

1444

1445

typedef MetadataTest DISubprogramTest;

1446

1447

TEST_F(DISubprogramTest, get) {

1448

DIScopeRef Scope = getCompositeType();

1449

StringRef Name = "name";

1450

StringRef LinkageName = "linkage";

1451

DIFile *File = getFile();

1452

unsigned Line = 2;

1453

DISubroutineType *Type = getSubroutineType();

1454

bool IsLocalToUnit = false;

1455

bool IsDefinition = true;

1456

unsigned ScopeLine = 3;

1457

DITypeRef ContainingType = getCompositeType();

1458

unsigned Virtuality = 4;

1459

unsigned VirtualIndex = 5;

1460

unsigned Flags = 6;

1461

bool IsOptimized = false;

1462

llvm::Function *Function = getFunction("foo");

1463

MDTuple *TemplateParams = getTuple();

1464

DISubprogram *Declaration = getSubprogram();

1465

MDTuple *Variables = getTuple();

1466

1467

auto *N = DISubprogram::get(

1468

Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,

1469

IsDefinition, ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags,

1470

IsOptimized, Function, TemplateParams, Declaration, Variables);

1471

1472

EXPECT_EQ(dwarf::DW_TAG_subprogram, N->getTag());

1473

EXPECT_EQ(Scope, N->getScope());

1474

EXPECT_EQ(Name, N->getName());

1475

EXPECT_EQ(LinkageName, N->getLinkageName());

1476

EXPECT_EQ(File, N->getFile());

1477

EXPECT_EQ(Line, N->getLine());

1478

EXPECT_EQ(Type, N->getType());

1479

EXPECT_EQ(IsLocalToUnit, N->isLocalToUnit());

1480

EXPECT_EQ(IsDefinition, N->isDefinition());

1481

EXPECT_EQ(ScopeLine, N->getScopeLine());

1482

EXPECT_EQ(ContainingType, N->getContainingType());

1483

EXPECT_EQ(Virtuality, N->getVirtuality());

1484

EXPECT_EQ(VirtualIndex, N->getVirtualIndex());

1485

EXPECT_EQ(Flags, N->getFlags());

1486

EXPECT_EQ(IsOptimized, N->isOptimized());

1487

EXPECT_EQ(Function, N->getFunction());

1488

EXPECT_EQ(TemplateParams, N->getTemplateParams().get());

1489

EXPECT_EQ(Declaration, N->getDeclaration());

1490

EXPECT_EQ(Variables, N->getVariables().get());

1491

EXPECT_EQ(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,

1492

Type, IsLocalToUnit, IsDefinition, ScopeLine,

1493

ContainingType, Virtuality, VirtualIndex,

1494

Flags, IsOptimized, Function, TemplateParams,

1495

Declaration, Variables));

1496

1497

EXPECT_NE(N, DISubprogram::get(Context, getCompositeType(), Name, LinkageName,

1498

File, Line, Type, IsLocalToUnit, IsDefinition,

1499

ScopeLine, ContainingType, Virtuality,

1500

VirtualIndex, Flags, IsOptimized, Function,

1501

TemplateParams, Declaration, Variables));

1502

EXPECT_NE(N, DISubprogram::get(Context, Scope, "other", LinkageName, File,

1503

Line, Type, IsLocalToUnit, IsDefinition,

1504

ScopeLine, ContainingType, Virtuality,

1505

VirtualIndex, Flags, IsOptimized, Function,

1506

TemplateParams, Declaration, Variables));

1507

EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, "other", File, Line,

1508

Type, IsLocalToUnit, IsDefinition, ScopeLine,

1509

ContainingType, Virtuality, VirtualIndex,

1510

Flags, IsOptimized, Function, TemplateParams,

1511

Declaration, Variables));

1512

EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, getFile(),

1513

Line, Type, IsLocalToUnit, IsDefinition,

1514

ScopeLine, ContainingType, Virtuality,

1515

VirtualIndex, Flags, IsOptimized, Function,

1516

TemplateParams, Declaration, Variables));

1517

EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File,

1518

Line + 1, Type, IsLocalToUnit, IsDefinition,

1519

ScopeLine, ContainingType, Virtuality,

1520

VirtualIndex, Flags, IsOptimized, Function,

1521

TemplateParams, Declaration, Variables));

1522

EXPECT_NE(N, DISubprogram::get(

1523

Context, Scope, Name, LinkageName, File, Line,

1524

getSubroutineType(), IsLocalToUnit, IsDefinition, ScopeLine,

1525

ContainingType, Virtuality, VirtualIndex, Flags, IsOptimized,

1526

Function, TemplateParams, Declaration, Variables));

1527

EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,

1528

Type, !IsLocalToUnit, IsDefinition, ScopeLine,

1529

ContainingType, Virtuality, VirtualIndex,

1530

Flags, IsOptimized, Function, TemplateParams,

1531

Declaration, Variables));

1532

EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,

1533

Type, IsLocalToUnit, !IsDefinition, ScopeLine,

1534

ContainingType, Virtuality, VirtualIndex,

1535

Flags, IsOptimized, Function, TemplateParams,

1536

Declaration, Variables));

1537

EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,

1538

Type, IsLocalToUnit, IsDefinition,

1539

ScopeLine + 1, ContainingType, Virtuality,

1540

VirtualIndex, Flags, IsOptimized, Function,

1541

TemplateParams, Declaration, Variables));

1542

EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,

1543

Type, IsLocalToUnit, IsDefinition, ScopeLine,

1544

getCompositeType(), Virtuality, VirtualIndex,

1545

Flags, IsOptimized, Function, TemplateParams,

1546

Declaration, Variables));

1547

EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,

1548

Type, IsLocalToUnit, IsDefinition, ScopeLine,

1549

ContainingType, Virtuality + 1, VirtualIndex,

1550

Flags, IsOptimized, Function, TemplateParams,

1551

Declaration, Variables));

1552

EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,

1553

Type, IsLocalToUnit, IsDefinition, ScopeLine,

1554

ContainingType, Virtuality, VirtualIndex + 1,

1555

Flags, IsOptimized, Function, TemplateParams,

1556

Declaration, Variables));

1557

EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,

1558

Type, IsLocalToUnit, IsDefinition, ScopeLine,

1559

ContainingType, Virtuality, VirtualIndex,

1560

~Flags, IsOptimized, Function, TemplateParams,

1561

Declaration, Variables));

1562

EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,

1563

Type, IsLocalToUnit, IsDefinition, ScopeLine,

1564

ContainingType, Virtuality, VirtualIndex,

1565

Flags, !IsOptimized, Function, TemplateParams,

1566

Declaration, Variables));

1567

EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,

1568

Type, IsLocalToUnit, IsDefinition, ScopeLine,

1569

ContainingType, Virtuality, VirtualIndex,

1570

Flags, IsOptimized, getFunction("bar"),

1571

TemplateParams, Declaration, Variables));

1572

EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,

1573

Type, IsLocalToUnit, IsDefinition, ScopeLine,

1574

ContainingType, Virtuality, VirtualIndex,

1575

Flags, IsOptimized, Function, getTuple(),

1576

Declaration, Variables));

1577

EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,

1578

Type, IsLocalToUnit, IsDefinition, ScopeLine,

1579

ContainingType, Virtuality, VirtualIndex,

1580

Flags, IsOptimized, Function, TemplateParams,

1581

getSubprogram(), Variables));

1582

EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,

1583

Type, IsLocalToUnit, IsDefinition, ScopeLine,

1584

ContainingType, Virtuality, VirtualIndex,

1585

Flags, IsOptimized, Function, TemplateParams,

1586

Declaration, getTuple()));

1587

1588

TempDISubprogram Temp = N->clone();

1589

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

1590

}

1591

1592

TEST_F(DISubprogramTest, replaceFunction) {

1593

DIScopeRef Scope = getCompositeType();

1594

StringRef Name = "name";

1595

StringRef LinkageName = "linkage";

1596

DIFile *File = getFile();

1597

unsigned Line = 2;

1598

DISubroutineType *Type = getSubroutineType();

1599

bool IsLocalToUnit = false;

1600

bool IsDefinition = true;

1601

unsigned ScopeLine = 3;

1602

DITypeRef ContainingType = getCompositeType();

1603

unsigned Virtuality = 4;

1604

unsigned VirtualIndex = 5;

1605

unsigned Flags = 6;

1606

bool IsOptimized = false;

1607

MDTuple *TemplateParams = getTuple();

1608

DISubprogram *Declaration = getSubprogram();

1609

MDTuple *Variables = getTuple();

1610

1611

auto *N = DISubprogram::get(

1612

Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,

1613

IsDefinition, ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags,

1614

IsOptimized, nullptr, TemplateParams, Declaration, Variables);

1615

1616

EXPECT_EQ(nullptr, N->getFunction());

1617

1618

std::unique_ptr<Function> F(

1619

Function::Create(FunctionType::get(Type::getVoidTy(Context), false),

1620

GlobalValue::ExternalLinkage));

1621

N->replaceFunction(F.get());

1622

EXPECT_EQ(F.get(), N->getFunction());

1623

1624

N->replaceFunction(nullptr);

1625

EXPECT_EQ(nullptr, N->getFunction());

1626

}

1627

1628

typedef MetadataTest DILexicalBlockTest;

1629

1630

TEST_F(DILexicalBlockTest, get) {

1631

DILocalScope *Scope = getSubprogram();

1632

DIFile *File = getFile();

1633

unsigned Line = 5;

1634

unsigned Column = 8;

1635

1636

auto *N = DILexicalBlock::get(Context, Scope, File, Line, Column);

1637

1638

EXPECT_EQ(dwarf::DW_TAG_lexical_block, N->getTag());

1639

EXPECT_EQ(Scope, N->getScope());

1640

EXPECT_EQ(File, N->getFile());

1641

EXPECT_EQ(Line, N->getLine());

1642

EXPECT_EQ(Column, N->getColumn());

1643

EXPECT_EQ(N, DILexicalBlock::get(Context, Scope, File, Line, Column));

1644

1645

EXPECT_NE(N,

1646

DILexicalBlock::get(Context, getSubprogram(), File, Line, Column));

1647

EXPECT_NE(N, DILexicalBlock::get(Context, Scope, getFile(), Line, Column));

1648

EXPECT_NE(N, DILexicalBlock::get(Context, Scope, File, Line + 1, Column));

1649

EXPECT_NE(N, DILexicalBlock::get(Context, Scope, File, Line, Column + 1));

1650

1651

TempDILexicalBlock Temp = N->clone();

1652

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

1653

}

1654

1655

typedef MetadataTest DILexicalBlockFileTest;

1656

1657

TEST_F(DILexicalBlockFileTest, get) {

1658

DILocalScope *Scope = getSubprogram();

1659

DIFile *File = getFile();

1660

unsigned Discriminator = 5;

1661

1662

auto *N = DILexicalBlockFile::get(Context, Scope, File, Discriminator);

1663

1664

EXPECT_EQ(dwarf::DW_TAG_lexical_block, N->getTag());

1665

EXPECT_EQ(Scope, N->getScope());

1666

EXPECT_EQ(File, N->getFile());

1667

EXPECT_EQ(Discriminator, N->getDiscriminator());

1668

EXPECT_EQ(N, DILexicalBlockFile::get(Context, Scope, File, Discriminator));

1669

1670

EXPECT_NE(N, DILexicalBlockFile::get(Context, getSubprogram(), File,

1671

Discriminator));

1672

EXPECT_NE(N,

1673

DILexicalBlockFile::get(Context, Scope, getFile(), Discriminator));

1674

EXPECT_NE(N,

1675

DILexicalBlockFile::get(Context, Scope, File, Discriminator + 1));

1676

1677

TempDILexicalBlockFile Temp = N->clone();

1678

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

1679

}

1680

1681

typedef MetadataTest DINamespaceTest;

1682

1683

TEST_F(DINamespaceTest, get) {

1684

DIScope *Scope = getFile();

1685

DIFile *File = getFile();

1686

StringRef Name = "namespace";

1687

unsigned Line = 5;

1688

1689

auto *N = DINamespace::get(Context, Scope, File, Name, Line);

1690

1691

EXPECT_EQ(dwarf::DW_TAG_namespace, N->getTag());

1692

EXPECT_EQ(Scope, N->getScope());

1693

EXPECT_EQ(File, N->getFile());

1694

EXPECT_EQ(Name, N->getName());

1695

EXPECT_EQ(Line, N->getLine());

1696

EXPECT_EQ(N, DINamespace::get(Context, Scope, File, Name, Line));

1697

1698

EXPECT_NE(N, DINamespace::get(Context, getFile(), File, Name, Line));

1699

EXPECT_NE(N, DINamespace::get(Context, Scope, getFile(), Name, Line));

1700

EXPECT_NE(N, DINamespace::get(Context, Scope, File, "other", Line));

1701

EXPECT_NE(N, DINamespace::get(Context, Scope, File, Name, Line + 1));

1702

1703

TempDINamespace Temp = N->clone();

1704

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

1705

}

1706

1707

typedef MetadataTest DIModuleTest;

1708

1709

TEST_F(DIModuleTest, get) {

1710

DIScope *Scope = getFile();

1711

StringRef Name = "module";

1712

StringRef ConfigMacro = "-DNDEBUG";

1713

StringRef Includes = "-I.";

1714

StringRef Sysroot = "/";

1715

1716

auto *N = DIModule::get(Context, Scope, Name, ConfigMacro, Includes, Sysroot);

1717

1718

EXPECT_EQ(dwarf::DW_TAG_module, N->getTag());

1719

EXPECT_EQ(Scope, N->getScope());

1720

EXPECT_EQ(Name, N->getName());

1721

EXPECT_EQ(ConfigMacro, N->getConfigurationMacros());

1722

EXPECT_EQ(Includes, N->getIncludePath());

1723

EXPECT_EQ(Sysroot, N->getISysRoot());

1724

EXPECT_EQ(N, DIModule::get(Context, Scope, Name,

1725

ConfigMacro, Includes, Sysroot));

1726

EXPECT_NE(N, DIModule::get(Context, getFile(), Name,

1727

ConfigMacro, Includes, Sysroot));

1728

EXPECT_NE(N, DIModule::get(Context, Scope, "other",

1729

ConfigMacro, Includes, Sysroot));

1730

EXPECT_NE(N, DIModule::get(Context, Scope, Name,

1731

"other", Includes, Sysroot));

1732

EXPECT_NE(N, DIModule::get(Context, Scope, Name,

1733

ConfigMacro, "other", Sysroot));

1734

EXPECT_NE(N, DIModule::get(Context, Scope, Name,

1735

ConfigMacro, Includes, "other"));

1736

1737

TempDIModule Temp = N->clone();

1738

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

1739

}

1740

1741

typedef MetadataTest DITemplateTypeParameterTest;

1742

1743

TEST_F(DITemplateTypeParameterTest, get) {

1744

StringRef Name = "template";

1745

DITypeRef Type = getBasicType("basic");

1746

1747

auto *N = DITemplateTypeParameter::get(Context, Name, Type);

1748

1749

EXPECT_EQ(dwarf::DW_TAG_template_type_parameter, N->getTag());

1750

EXPECT_EQ(Name, N->getName());

1751

EXPECT_EQ(Type, N->getType());

1752

EXPECT_EQ(N, DITemplateTypeParameter::get(Context, Name, Type));

1753

1754

EXPECT_NE(N, DITemplateTypeParameter::get(Context, "other", Type));

1755

EXPECT_NE(N,

1756

DITemplateTypeParameter::get(Context, Name, getBasicType("other")));

1757

1758

TempDITemplateTypeParameter Temp = N->clone();

1759

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

1760

}

1761

1762

typedef MetadataTest DITemplateValueParameterTest;

1763

1764

TEST_F(DITemplateValueParameterTest, get) {

1765

unsigned Tag = dwarf::DW_TAG_template_value_parameter;

1766

StringRef Name = "template";

1767

DITypeRef Type = getBasicType("basic");

1768

Metadata *Value = getConstantAsMetadata();

1769

1770

auto *N = DITemplateValueParameter::get(Context, Tag, Name, Type, Value);

1771

EXPECT_EQ(Tag, N->getTag());

1772

EXPECT_EQ(Name, N->getName());

1773

EXPECT_EQ(Type, N->getType());

1774

EXPECT_EQ(Value, N->getValue());

1775

EXPECT_EQ(N, DITemplateValueParameter::get(Context, Tag, Name, Type, Value));

1776

1777

EXPECT_NE(N, DITemplateValueParameter::get(

1778

Context, dwarf::DW_TAG_GNU_template_template_param, Name,

1779

Type, Value));

1780

EXPECT_NE(N,

1781

DITemplateValueParameter::get(Context, Tag, "other", Type, Value));

1782

EXPECT_NE(N, DITemplateValueParameter::get(Context, Tag, Name,

1783

getBasicType("other"), Value));

1784

EXPECT_NE(N, DITemplateValueParameter::get(Context, Tag, Name, Type,

1785

getConstantAsMetadata()));

1786

1787

TempDITemplateValueParameter Temp = N->clone();

1788

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

1789

}

1790

1791

typedef MetadataTest DIGlobalVariableTest;

1792

1793

TEST_F(DIGlobalVariableTest, get) {

1794

DIScope *Scope = getSubprogram();

1795

StringRef Name = "name";

1796

StringRef LinkageName = "linkage";

1797

DIFile *File = getFile();

1798

unsigned Line = 5;

1799

DITypeRef Type = getDerivedType();

1800

bool IsLocalToUnit = false;

1801

bool IsDefinition = true;

1802

Constant *Variable = getConstant();

1803

DIDerivedType *StaticDataMemberDeclaration =

1804

cast<DIDerivedType>(getDerivedType());

1805

1806

auto *N = DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line,

1807

Type, IsLocalToUnit, IsDefinition, Variable,

1808

StaticDataMemberDeclaration);

1809

EXPECT_EQ(dwarf::DW_TAG_variable, N->getTag());

1810

EXPECT_EQ(Scope, N->getScope());

1811

EXPECT_EQ(Name, N->getName());

1812

EXPECT_EQ(LinkageName, N->getLinkageName());

1813

EXPECT_EQ(File, N->getFile());

1814

EXPECT_EQ(Line, N->getLine());

1815

EXPECT_EQ(Type, N->getType());

1816

EXPECT_EQ(IsLocalToUnit, N->isLocalToUnit());

1817

EXPECT_EQ(IsDefinition, N->isDefinition());

1818

EXPECT_EQ(Variable, N->getVariable());

1819

EXPECT_EQ(StaticDataMemberDeclaration, N->getStaticDataMemberDeclaration());

1820

EXPECT_EQ(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,

1821

Line, Type, IsLocalToUnit, IsDefinition,

1822

Variable, StaticDataMemberDeclaration));

1823

1824

EXPECT_NE(N,

1825

DIGlobalVariable::get(Context, getSubprogram(), Name, LinkageName,

1826

File, Line, Type, IsLocalToUnit, IsDefinition,

1827

Variable, StaticDataMemberDeclaration));

1828

EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, "other", LinkageName, File,

1829

Line, Type, IsLocalToUnit, IsDefinition,

1830

Variable, StaticDataMemberDeclaration));

1831

EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, "other", File, Line,

1832

Type, IsLocalToUnit, IsDefinition,

1833

Variable, StaticDataMemberDeclaration));

1834

EXPECT_NE(N,

1835

DIGlobalVariable::get(Context, Scope, Name, LinkageName, getFile(),

1836

Line, Type, IsLocalToUnit, IsDefinition,

1837

Variable, StaticDataMemberDeclaration));

1838

EXPECT_NE(N,

1839

DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,

1840

Line + 1, Type, IsLocalToUnit, IsDefinition,

1841

Variable, StaticDataMemberDeclaration));

1842

EXPECT_NE(N,

1843

DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line,

1844

getDerivedType(), IsLocalToUnit, IsDefinition,

1845

Variable, StaticDataMemberDeclaration));

1846

EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,

1847

Line, Type, !IsLocalToUnit, IsDefinition,

1848

Variable, StaticDataMemberDeclaration));

1849

EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,

1850

Line, Type, IsLocalToUnit, !IsDefinition,

1851

Variable, StaticDataMemberDeclaration));

1852

EXPECT_NE(N,

1853

DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line,

1854

Type, IsLocalToUnit, IsDefinition,

1855

getConstant(), StaticDataMemberDeclaration));

1856

EXPECT_NE(N,

1857

DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line,

1858

Type, IsLocalToUnit, IsDefinition, Variable,

1859

cast<DIDerivedType>(getDerivedType())));

1860

1861

TempDIGlobalVariable Temp = N->clone();

1862

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

1863

}

1864

1865

typedef MetadataTest DILocalVariableTest;

1866

1867

TEST_F(DILocalVariableTest, get) {

1868

unsigned Tag = dwarf::DW_TAG_arg_variable;

1869

DILocalScope *Scope = getSubprogram();

1870

StringRef Name = "name";

1871

DIFile *File = getFile();

1872

unsigned Line = 5;

1873

DITypeRef Type = getDerivedType();

1874

unsigned Arg = 6;

1875

unsigned Flags = 7;

1876

1877

auto *N = DILocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,

1878

Arg, Flags);

1879

EXPECT_EQ(Tag, N->getTag());

1880

EXPECT_EQ(Scope, N->getScope());

1881

EXPECT_EQ(Name, N->getName());

1882

EXPECT_EQ(File, N->getFile());

1883

EXPECT_EQ(Line, N->getLine());

1884

EXPECT_EQ(Type, N->getType());

1885

EXPECT_EQ(Arg, N->getArg());

1886

EXPECT_EQ(Flags, N->getFlags());

1887

EXPECT_EQ(N, DILocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,

1888

Arg, Flags));

1889

1890

EXPECT_NE(N, DILocalVariable::get(Context, dwarf::DW_TAG_auto_variable, Scope,

1891

Name, File, Line, Type, Arg, Flags));

1892

EXPECT_NE(N, DILocalVariable::get(Context, Tag, getSubprogram(), Name, File,

1893

Line, Type, Arg, Flags));

1894

EXPECT_NE(N, DILocalVariable::get(Context, Tag, Scope, "other", File, Line,

1895

Type, Arg, Flags));

1896

EXPECT_NE(N, DILocalVariable::get(Context, Tag, Scope, Name, getFile(), Line,

1897

Type, Arg, Flags));

1898

EXPECT_NE(N, DILocalVariable::get(Context, Tag, Scope, Name, File, Line + 1,

1899

Type, Arg, Flags));

1900

EXPECT_NE(N, DILocalVariable::get(Context, Tag, Scope, Name, File, Line,

1901

getDerivedType(), Arg, Flags));

1902

EXPECT_NE(N, DILocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,

1903

Arg + 1, Flags));

1904

EXPECT_NE(N, DILocalVariable::get(Context, Tag, Scope, Name, File, Line, Type,

1905

Arg, ~Flags));

1906

1907

TempDILocalVariable Temp = N->clone();

1908

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

1909

}

1910

1911

TEST_F(DILocalVariableTest, getArg256) {

1912

EXPECT_EQ(255u, DILocalVariable::get(Context, dwarf::DW_TAG_arg_variable,

1913

getSubprogram(), "", getFile(), 0,

1914

nullptr, 255, 0)

1915

->getArg());

1916

EXPECT_EQ(256u, DILocalVariable::get(Context, dwarf::DW_TAG_arg_variable,

1917

getSubprogram(), "", getFile(), 0,

1918

nullptr, 256, 0)

1919

->getArg());

1920

EXPECT_EQ(257u, DILocalVariable::get(Context, dwarf::DW_TAG_arg_variable,

1921

getSubprogram(), "", getFile(), 0,

1922

nullptr, 257, 0)

1923

->getArg());

1924

unsigned Max = UINT16_MAX;

1925

EXPECT_EQ(Max, DILocalVariable::get(Context, dwarf::DW_TAG_arg_variable,

1926

getSubprogram(), "", getFile(), 0,

1927

nullptr, Max, 0)

1928

->getArg());

1929

}

1930

1931

typedef MetadataTest DIExpressionTest;

1932

1933

TEST_F(DIExpressionTest, get) {

1934

uint64_t Elements[] = {2, 6, 9, 78, 0};

1935

auto *N = DIExpression::get(Context, Elements);

1936

EXPECT_EQ(makeArrayRef(Elements), N->getElements());

1937

EXPECT_EQ(N, DIExpression::get(Context, Elements));

1938

1939

EXPECT_EQ(5u, N->getNumElements());

1940

EXPECT_EQ(2u, N->getElement(0));

1941

EXPECT_EQ(6u, N->getElement(1));

1942

EXPECT_EQ(9u, N->getElement(2));

1943

EXPECT_EQ(78u, N->getElement(3));

1944

EXPECT_EQ(0u, N->getElement(4));

1945

1946

TempDIExpression Temp = N->clone();

1947

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

1948

}

1949

1950

TEST_F(DIExpressionTest, isValid) {

1951

#define EXPECT_VALID(...) \

1952

do { \

1953

uint64_t Elements[] = {__VA_ARGS__}; \

1954

EXPECT_TRUE(DIExpression::get(Context, Elements)->isValid()); \

1955

} while (false)

1956

#define EXPECT_INVALID(...) \

1957

do { \

1958

uint64_t Elements[] = {__VA_ARGS__}; \

1959

EXPECT_FALSE(DIExpression::get(Context, Elements)->isValid()); \

1960

} while (false)

1961

1962

// Empty expression should be valid.

1963

EXPECT_TRUE(DIExpression::get(Context, None));

1964

1965

// Valid constructions.

1966

EXPECT_VALID(dwarf::DW_OP_plus, 6);

1967

EXPECT_VALID(dwarf::DW_OP_deref);

1968

EXPECT_VALID(dwarf::DW_OP_bit_piece, 3, 7);

1969

EXPECT_VALID(dwarf::DW_OP_plus, 6, dwarf::DW_OP_deref);

1970

EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_plus, 6);

1971

EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_bit_piece, 3, 7);

1972

EXPECT_VALID(dwarf::DW_OP_deref, dwarf::DW_OP_plus, 6, dwarf::DW_OP_bit_piece, 3, 7);

1973

1974

// Invalid constructions.

1975

EXPECT_INVALID(~0u);

1976

EXPECT_INVALID(dwarf::DW_OP_plus);

1977

EXPECT_INVALID(dwarf::DW_OP_bit_piece);

1978

EXPECT_INVALID(dwarf::DW_OP_bit_piece, 3);

1979

EXPECT_INVALID(dwarf::DW_OP_bit_piece, 3, 7, dwarf::DW_OP_plus, 3);

1980

EXPECT_INVALID(dwarf::DW_OP_bit_piece, 3, 7, dwarf::DW_OP_deref);

1981

1982

#undef EXPECT_VALID

1983

#undef EXPECT_INVALID

1984

}

1985

1986

typedef MetadataTest DIObjCPropertyTest;

1987

1988

TEST_F(DIObjCPropertyTest, get) {

1989

StringRef Name = "name";

1990

DIFile *File = getFile();

1991

unsigned Line = 5;

1992

StringRef GetterName = "getter";

1993

StringRef SetterName = "setter";

1994

unsigned Attributes = 7;

1995

DITypeRef Type = getBasicType("basic");

1996

1997

auto *N = DIObjCProperty::get(Context, Name, File, Line, GetterName,

1998

SetterName, Attributes, Type);

1999

2000

EXPECT_EQ(dwarf::DW_TAG_APPLE_property, N->getTag());

2001

EXPECT_EQ(Name, N->getName());

2002

EXPECT_EQ(File, N->getFile());

2003

EXPECT_EQ(Line, N->getLine());

2004

EXPECT_EQ(GetterName, N->getGetterName());

2005

EXPECT_EQ(SetterName, N->getSetterName());

2006

EXPECT_EQ(Attributes, N->getAttributes());

2007

EXPECT_EQ(Type, N->getType());

2008

EXPECT_EQ(N, DIObjCProperty::get(Context, Name, File, Line, GetterName,

2009

SetterName, Attributes, Type));

2010

2011

EXPECT_NE(N, DIObjCProperty::get(Context, "other", File, Line, GetterName,

2012

SetterName, Attributes, Type));

2013

EXPECT_NE(N, DIObjCProperty::get(Context, Name, getFile(), Line, GetterName,

2014

SetterName, Attributes, Type));

2015

EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line + 1, GetterName,

2016

SetterName, Attributes, Type));

2017

EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line, "other",

2018

SetterName, Attributes, Type));

2019

EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line, GetterName,

2020

"other", Attributes, Type));

2021

EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line, GetterName,

2022

SetterName, Attributes + 1, Type));

2023

EXPECT_NE(N, DIObjCProperty::get(Context, Name, File, Line, GetterName,

2024

SetterName, Attributes,

2025

getBasicType("other")));

2026

2027

TempDIObjCProperty Temp = N->clone();

2028

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

2029

}

2030

2031

typedef MetadataTest DIImportedEntityTest;

2032

2033

TEST_F(DIImportedEntityTest, get) {

2034

unsigned Tag = dwarf::DW_TAG_imported_module;

2035

DIScope *Scope = getSubprogram();

2036

DINodeRef Entity = getCompositeType();

2037

unsigned Line = 5;

2038

StringRef Name = "name";

2039

2040

auto *N = DIImportedEntity::get(Context, Tag, Scope, Entity, Line, Name);

2041

2042

EXPECT_EQ(Tag, N->getTag());

2043

EXPECT_EQ(Scope, N->getScope());

2044

EXPECT_EQ(Entity, N->getEntity());

2045

EXPECT_EQ(Line, N->getLine());

2046

EXPECT_EQ(Name, N->getName());

2047

EXPECT_EQ(N, DIImportedEntity::get(Context, Tag, Scope, Entity, Line, Name));

2048

2049

EXPECT_NE(N,

2050

DIImportedEntity::get(Context, dwarf::DW_TAG_imported_declaration,

2051

Scope, Entity, Line, Name));

2052

EXPECT_NE(N, DIImportedEntity::get(Context, Tag, getSubprogram(), Entity,

2053

Line, Name));

2054

EXPECT_NE(N, DIImportedEntity::get(Context, Tag, Scope, getCompositeType(),

2055

Line, Name));

2056

EXPECT_NE(N,

2057

DIImportedEntity::get(Context, Tag, Scope, Entity, Line + 1, Name));

2058

EXPECT_NE(N,

2059

DIImportedEntity::get(Context, Tag, Scope, Entity, Line, "other"));

2060

2061

TempDIImportedEntity Temp = N->clone();

2062

EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));

2063

}

2064

2065

typedef MetadataTest MetadataAsValueTest;

2066

2067

TEST_F(MetadataAsValueTest, MDNode) {

2068

MDNode *N = MDNode::get(Context, None);

2069

auto *V = MetadataAsValue::get(Context, N);

2070

EXPECT_TRUE(V->getType()->isMetadataTy());

2071

EXPECT_EQ(N, V->getMetadata());

2072

2073

auto *V2 = MetadataAsValue::get(Context, N);

2074

EXPECT_EQ(V, V2);

2075

}

2076

2077

TEST_F(MetadataAsValueTest, MDNodeMDNode) {

2078

MDNode *N = MDNode::get(Context, None);

2079

Metadata *Ops[] = {N};

2080

MDNode *N2 = MDNode::get(Context, Ops);

2081

auto *V = MetadataAsValue::get(Context, N2);

2082

EXPECT_TRUE(V->getType()->isMetadataTy());

2083

EXPECT_EQ(N2, V->getMetadata());

2084

2085

auto *V2 = MetadataAsValue::get(Context, N2);

2086

EXPECT_EQ(V, V2);

2087

2088

auto *V3 = MetadataAsValue::get(Context, N);

2089

EXPECT_TRUE(V3->getType()->isMetadataTy());

2090

EXPECT_NE(V, V3);

2091

EXPECT_EQ(N, V3->getMetadata());

2092

}

2093

2094

TEST_F(MetadataAsValueTest, MDNodeConstant) {

2095

auto *C = ConstantInt::getTrue(Context);

2096

auto *MD = ConstantAsMetadata::get(C);

2097

Metadata *Ops[] = {MD};

2098

auto *N = MDNode::get(Context, Ops);

2099

2100

auto *V = MetadataAsValue::get(Context, MD);

2101

EXPECT_TRUE(V->getType()->isMetadataTy());

2102

EXPECT_EQ(MD, V->getMetadata());

2103

2104

auto *V2 = MetadataAsValue::get(Context, N);

2105

EXPECT_EQ(MD, V2->getMetadata());

2106

EXPECT_EQ(V, V2);

2107

}

2108

2109

typedef MetadataTest ValueAsMetadataTest;

2110

2111

TEST_F(ValueAsMetadataTest, UpdatesOnRAUW) {

2112

Type *Ty = Type::getInt1PtrTy(Context);

2113

std::unique_ptr<GlobalVariable> GV0(

2114

new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));

2115

auto *MD = ValueAsMetadata::get(GV0.get());

2116

EXPECT_TRUE(MD->getValue() == GV0.get());

2117

ASSERT_TRUE(GV0->use_empty());

2118

2119

std::unique_ptr<GlobalVariable> GV1(

2120

new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));

2121

GV0->replaceAllUsesWith(GV1.get());

2122

EXPECT_TRUE(MD->getValue() == GV1.get());

2123

}

2124

2125

TEST_F(ValueAsMetadataTest, CollidingDoubleUpdates) {

2126

// Create a constant.

2127

ConstantAsMetadata *CI = ConstantAsMetadata::get(

2128

ConstantInt::get(getGlobalContext(), APInt(8, 0)));

2129

2130

// Create a temporary to prevent nodes from resolving.

2131

auto Temp = MDTuple::getTemporary(Context, None);

2132

2133

// When the first operand of N1 gets reset to nullptr, it'll collide with N2.

2134

Metadata *Ops1[] = {CI, CI, Temp.get()};

2135

Metadata *Ops2[] = {nullptr, CI, Temp.get()};

2136

2137

auto *N1 = MDTuple::get(Context, Ops1);

2138

auto *N2 = MDTuple::get(Context, Ops2);

2139

ASSERT_NE(N1, N2);

2140

2141

// Tell metadata that the constant is getting deleted.

2142

//

2143

// After this, N1 will be invalid, so don't touch it.

2144

ValueAsMetadata::handleDeletion(CI->getValue());

2145

EXPECT_EQ(nullptr, N2->getOperand(0));

2146

EXPECT_EQ(nullptr, N2->getOperand(1));

2147

EXPECT_EQ(Temp.get(), N2->getOperand(2));

2148

2149

// Clean up Temp for teardown.

2150

Temp->replaceAllUsesWith(nullptr);

2151

}

2152

2153

typedef MetadataTest TrackingMDRefTest;

2154

2155

TEST_F(TrackingMDRefTest, UpdatesOnRAUW) {

2156

Type *Ty = Type::getInt1PtrTy(Context);

2157

std::unique_ptr<GlobalVariable> GV0(

2158

new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));

2159

TypedTrackingMDRef<ValueAsMetadata> MD(ValueAsMetadata::get(GV0.get()));

2160

EXPECT_TRUE(MD->getValue() == GV0.get());

2161

ASSERT_TRUE(GV0->use_empty());

2162

2163

std::unique_ptr<GlobalVariable> GV1(

2164

new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));

2165

GV0->replaceAllUsesWith(GV1.get());

2166

EXPECT_TRUE(MD->getValue() == GV1.get());

2167

2168

// Reset it, so we don't inadvertently test deletion.

2169

MD.reset();

2170

}

2171

2172

TEST_F(TrackingMDRefTest, UpdatesOnDeletion) {

2173

Type *Ty = Type::getInt1PtrTy(Context);

2174

std::unique_ptr<GlobalVariable> GV(

2175

new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));

2176

TypedTrackingMDRef<ValueAsMetadata> MD(ValueAsMetadata::get(GV.get()));

2177

EXPECT_TRUE(MD->getValue() == GV.get());

2178

ASSERT_TRUE(GV->use_empty());

2179

2180

GV.reset();

2181

EXPECT_TRUE(!MD);

2182

}

2183

2184

TEST(NamedMDNodeTest, Search) {

2185

LLVMContext Context;

2186

ConstantAsMetadata *C =

2187

ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 1));

2188

ConstantAsMetadata *C2 =

2189

ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 2));

2190

2191

Metadata *const V = C;

2192

Metadata *const V2 = C2;

2193

MDNode *n = MDNode::get(Context, V);

2194

MDNode *n2 = MDNode::get(Context, V2);

2195

2196

Module M("MyModule", Context);

2197

const char *Name = "llvm.NMD1";

2198

NamedMDNode *NMD = M.getOrInsertNamedMetadata(Name);

2199

NMD->addOperand(n);

2200

NMD->addOperand(n2);

2201

2202

std::string Str;

2203

raw_string_ostream oss(Str);

2204

NMD->print(oss);

2205

EXPECT_STREQ("!llvm.NMD1 = !{!0, !1}\n",

2206

oss.str().c_str());

2207

}

2208

2209

typedef MetadataTest FunctionAttachmentTest;

2210

TEST_F(FunctionAttachmentTest, setMetadata) {

2211

Function *F = getFunction("foo");

2212

ASSERT_FALSE(F->hasMetadata());

2213

EXPECT_EQ(nullptr, F->getMetadata(LLVMContext::MD_dbg));

2214

EXPECT_EQ(nullptr, F->getMetadata("dbg"));

2215

EXPECT_EQ(nullptr, F->getMetadata("other"));

2216

2217

DISubprogram *SP1 = getSubprogram();

2218

DISubprogram *SP2 = getSubprogram();

2219

ASSERT_NE(SP1, SP2);

2220

2221

F->setMetadata("dbg", SP1);

2222

EXPECT_TRUE(F->hasMetadata());

2223

EXPECT_EQ(SP1, F->getMetadata(LLVMContext::MD_dbg));

2224

EXPECT_EQ(SP1, F->getMetadata("dbg"));

2225

EXPECT_EQ(nullptr, F->getMetadata("other"));

2226

2227

F->setMetadata(LLVMContext::MD_dbg, SP2);

2228

EXPECT_TRUE(F->hasMetadata());

2229

EXPECT_EQ(SP2, F->getMetadata(LLVMContext::MD_dbg));

2230

EXPECT_EQ(SP2, F->getMetadata("dbg"));

2231

EXPECT_EQ(nullptr, F->getMetadata("other"));

2232

2233

F->setMetadata("dbg", nullptr);

2234

EXPECT_FALSE(F->hasMetadata());

2235

EXPECT_EQ(nullptr, F->getMetadata(LLVMContext::MD_dbg));

2236

EXPECT_EQ(nullptr, F->getMetadata("dbg"));

2237

EXPECT_EQ(nullptr, F->getMetadata("other"));

2238

2239

MDTuple *T1 = getTuple();

2240

MDTuple *T2 = getTuple();

2241

ASSERT_NE(T1, T2);

2242

2243

F->setMetadata("other1", T1);

2244

F->setMetadata("other2", T2);

2245

EXPECT_TRUE(F->hasMetadata());

2246

EXPECT_EQ(T1, F->getMetadata("other1"));

2247

EXPECT_EQ(T2, F->getMetadata("other2"));

2248

EXPECT_EQ(nullptr, F->getMetadata("dbg"));

2249

2250

F->setMetadata("other1", T2);

2251

F->setMetadata("other2", T1);

2252

EXPECT_EQ(T2, F->getMetadata("other1"));

2253

EXPECT_EQ(T1, F->getMetadata("other2"));

2254

2255

F->setMetadata("other1", nullptr);

2256

F->setMetadata("other2", nullptr);

2257

EXPECT_FALSE(F->hasMetadata());

2258

EXPECT_EQ(nullptr, F->getMetadata("other1"));

2259

EXPECT_EQ(nullptr, F->getMetadata("other2"));

2260

}

2261

2262

TEST_F(FunctionAttachmentTest, getAll) {

2263

Function *F = getFunction("foo");

2264

2265

MDTuple *T1 = getTuple();

2266

MDTuple *T2 = getTuple();

2267

MDTuple *P = getTuple();

2268

DISubprogram *SP = getSubprogram();

2269

2270

F->setMetadata("other1", T2);

2271

F->setMetadata(LLVMContext::MD_dbg, SP);

2272

F->setMetadata("other2", T1);

2273

F->setMetadata(LLVMContext::MD_prof, P);

2274

F->setMetadata("other2", T2);

2275

F->setMetadata("other1", T1);

2276

2277

SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;

2278

F->getAllMetadata(MDs);

2279

ASSERT_EQ(4u, MDs.size());

2280

EXPECT_EQ(LLVMContext::MD_dbg, MDs[0].first);

2281

EXPECT_EQ(LLVMContext::MD_prof, MDs[1].first);

2282

EXPECT_EQ(Context.getMDKindID("other1"), MDs[2].first);

2283

EXPECT_EQ(Context.getMDKindID("other2"), MDs[3].first);

2284

EXPECT_EQ(SP, MDs[0].second);

2285

EXPECT_EQ(P, MDs[1].second);

2286

EXPECT_EQ(T1, MDs[2].second);

2287

EXPECT_EQ(T2, MDs[3].second);

2288

}

2289

2290

TEST_F(FunctionAttachmentTest, dropUnknownMetadata) {

2291

Function *F = getFunction("foo");

2292

2293

MDTuple *T1 = getTuple();

2294

MDTuple *T2 = getTuple();

2295

MDTuple *P = getTuple();

2296

DISubprogram *SP = getSubprogram();

2297

2298

F->setMetadata("other1", T1);

2299

F->setMetadata(LLVMContext::MD_dbg, SP);

2300

F->setMetadata("other2", T2);

2301

F->setMetadata(LLVMContext::MD_prof, P);

2302

2303

unsigned Known[] = {Context.getMDKindID("other2"), LLVMContext::MD_prof};

2304

F->dropUnknownMetadata(Known);

2305

2306

EXPECT_EQ(T2, F->getMetadata("other2"));

2307

EXPECT_EQ(P, F->getMetadata(LLVMContext::MD_prof));

2308

EXPECT_EQ(nullptr, F->getMetadata("other1"));

2309

EXPECT_EQ(nullptr, F->getMetadata(LLVMContext::MD_dbg));

2310

2311

F->setMetadata("other2", nullptr);

2312

F->setMetadata(LLVMContext::MD_prof, nullptr);

2313

EXPECT_FALSE(F->hasMetadata());

2314

}

2315

2316

TEST_F(FunctionAttachmentTest, Verifier) {

2317

Function *F = getFunction("foo");

2318

F->setMetadata("attach", getTuple());

2319

2320

// Confirm this has no body.

2321

ASSERT_TRUE(F->empty());

2322

2323

// Functions without a body cannot have metadata attachments (they also can't

2324

// be verified directly, so check that the module fails to verify).

2325

EXPECT_TRUE(verifyModule(*F->getParent()));

2326

2327

// Functions with a body can.

2328

(void)new UnreachableInst(Context, BasicBlock::Create(Context, "bb", F));

2329

EXPECT_FALSE(verifyModule(*F->getParent()));

2330

EXPECT_FALSE(verifyFunction(*F));

2331

}

2332

2333

TEST_F(FunctionAttachmentTest, EntryCount) {

2334

Function *F = getFunction("foo");

2335

EXPECT_FALSE(F->getEntryCount().hasValue());

2336

F->setEntryCount(12304);

2337

EXPECT_TRUE(F->getEntryCount().hasValue());

2338

EXPECT_EQ(12304u, *F->getEntryCount());

2339

}

2340

2341

}