/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp

Bug Summary

File:	tools/clang/lib/Serialization/ASTReaderStmt.cpp
Location:	line 1807, column 3
Description:	Function call argument is an uninitialized value

Annotated Source Code

//===--- ASTReaderStmt.cpp - Stmt/Expr Deserialization ----------*- C++ -*-===//

// The LLVM Compiler Infrastructure

// This file is distributed under the University of Illinois Open Source

// License. See LICENSE.TXT for details.

//===----------------------------------------------------------------------===//

// Statement/expression deserialization. This implements the

// ASTReader::ReadStmt method.

//===----------------------------------------------------------------------===//

#include "clang/Serialization/ASTReader.h"

#include "clang/AST/ASTContext.h"

#include "clang/AST/DeclCXX.h"

#include "clang/AST/DeclTemplate.h"

#include "clang/AST/StmtVisitor.h"

#include "clang/Lex/Token.h"

#include "llvm/ADT/SmallString.h"

using namespace clang;

using namespace clang::serialization;

namespace clang {

class ASTStmtReader : public StmtVisitor<ASTStmtReader> {

friend class OMPClauseReader;

typedef ASTReader::RecordData RecordData;

ASTReader &Reader;

ModuleFile &F;

llvm::BitstreamCursor &DeclsCursor;

const ASTReader::RecordData &Record;

unsigned &Idx;

Token ReadToken(const RecordData &R, unsigned &I) {

return Reader.ReadToken(F, R, I);

}

SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {

return Reader.ReadSourceLocation(F, R, I);

}

SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {

return Reader.ReadSourceRange(F, R, I);

}

std::string ReadString(const RecordData &R, unsigned &I) {

return Reader.ReadString(R, I);

}

TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {

return Reader.GetTypeSourceInfo(F, R, I);

}

serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {

return Reader.ReadDeclID(F, R, I);

}

Decl *ReadDecl(const RecordData &R, unsigned &I) {

return Reader.ReadDecl(F, R, I);

}

template<typename T>

T *ReadDeclAs(const RecordData &R, unsigned &I) {

return Reader.ReadDeclAs<T>(F, R, I);

}

void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,

const ASTReader::RecordData &R, unsigned &I) {

Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);

}

void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,

const ASTReader::RecordData &R, unsigned &I) {

Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);

}

public:

ASTStmtReader(ASTReader &Reader, ModuleFile &F,

llvm::BitstreamCursor &Cursor,

const ASTReader::RecordData &Record, unsigned &Idx)

: Reader(Reader), F(F), DeclsCursor(Cursor), Record(Record), Idx(Idx) { }

/// \brief The number of record fields required for the Stmt class

/// itself.

static const unsigned NumStmtFields = 0;

/// \brief The number of record fields required for the Expr class

/// itself.

static const unsigned NumExprFields = NumStmtFields + 7;

/// \brief Read and initialize a ExplicitTemplateArgumentList structure.

void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,

unsigned NumTemplateArgs);

/// \brief Read and initialize a ExplicitTemplateArgumentList structure.

void ReadExplicitTemplateArgumentList(ASTTemplateArgumentListInfo &ArgList,

unsigned NumTemplateArgs);

100

101

void VisitStmt(Stmt *S);

102

#define STMT(Type, Base) \

103

void Visit##Type(Type *);

104

#include "clang/AST/StmtNodes.inc"

105

};

106

}

107

108

void ASTStmtReader::

109

ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,

110

unsigned NumTemplateArgs) {

111

SourceLocation TemplateKWLoc = ReadSourceLocation(Record, Idx);

112

TemplateArgumentListInfo ArgInfo;

113

ArgInfo.setLAngleLoc(ReadSourceLocation(Record, Idx));

114

ArgInfo.setRAngleLoc(ReadSourceLocation(Record, Idx));

115

for (unsigned i = 0; i != NumTemplateArgs; ++i)

116

ArgInfo.addArgument(

117

Reader.ReadTemplateArgumentLoc(F, Record, Idx));

118

Args.initializeFrom(TemplateKWLoc, ArgInfo);

119

}

120

121

void ASTStmtReader::VisitStmt(Stmt *S) {

122

assert(Idx == NumStmtFields && "Incorrect statement field count")((Idx == NumStmtFields && "Incorrect statement field count"
) ? static_cast<void> (0) : __assert_fail ("Idx == NumStmtFields && \"Incorrect statement field count\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 122, __PRETTY_FUNCTION__));

123

}

124

125

void ASTStmtReader::VisitNullStmt(NullStmt *S) {

126

VisitStmt(S);

127

S->setSemiLoc(ReadSourceLocation(Record, Idx));

128

S->HasLeadingEmptyMacro = Record[Idx++];

129

}

130

131

void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {

132

VisitStmt(S);

133

SmallVector<Stmt *, 16> Stmts;

134

unsigned NumStmts = Record[Idx++];

135

while (NumStmts--)

136

Stmts.push_back(Reader.ReadSubStmt());

137

S->setStmts(Reader.getContext(), Stmts.data(), Stmts.size());

138

S->LBraceLoc = ReadSourceLocation(Record, Idx);

139

S->RBraceLoc = ReadSourceLocation(Record, Idx);

140

}

141

142

void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {

143

VisitStmt(S);

144

Reader.RecordSwitchCaseID(S, Record[Idx++]);

145

S->setKeywordLoc(ReadSourceLocation(Record, Idx));

146

S->setColonLoc(ReadSourceLocation(Record, Idx));

147

}

148

149

void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {

150

VisitSwitchCase(S);

151

S->setLHS(Reader.ReadSubExpr());

152

S->setRHS(Reader.ReadSubExpr());

153

S->setSubStmt(Reader.ReadSubStmt());

154

S->setEllipsisLoc(ReadSourceLocation(Record, Idx));

155

}

156

157

void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {

158

VisitSwitchCase(S);

159

S->setSubStmt(Reader.ReadSubStmt());

160

}

161

162

void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {

163

VisitStmt(S);

164

LabelDecl *LD = ReadDeclAs<LabelDecl>(Record, Idx);

165

LD->setStmt(S);

166

S->setDecl(LD);

167

S->setSubStmt(Reader.ReadSubStmt());

168

S->setIdentLoc(ReadSourceLocation(Record, Idx));

169

}

170

171

void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {

172

VisitStmt(S);

173

uint64_t NumAttrs = Record[Idx++];

174

AttrVec Attrs;

175

Reader.ReadAttributes(F, Attrs, Record, Idx);

176

(void)NumAttrs;

177

assert(NumAttrs == S->NumAttrs)((NumAttrs == S->NumAttrs) ? static_cast<void> (0) :
__assert_fail ("NumAttrs == S->NumAttrs", "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 177, __PRETTY_FUNCTION__));

178

assert(NumAttrs == Attrs.size())((NumAttrs == Attrs.size()) ? static_cast<void> (0) : __assert_fail
("NumAttrs == Attrs.size()", "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 178, __PRETTY_FUNCTION__));

179

std::copy(Attrs.begin(), Attrs.end(), S->getAttrArrayPtr());

180

S->SubStmt = Reader.ReadSubStmt();

181

S->AttrLoc = ReadSourceLocation(Record, Idx);

182

}

183

184

void ASTStmtReader::VisitIfStmt(IfStmt *S) {

185

VisitStmt(S);

186

S->setConditionVariable(Reader.getContext(),

187

ReadDeclAs<VarDecl>(Record, Idx));

188

S->setCond(Reader.ReadSubExpr());

189

S->setThen(Reader.ReadSubStmt());

190

S->setElse(Reader.ReadSubStmt());

191

S->setIfLoc(ReadSourceLocation(Record, Idx));

192

S->setElseLoc(ReadSourceLocation(Record, Idx));

193

}

194

195

void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {

196

VisitStmt(S);

197

S->setConditionVariable(Reader.getContext(),

198

ReadDeclAs<VarDecl>(Record, Idx));

199

S->setCond(Reader.ReadSubExpr());

200

S->setBody(Reader.ReadSubStmt());

201

S->setSwitchLoc(ReadSourceLocation(Record, Idx));

202

if (Record[Idx++])

203

S->setAllEnumCasesCovered();

204

205

SwitchCase *PrevSC = nullptr;

206

for (unsigned N = Record.size(); Idx != N; ++Idx) {

207

SwitchCase *SC = Reader.getSwitchCaseWithID(Record[Idx]);

208

if (PrevSC)

209

PrevSC->setNextSwitchCase(SC);

210

else

211

S->setSwitchCaseList(SC);

212

213

PrevSC = SC;

214

}

215

}

216

217

void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {

218

VisitStmt(S);

219

S->setConditionVariable(Reader.getContext(),

220

ReadDeclAs<VarDecl>(Record, Idx));

221

222

S->setCond(Reader.ReadSubExpr());

223

S->setBody(Reader.ReadSubStmt());

224

S->setWhileLoc(ReadSourceLocation(Record, Idx));

225

}

226

227

void ASTStmtReader::VisitDoStmt(DoStmt *S) {

228

VisitStmt(S);

229

S->setCond(Reader.ReadSubExpr());

230

S->setBody(Reader.ReadSubStmt());

231

S->setDoLoc(ReadSourceLocation(Record, Idx));

232

S->setWhileLoc(ReadSourceLocation(Record, Idx));

233

S->setRParenLoc(ReadSourceLocation(Record, Idx));

234

}

235

236

void ASTStmtReader::VisitForStmt(ForStmt *S) {

237

VisitStmt(S);

238

S->setInit(Reader.ReadSubStmt());

239

S->setCond(Reader.ReadSubExpr());

240

S->setConditionVariable(Reader.getContext(),

241

ReadDeclAs<VarDecl>(Record, Idx));

242

S->setInc(Reader.ReadSubExpr());

243

S->setBody(Reader.ReadSubStmt());

244

S->setForLoc(ReadSourceLocation(Record, Idx));

245

S->setLParenLoc(ReadSourceLocation(Record, Idx));

246

S->setRParenLoc(ReadSourceLocation(Record, Idx));

247

}

248

249

void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {

250

VisitStmt(S);

251

S->setLabel(ReadDeclAs<LabelDecl>(Record, Idx));

252

S->setGotoLoc(ReadSourceLocation(Record, Idx));

253

S->setLabelLoc(ReadSourceLocation(Record, Idx));

254

}

255

256

void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {

257

VisitStmt(S);

258

S->setGotoLoc(ReadSourceLocation(Record, Idx));

259

S->setStarLoc(ReadSourceLocation(Record, Idx));

260

S->setTarget(Reader.ReadSubExpr());

261

}

262

263

void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {

264

VisitStmt(S);

265

S->setContinueLoc(ReadSourceLocation(Record, Idx));

266

}

267

268

void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {

269

VisitStmt(S);

270

S->setBreakLoc(ReadSourceLocation(Record, Idx));

271

}

272

273

void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {

274

VisitStmt(S);

275

S->setRetValue(Reader.ReadSubExpr());

276

S->setReturnLoc(ReadSourceLocation(Record, Idx));

277

S->setNRVOCandidate(ReadDeclAs<VarDecl>(Record, Idx));

278

}

279

280

void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {

281

VisitStmt(S);

282

S->setStartLoc(ReadSourceLocation(Record, Idx));

283

S->setEndLoc(ReadSourceLocation(Record, Idx));

284

285

if (Idx + 1 == Record.size()) {

286

// Single declaration

287

S->setDeclGroup(DeclGroupRef(ReadDecl(Record, Idx)));

288

} else {

289

SmallVector<Decl *, 16> Decls;

290

Decls.reserve(Record.size() - Idx);

291

for (unsigned N = Record.size(); Idx != N; )

292

Decls.push_back(ReadDecl(Record, Idx));

293

S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Reader.getContext(),

294

Decls.data(),

295

Decls.size())));

296

}

297

}

298

299

void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {

300

VisitStmt(S);

301

S->NumOutputs = Record[Idx++];

302

S->NumInputs = Record[Idx++];

303

S->NumClobbers = Record[Idx++];

304

S->setAsmLoc(ReadSourceLocation(Record, Idx));

305

S->setVolatile(Record[Idx++]);

306

S->setSimple(Record[Idx++]);

307

}

308

309

void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) {

310

VisitAsmStmt(S);

311

S->setRParenLoc(ReadSourceLocation(Record, Idx));

312

S->setAsmString(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));

313

314

unsigned NumOutputs = S->getNumOutputs();

315

unsigned NumInputs = S->getNumInputs();

316

unsigned NumClobbers = S->getNumClobbers();

317

318

// Outputs and inputs

319

SmallVector<IdentifierInfo *, 16> Names;

320

SmallVector<StringLiteral*, 16> Constraints;

321

SmallVector<Stmt*, 16> Exprs;

322

for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {

323

Names.push_back(Reader.GetIdentifierInfo(F, Record, Idx));

324

Constraints.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));

325

Exprs.push_back(Reader.ReadSubStmt());

326

}

327

328

// Constraints

329

SmallVector<StringLiteral*, 16> Clobbers;

330

for (unsigned I = 0; I != NumClobbers; ++I)

331

Clobbers.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));

332

333

S->setOutputsAndInputsAndClobbers(Reader.getContext(),

334

Names.data(), Constraints.data(),

335

Exprs.data(), NumOutputs, NumInputs,

336

Clobbers.data(), NumClobbers);

337

}

338

339

void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {

340

VisitAsmStmt(S);

341

S->LBraceLoc = ReadSourceLocation(Record, Idx);

342

S->EndLoc = ReadSourceLocation(Record, Idx);

343

S->NumAsmToks = Record[Idx++];

344

std::string AsmStr = ReadString(Record, Idx);

345

346

// Read the tokens.

347

SmallVector<Token, 16> AsmToks;

348

AsmToks.reserve(S->NumAsmToks);

349

for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) {

350

AsmToks.push_back(ReadToken(Record, Idx));

351

}

352

353

// The calls to reserve() for the FooData vectors are mandatory to

354

// prevent dead StringRefs in the Foo vectors.

355

356

// Read the clobbers.

357

SmallVector<std::string, 16> ClobbersData;

358

SmallVector<StringRef, 16> Clobbers;

359

ClobbersData.reserve(S->NumClobbers);

360

Clobbers.reserve(S->NumClobbers);

361

for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {

362

ClobbersData.push_back(ReadString(Record, Idx));

363

Clobbers.push_back(ClobbersData.back());

364

}

365

366

// Read the operands.

367

unsigned NumOperands = S->NumOutputs + S->NumInputs;

368

SmallVector<Expr*, 16> Exprs;

369

SmallVector<std::string, 16> ConstraintsData;

370

SmallVector<StringRef, 16> Constraints;

371

Exprs.reserve(NumOperands);

372

ConstraintsData.reserve(NumOperands);

373

Constraints.reserve(NumOperands);

374

for (unsigned i = 0; i != NumOperands; ++i) {

375

Exprs.push_back(cast<Expr>(Reader.ReadSubStmt()));

376

ConstraintsData.push_back(ReadString(Record, Idx));

377

Constraints.push_back(ConstraintsData.back());

378

}

379

380

S->initialize(Reader.getContext(), AsmStr, AsmToks,

381

Constraints, Exprs, Clobbers);

382

}

383

384

void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {

385

VisitStmt(S);

386

++Idx;

387

S->setCapturedDecl(ReadDeclAs<CapturedDecl>(Record, Idx));

388

S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record[Idx++]));

389

S->setCapturedRecordDecl(ReadDeclAs<RecordDecl>(Record, Idx));

390

391

// Capture inits

392

for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(),

393

E = S->capture_init_end();

394

I != E; ++I)

395

*I = Reader.ReadSubExpr();

396

397

// Body

398

S->setCapturedStmt(Reader.ReadSubStmt());

399

S->getCapturedDecl()->setBody(S->getCapturedStmt());

400

401

// Captures

402

for (auto &I : S->captures()) {

403

I.VarAndKind.setPointer(ReadDeclAs<VarDecl>(Record, Idx));

404

I.VarAndKind

405

.setInt(static_cast<CapturedStmt::VariableCaptureKind>(Record[Idx++]));

406

I.Loc = ReadSourceLocation(Record, Idx);

407

}

408

}

409

410

void ASTStmtReader::VisitExpr(Expr *E) {

411

VisitStmt(E);

412

E->setType(Reader.readType(F, Record, Idx));

413

E->setTypeDependent(Record[Idx++]);

414

E->setValueDependent(Record[Idx++]);

415

E->setInstantiationDependent(Record[Idx++]);

416

E->ExprBits.ContainsUnexpandedParameterPack = Record[Idx++];

417

E->setValueKind(static_cast<ExprValueKind>(Record[Idx++]));

418

E->setObjectKind(static_cast<ExprObjectKind>(Record[Idx++]));

419

assert(Idx == NumExprFields && "Incorrect expression field count")((Idx == NumExprFields && "Incorrect expression field count"
) ? static_cast<void> (0) : __assert_fail ("Idx == NumExprFields && \"Incorrect expression field count\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 419, __PRETTY_FUNCTION__));

420

}

421

422

void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {

423

VisitExpr(E);

424

E->setLocation(ReadSourceLocation(Record, Idx));

425

E->Type = (PredefinedExpr::IdentType)Record[Idx++];

426

E->FnName = cast_or_null<StringLiteral>(Reader.ReadSubExpr());

427

}

428

429

void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {

430

VisitExpr(E);

431

432

E->DeclRefExprBits.HasQualifier = Record[Idx++];

433

E->DeclRefExprBits.HasFoundDecl = Record[Idx++];

434

E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record[Idx++];

435

E->DeclRefExprBits.HadMultipleCandidates = Record[Idx++];

436

E->DeclRefExprBits.RefersToEnclosingVariableOrCapture = Record[Idx++];

437

unsigned NumTemplateArgs = 0;

438

if (E->hasTemplateKWAndArgsInfo())

439

NumTemplateArgs = Record[Idx++];

440

441

if (E->hasQualifier())

442

E->getInternalQualifierLoc()

443

= Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);

444

445

if (E->hasFoundDecl())

446

E->getInternalFoundDecl() = ReadDeclAs<NamedDecl>(Record, Idx);

447

448

if (E->hasTemplateKWAndArgsInfo())

449

ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),

450

NumTemplateArgs);

451

452

E->setDecl(ReadDeclAs<ValueDecl>(Record, Idx));

453

E->setLocation(ReadSourceLocation(Record, Idx));

454

ReadDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record, Idx);

455

}

456

457

void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {

458

VisitExpr(E);

459

E->setLocation(ReadSourceLocation(Record, Idx));

460

E->setValue(Reader.getContext(), Reader.ReadAPInt(Record, Idx));

461

}

462

463

void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {

464

VisitExpr(E);

465

E->setRawSemantics(static_cast<Stmt::APFloatSemantics>(Record[Idx++]));

466

E->setExact(Record[Idx++]);

467

E->setValue(Reader.getContext(),

468

Reader.ReadAPFloat(Record, E->getSemantics(), Idx));

469

E->setLocation(ReadSourceLocation(Record, Idx));

470

}

471

472

void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {

473

VisitExpr(E);

474

E->setSubExpr(Reader.ReadSubExpr());

475

}

476

477

void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {

478

VisitExpr(E);

479

unsigned Len = Record[Idx++];

480

assert(Record[Idx] == E->getNumConcatenated() &&((Record[Idx] == E->getNumConcatenated() && "Wrong number of concatenated tokens!"
) ? static_cast<void> (0) : __assert_fail ("Record[Idx] == E->getNumConcatenated() && \"Wrong number of concatenated tokens!\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 481, __PRETTY_FUNCTION__))

481

"Wrong number of concatenated tokens!")((Record[Idx] == E->getNumConcatenated() && "Wrong number of concatenated tokens!"
) ? static_cast<void> (0) : __assert_fail ("Record[Idx] == E->getNumConcatenated() && \"Wrong number of concatenated tokens!\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 481, __PRETTY_FUNCTION__));

482

++Idx;

483

StringLiteral::StringKind kind =

484

static_cast<StringLiteral::StringKind>(Record[Idx++]);

485

bool isPascal = Record[Idx++];

486

487

// Read string data

488

SmallString<16> Str(&Record[Idx], &Record[Idx] + Len);

489

E->setString(Reader.getContext(), Str, kind, isPascal);

490

Idx += Len;

491

492

// Read source locations

493

for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)

494

E->setStrTokenLoc(I, ReadSourceLocation(Record, Idx));

495

}

496

497

void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {

498

VisitExpr(E);

499

E->setValue(Record[Idx++]);

500

E->setLocation(ReadSourceLocation(Record, Idx));

501

E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record[Idx++]));

502

}

503

504

void ASTStmtReader::VisitParenExpr(ParenExpr *E) {

505

VisitExpr(E);

506

E->setLParen(ReadSourceLocation(Record, Idx));

507

E->setRParen(ReadSourceLocation(Record, Idx));

508

E->setSubExpr(Reader.ReadSubExpr());

509

}

510

511

void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {

512

VisitExpr(E);

513

unsigned NumExprs = Record[Idx++];

514

E->Exprs = new (Reader.getContext()) Stmt*[NumExprs];

515

for (unsigned i = 0; i != NumExprs; ++i)

516

E->Exprs[i] = Reader.ReadSubStmt();

517

E->NumExprs = NumExprs;

518

E->LParenLoc = ReadSourceLocation(Record, Idx);

519

E->RParenLoc = ReadSourceLocation(Record, Idx);

520

}

521

522

void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {

523

VisitExpr(E);

524

E->setSubExpr(Reader.ReadSubExpr());

525

E->setOpcode((UnaryOperator::Opcode)Record[Idx++]);

526

E->setOperatorLoc(ReadSourceLocation(Record, Idx));

527

}

528

529

void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {

530

typedef OffsetOfExpr::OffsetOfNode Node;

531

VisitExpr(E);

532

assert(E->getNumComponents() == Record[Idx])((E->getNumComponents() == Record[Idx]) ? static_cast<void
> (0) : __assert_fail ("E->getNumComponents() == Record[Idx]"
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 532, __PRETTY_FUNCTION__));

533

++Idx;

534

assert(E->getNumExpressions() == Record[Idx])((E->getNumExpressions() == Record[Idx]) ? static_cast<
void> (0) : __assert_fail ("E->getNumExpressions() == Record[Idx]"
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 534, __PRETTY_FUNCTION__));

535

++Idx;

536

E->setOperatorLoc(ReadSourceLocation(Record, Idx));

537

E->setRParenLoc(ReadSourceLocation(Record, Idx));

538

E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));

539

for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {

540

Node::Kind Kind = static_cast<Node::Kind>(Record[Idx++]);

541

SourceLocation Start = ReadSourceLocation(Record, Idx);

542

SourceLocation End = ReadSourceLocation(Record, Idx);

543

switch (Kind) {

544

case Node::Array:

545

E->setComponent(I, Node(Start, Record[Idx++], End));

546

break;

547

548

case Node::Field:

549

E->setComponent(I, Node(Start, ReadDeclAs<FieldDecl>(Record, Idx), End));

550

break;

551

552

case Node::Identifier:

553

E->setComponent(I,

554

Node(Start,

555

Reader.GetIdentifierInfo(F, Record, Idx),

556

End));

557

break;

558

559

case Node::Base: {

560

CXXBaseSpecifier *Base = new (Reader.getContext()) CXXBaseSpecifier();

561

*Base = Reader.ReadCXXBaseSpecifier(F, Record, Idx);

562

E->setComponent(I, Node(Base));

563

break;

564

}

565

}

566

}

567

568

for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)

569

E->setIndexExpr(I, Reader.ReadSubExpr());

570

}

571

572

void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {

573

VisitExpr(E);

574

E->setKind(static_cast<UnaryExprOrTypeTrait>(Record[Idx++]));

575

if (Record[Idx] == 0) {

576

E->setArgument(Reader.ReadSubExpr());

577

++Idx;

578

} else {

579

E->setArgument(GetTypeSourceInfo(Record, Idx));

580

}

581

E->setOperatorLoc(ReadSourceLocation(Record, Idx));

582

E->setRParenLoc(ReadSourceLocation(Record, Idx));

583

}

584

585

void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {

586

VisitExpr(E);

587

E->setLHS(Reader.ReadSubExpr());

588

E->setRHS(Reader.ReadSubExpr());

589

E->setRBracketLoc(ReadSourceLocation(Record, Idx));

590

}

591

592

void ASTStmtReader::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {

593

VisitExpr(E);

594

E->setBase(Reader.ReadSubExpr());

595

E->setLowerBound(Reader.ReadSubExpr());

596

E->setLength(Reader.ReadSubExpr());

597

E->setColonLoc(ReadSourceLocation(Record, Idx));

598

E->setRBracketLoc(ReadSourceLocation(Record, Idx));

599

}

600

601

void ASTStmtReader::VisitCallExpr(CallExpr *E) {

602

VisitExpr(E);

603

E->setNumArgs(Reader.getContext(), Record[Idx++]);

604

E->setRParenLoc(ReadSourceLocation(Record, Idx));

605

E->setCallee(Reader.ReadSubExpr());

606

for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)

607

E->setArg(I, Reader.ReadSubExpr());

608

}

609

610

void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {

611

VisitCallExpr(E);

612

}

613

614

void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {

615

// Don't call VisitExpr, this is fully initialized at creation.

616

assert(E->getStmtClass() == Stmt::MemberExprClass &&((E->getStmtClass() == Stmt::MemberExprClass && "It's a subclass, we must advance Idx!"
) ? static_cast<void> (0) : __assert_fail ("E->getStmtClass() == Stmt::MemberExprClass && \"It's a subclass, we must advance Idx!\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 617, __PRETTY_FUNCTION__))

617

"It's a subclass, we must advance Idx!")((E->getStmtClass() == Stmt::MemberExprClass && "It's a subclass, we must advance Idx!"
) ? static_cast<void> (0) : __assert_fail ("E->getStmtClass() == Stmt::MemberExprClass && \"It's a subclass, we must advance Idx!\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 617, __PRETTY_FUNCTION__));

618

}

619

620

void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {

621

VisitExpr(E);

622

E->setBase(Reader.ReadSubExpr());

623

E->setIsaMemberLoc(ReadSourceLocation(Record, Idx));

624

E->setOpLoc(ReadSourceLocation(Record, Idx));

625

E->setArrow(Record[Idx++]);

626

}

627

628

void ASTStmtReader::

629

VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {

630

VisitExpr(E);

631

E->Operand = Reader.ReadSubExpr();

632

E->setShouldCopy(Record[Idx++]);

633

}

634

635

void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {

636

VisitExplicitCastExpr(E);

637

E->LParenLoc = ReadSourceLocation(Record, Idx);

638

E->BridgeKeywordLoc = ReadSourceLocation(Record, Idx);

639

E->Kind = Record[Idx++];

640

}

641

642

void ASTStmtReader::VisitCastExpr(CastExpr *E) {

643

VisitExpr(E);

644

unsigned NumBaseSpecs = Record[Idx++];

645

assert(NumBaseSpecs == E->path_size())((NumBaseSpecs == E->path_size()) ? static_cast<void>
(0) : __assert_fail ("NumBaseSpecs == E->path_size()", "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 645, __PRETTY_FUNCTION__));

646

E->setSubExpr(Reader.ReadSubExpr());

647

E->setCastKind((CastKind)Record[Idx++]);

648

CastExpr::path_iterator BaseI = E->path_begin();

649

while (NumBaseSpecs--) {

650

CXXBaseSpecifier *BaseSpec = new (Reader.getContext()) CXXBaseSpecifier;

651

*BaseSpec = Reader.ReadCXXBaseSpecifier(F, Record, Idx);

652

*BaseI++ = BaseSpec;

653

}

654

}

655

656

void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {

657

VisitExpr(E);

658

E->setLHS(Reader.ReadSubExpr());

659

E->setRHS(Reader.ReadSubExpr());

660

E->setOpcode((BinaryOperator::Opcode)Record[Idx++]);

661

E->setOperatorLoc(ReadSourceLocation(Record, Idx));

662

E->setFPContractable((bool)Record[Idx++]);

663

}

664

665

void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {

666

VisitBinaryOperator(E);

667

E->setComputationLHSType(Reader.readType(F, Record, Idx));

668

E->setComputationResultType(Reader.readType(F, Record, Idx));

669

}

670

671

void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {

672

VisitExpr(E);

673

E->SubExprs[ConditionalOperator::COND] = Reader.ReadSubExpr();

674

E->SubExprs[ConditionalOperator::LHS] = Reader.ReadSubExpr();

675

E->SubExprs[ConditionalOperator::RHS] = Reader.ReadSubExpr();

676

E->QuestionLoc = ReadSourceLocation(Record, Idx);

677

E->ColonLoc = ReadSourceLocation(Record, Idx);

678

}

679

680

void

681

ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {

682

VisitExpr(E);

683

E->OpaqueValue = cast<OpaqueValueExpr>(Reader.ReadSubExpr());

684

E->SubExprs[BinaryConditionalOperator::COMMON] = Reader.ReadSubExpr();

685

E->SubExprs[BinaryConditionalOperator::COND] = Reader.ReadSubExpr();

686

E->SubExprs[BinaryConditionalOperator::LHS] = Reader.ReadSubExpr();

687

E->SubExprs[BinaryConditionalOperator::RHS] = Reader.ReadSubExpr();

688

E->QuestionLoc = ReadSourceLocation(Record, Idx);

689

E->ColonLoc = ReadSourceLocation(Record, Idx);

690

}

691

692

void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {

693

VisitCastExpr(E);

694

}

695

696

void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {

697

VisitCastExpr(E);

698

E->setTypeInfoAsWritten(GetTypeSourceInfo(Record, Idx));

699

}

700

701

void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {

702

VisitExplicitCastExpr(E);

703

E->setLParenLoc(ReadSourceLocation(Record, Idx));

704

E->setRParenLoc(ReadSourceLocation(Record, Idx));

705

}

706

707

void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {

708

VisitExpr(E);

709

E->setLParenLoc(ReadSourceLocation(Record, Idx));

710

E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));

711

E->setInitializer(Reader.ReadSubExpr());

712

E->setFileScope(Record[Idx++]);

713

}

714

715

void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {

716

VisitExpr(E);

717

E->setBase(Reader.ReadSubExpr());

718

E->setAccessor(Reader.GetIdentifierInfo(F, Record, Idx));

719

E->setAccessorLoc(ReadSourceLocation(Record, Idx));

720

}

721

722

void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {

723

VisitExpr(E);

724

if (InitListExpr *SyntForm = cast_or_null<InitListExpr>(Reader.ReadSubStmt()))

725

E->setSyntacticForm(SyntForm);

726

E->setLBraceLoc(ReadSourceLocation(Record, Idx));

727

E->setRBraceLoc(ReadSourceLocation(Record, Idx));

728

bool isArrayFiller = Record[Idx++];

729

Expr *filler = nullptr;

730

if (isArrayFiller) {

731

filler = Reader.ReadSubExpr();

732

E->ArrayFillerOrUnionFieldInit = filler;

733

} else

734

E->ArrayFillerOrUnionFieldInit = ReadDeclAs<FieldDecl>(Record, Idx);

735

E->sawArrayRangeDesignator(Record[Idx++]);

736

unsigned NumInits = Record[Idx++];

737

E->reserveInits(Reader.getContext(), NumInits);

738

if (isArrayFiller) {

739

for (unsigned I = 0; I != NumInits; ++I) {

740

Expr *init = Reader.ReadSubExpr();

741

E->updateInit(Reader.getContext(), I, init ? init : filler);

742

}

743

} else {

744

for (unsigned I = 0; I != NumInits; ++I)

745

E->updateInit(Reader.getContext(), I, Reader.ReadSubExpr());

746

}

747

}

748

749

void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {

750

typedef DesignatedInitExpr::Designator Designator;

751

752

VisitExpr(E);

753

unsigned NumSubExprs = Record[Idx++];

754

assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs")((NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs"
) ? static_cast<void> (0) : __assert_fail ("NumSubExprs == E->getNumSubExprs() && \"Wrong number of subexprs\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 754, __PRETTY_FUNCTION__));

755

for (unsigned I = 0; I != NumSubExprs; ++I)

756

E->setSubExpr(I, Reader.ReadSubExpr());

757

E->setEqualOrColonLoc(ReadSourceLocation(Record, Idx));

758

E->setGNUSyntax(Record[Idx++]);

759

760

SmallVector<Designator, 4> Designators;

761

while (Idx < Record.size()) {

762

switch ((DesignatorTypes)Record[Idx++]) {

763

case DESIG_FIELD_DECL: {

764

FieldDecl *Field = ReadDeclAs<FieldDecl>(Record, Idx);

765

SourceLocation DotLoc

766

= ReadSourceLocation(Record, Idx);

767

SourceLocation FieldLoc

768

= ReadSourceLocation(Record, Idx);

769

Designators.push_back(Designator(Field->getIdentifier(), DotLoc,

770

FieldLoc));

771

Designators.back().setField(Field);

772

break;

773

}

774

775

case DESIG_FIELD_NAME: {

776

const IdentifierInfo *Name = Reader.GetIdentifierInfo(F, Record, Idx);

777

SourceLocation DotLoc

778

= ReadSourceLocation(Record, Idx);

779

SourceLocation FieldLoc

780

= ReadSourceLocation(Record, Idx);

781

Designators.push_back(Designator(Name, DotLoc, FieldLoc));

782

break;

783

}

784

785

case DESIG_ARRAY: {

786

unsigned Index = Record[Idx++];

787

SourceLocation LBracketLoc

788

= ReadSourceLocation(Record, Idx);

789

SourceLocation RBracketLoc

790

= ReadSourceLocation(Record, Idx);

791

Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));

792

break;

793

}

794

795

case DESIG_ARRAY_RANGE: {

796

unsigned Index = Record[Idx++];

797

SourceLocation LBracketLoc

798

= ReadSourceLocation(Record, Idx);

799

SourceLocation EllipsisLoc

800

= ReadSourceLocation(Record, Idx);

801

SourceLocation RBracketLoc

802

= ReadSourceLocation(Record, Idx);

803

Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,

804

RBracketLoc));

805

break;

806

}

807

}

808

}

809

E->setDesignators(Reader.getContext(),

810

Designators.data(), Designators.size());

811

}

812

813

void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {

814

VisitExpr(E);

815

E->setBase(Reader.ReadSubExpr());

816

E->setUpdater(Reader.ReadSubExpr());

817

}

818

819

void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) {

820

VisitExpr(E);

821

}

822

823

void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {

824

VisitExpr(E);

825

}

826

827

void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {

828

VisitExpr(E);

829

E->setSubExpr(Reader.ReadSubExpr());

830

E->setWrittenTypeInfo(GetTypeSourceInfo(Record, Idx));

831

E->setBuiltinLoc(ReadSourceLocation(Record, Idx));

832

E->setRParenLoc(ReadSourceLocation(Record, Idx));

833

}

834

835

void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {

836

VisitExpr(E);

837

E->setAmpAmpLoc(ReadSourceLocation(Record, Idx));

838

E->setLabelLoc(ReadSourceLocation(Record, Idx));

839

E->setLabel(ReadDeclAs<LabelDecl>(Record, Idx));

840

}

841

842

void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {

843

VisitExpr(E);

844

E->setLParenLoc(ReadSourceLocation(Record, Idx));

845

E->setRParenLoc(ReadSourceLocation(Record, Idx));

846

E->setSubStmt(cast_or_null<CompoundStmt>(Reader.ReadSubStmt()));

847

}

848

849

void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {

850

VisitExpr(E);

851

E->setCond(Reader.ReadSubExpr());

852

E->setLHS(Reader.ReadSubExpr());

853

E->setRHS(Reader.ReadSubExpr());

854

E->setBuiltinLoc(ReadSourceLocation(Record, Idx));

855

E->setRParenLoc(ReadSourceLocation(Record, Idx));

856

E->setIsConditionTrue(Record[Idx++]);

857

}

858

859

void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {

860

VisitExpr(E);

861

E->setTokenLocation(ReadSourceLocation(Record, Idx));

862

}

863

864

void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {

865

VisitExpr(E);

866

SmallVector<Expr *, 16> Exprs;

867

unsigned NumExprs = Record[Idx++];

868

while (NumExprs--)

869

Exprs.push_back(Reader.ReadSubExpr());

870

E->setExprs(Reader.getContext(), Exprs);

871

E->setBuiltinLoc(ReadSourceLocation(Record, Idx));

872

E->setRParenLoc(ReadSourceLocation(Record, Idx));

873

}

874

875

void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) {

876

VisitExpr(E);

877

E->BuiltinLoc = ReadSourceLocation(Record, Idx);

878

E->RParenLoc = ReadSourceLocation(Record, Idx);

879

E->TInfo = GetTypeSourceInfo(Record, Idx);

880

E->SrcExpr = Reader.ReadSubExpr();

881

}

882

883

void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {

884

VisitExpr(E);

885

E->setBlockDecl(ReadDeclAs<BlockDecl>(Record, Idx));

886

}

887

888

void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {

889

VisitExpr(E);

890

E->NumAssocs = Record[Idx++];

891

E->AssocTypes = new (Reader.getContext()) TypeSourceInfo*[E->NumAssocs];

892

E->SubExprs =

893

new(Reader.getContext()) Stmt*[GenericSelectionExpr::END_EXPR+E->NumAssocs];

894

895

E->SubExprs[GenericSelectionExpr::CONTROLLING] = Reader.ReadSubExpr();

896

for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {

897

E->AssocTypes[I] = GetTypeSourceInfo(Record, Idx);

898

E->SubExprs[GenericSelectionExpr::END_EXPR+I] = Reader.ReadSubExpr();

899

}

900

E->ResultIndex = Record[Idx++];

901

902

E->GenericLoc = ReadSourceLocation(Record, Idx);

903

E->DefaultLoc = ReadSourceLocation(Record, Idx);

904

E->RParenLoc = ReadSourceLocation(Record, Idx);

905

}

906

907

void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {

908

VisitExpr(E);

909

unsigned numSemanticExprs = Record[Idx++];

910

assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs)((numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs
) ? static_cast<void> (0) : __assert_fail ("numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs"
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 910, __PRETTY_FUNCTION__));

911

E->PseudoObjectExprBits.ResultIndex = Record[Idx++];

912

913

// Read the syntactic expression.

914

E->getSubExprsBuffer()[0] = Reader.ReadSubExpr();

915

916

// Read all the semantic expressions.

917

for (unsigned i = 0; i != numSemanticExprs; ++i) {

918

Expr *subExpr = Reader.ReadSubExpr();

919

E->getSubExprsBuffer()[i+1] = subExpr;

920

}

921

}

922

923

void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {

924

VisitExpr(E);

925

E->Op = AtomicExpr::AtomicOp(Record[Idx++]);

926

E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);

927

for (unsigned I = 0; I != E->NumSubExprs; ++I)

928

E->SubExprs[I] = Reader.ReadSubExpr();

929

E->BuiltinLoc = ReadSourceLocation(Record, Idx);

930

E->RParenLoc = ReadSourceLocation(Record, Idx);

931

}

932

933

//===----------------------------------------------------------------------===//

934

// Objective-C Expressions and Statements

935

936

void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {

937

VisitExpr(E);

938

E->setString(cast<StringLiteral>(Reader.ReadSubStmt()));

939

E->setAtLoc(ReadSourceLocation(Record, Idx));

940

}

941

942

void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {

943

VisitExpr(E);

944

// could be one of several IntegerLiteral, FloatLiteral, etc.

945

E->SubExpr = Reader.ReadSubStmt();

946

E->BoxingMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx);

947

E->Range = ReadSourceRange(Record, Idx);

948

}

949

950

void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {

951

VisitExpr(E);

952

unsigned NumElements = Record[Idx++];

953

assert(NumElements == E->getNumElements() && "Wrong number of elements")((NumElements == E->getNumElements() && "Wrong number of elements"
) ? static_cast<void> (0) : __assert_fail ("NumElements == E->getNumElements() && \"Wrong number of elements\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 953, __PRETTY_FUNCTION__));

954

Expr **Elements = E->getElements();

955

for (unsigned I = 0, N = NumElements; I != N; ++I)

956

Elements[I] = Reader.ReadSubExpr();

957

E->ArrayWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx);

958

E->Range = ReadSourceRange(Record, Idx);

959

}

960

961

void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {

962

VisitExpr(E);

963

unsigned NumElements = Record[Idx++];

964

965

bool HasPackExpansions = Record[Idx++];

966

assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch")((HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch"
) ? static_cast<void> (0) : __assert_fail ("HasPackExpansions == E->HasPackExpansions &&\"Pack expansion mismatch\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 966, __PRETTY_FUNCTION__));

967

ObjCDictionaryLiteral::KeyValuePair *KeyValues = E->getKeyValues();

968

ObjCDictionaryLiteral::ExpansionData *Expansions = E->getExpansionData();

969

for (unsigned I = 0; I != NumElements; ++I) {

970

KeyValues[I].Key = Reader.ReadSubExpr();

971

KeyValues[I].Value = Reader.ReadSubExpr();

972

if (HasPackExpansions) {

973

Expansions[I].EllipsisLoc = ReadSourceLocation(Record, Idx);

974

Expansions[I].NumExpansionsPlusOne = Record[Idx++];

975

}

976

}

977

E->DictWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx);

978

E->Range = ReadSourceRange(Record, Idx);

979

}

980

981

void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {

982

VisitExpr(E);

983

E->setEncodedTypeSourceInfo(GetTypeSourceInfo(Record, Idx));

984

E->setAtLoc(ReadSourceLocation(Record, Idx));

985

E->setRParenLoc(ReadSourceLocation(Record, Idx));

986

}

987

988

void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {

989

VisitExpr(E);

990

E->setSelector(Reader.ReadSelector(F, Record, Idx));

991

E->setAtLoc(ReadSourceLocation(Record, Idx));

992

E->setRParenLoc(ReadSourceLocation(Record, Idx));

993

}

994

995

void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {

996

VisitExpr(E);

997

E->setProtocol(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));

998

E->setAtLoc(ReadSourceLocation(Record, Idx));

999

E->ProtoLoc = ReadSourceLocation(Record, Idx);

1000

E->setRParenLoc(ReadSourceLocation(Record, Idx));

1001

}

1002

1003

void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {

1004

VisitExpr(E);

1005

E->setDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));

1006

E->setLocation(ReadSourceLocation(Record, Idx));

1007

E->setOpLoc(ReadSourceLocation(Record, Idx));

1008

E->setBase(Reader.ReadSubExpr());

1009

E->setIsArrow(Record[Idx++]);

1010

E->setIsFreeIvar(Record[Idx++]);

1011

}

1012

1013

void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {

1014

VisitExpr(E);

1015

unsigned MethodRefFlags = Record[Idx++];

1016

bool Implicit = Record[Idx++] != 0;

1017

if (Implicit) {

1018

ObjCMethodDecl *Getter = ReadDeclAs<ObjCMethodDecl>(Record, Idx);

1019

ObjCMethodDecl *Setter = ReadDeclAs<ObjCMethodDecl>(Record, Idx);

1020

E->setImplicitProperty(Getter, Setter, MethodRefFlags);

1021

} else {

1022

E->setExplicitProperty(ReadDeclAs<ObjCPropertyDecl>(Record, Idx),

1023

MethodRefFlags);

1024

}

1025

E->setLocation(ReadSourceLocation(Record, Idx));

1026

E->setReceiverLocation(ReadSourceLocation(Record, Idx));

1027

switch (Record[Idx++]) {

1028

case 0:

1029

E->setBase(Reader.ReadSubExpr());

1030

break;

1031

case 1:

1032

E->setSuperReceiver(Reader.readType(F, Record, Idx));

1033

break;

1034

case 2:

1035

E->setClassReceiver(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));

1036

break;

1037

}

1038

}

1039

1040

void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {

1041

VisitExpr(E);

1042

E->setRBracket(ReadSourceLocation(Record, Idx));

1043

E->setBaseExpr(Reader.ReadSubExpr());

1044

E->setKeyExpr(Reader.ReadSubExpr());

1045

E->GetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>(Record, Idx);

1046

E->SetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>(Record, Idx);

1047

}

1048

1049

void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {

1050

VisitExpr(E);

1051

assert(Record[Idx] == E->getNumArgs())((Record[Idx] == E->getNumArgs()) ? static_cast<void>
(0) : __assert_fail ("Record[Idx] == E->getNumArgs()", "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1051, __PRETTY_FUNCTION__));

1052

++Idx;

1053

unsigned NumStoredSelLocs = Record[Idx++];

1054

E->SelLocsKind = Record[Idx++];

1055

E->setDelegateInitCall(Record[Idx++]);

1056

E->IsImplicit = Record[Idx++];

1057

ObjCMessageExpr::ReceiverKind Kind

1058

= static_cast<ObjCMessageExpr::ReceiverKind>(Record[Idx++]);

1059

switch (Kind) {

1060

case ObjCMessageExpr::Instance:

1061

E->setInstanceReceiver(Reader.ReadSubExpr());

1062

break;

1063

1064

case ObjCMessageExpr::Class:

1065

E->setClassReceiver(GetTypeSourceInfo(Record, Idx));

1066

break;

1067

1068

case ObjCMessageExpr::SuperClass:

1069

case ObjCMessageExpr::SuperInstance: {

1070

QualType T = Reader.readType(F, Record, Idx);

1071

SourceLocation SuperLoc = ReadSourceLocation(Record, Idx);

1072

E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);

1073

break;

1074

}

1075

}

1076

1077

assert(Kind == E->getReceiverKind())((Kind == E->getReceiverKind()) ? static_cast<void> (
0) : __assert_fail ("Kind == E->getReceiverKind()", "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1077, __PRETTY_FUNCTION__));

1078

1079

if (Record[Idx++])

1080

E->setMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));

1081

else

1082

E->setSelector(Reader.ReadSelector(F, Record, Idx));

1083

1084

E->LBracLoc = ReadSourceLocation(Record, Idx);

1085

E->RBracLoc = ReadSourceLocation(Record, Idx);

1086

1087

for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)

1088

E->setArg(I, Reader.ReadSubExpr());

1089

1090

SourceLocation *Locs = E->getStoredSelLocs();

1091

for (unsigned I = 0; I != NumStoredSelLocs; ++I)

1092

Locs[I] = ReadSourceLocation(Record, Idx);

1093

}

1094

1095

void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {

1096

VisitStmt(S);

1097

S->setElement(Reader.ReadSubStmt());

1098

S->setCollection(Reader.ReadSubExpr());

1099

S->setBody(Reader.ReadSubStmt());

1100

S->setForLoc(ReadSourceLocation(Record, Idx));

1101

S->setRParenLoc(ReadSourceLocation(Record, Idx));

1102

}

1103

1104

void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {

1105

VisitStmt(S);

1106

S->setCatchBody(Reader.ReadSubStmt());

1107

S->setCatchParamDecl(ReadDeclAs<VarDecl>(Record, Idx));

1108

S->setAtCatchLoc(ReadSourceLocation(Record, Idx));

1109

S->setRParenLoc(ReadSourceLocation(Record, Idx));

1110

}

1111

1112

void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {

1113

VisitStmt(S);

1114

S->setFinallyBody(Reader.ReadSubStmt());

1115

S->setAtFinallyLoc(ReadSourceLocation(Record, Idx));

1116

}

1117

1118

void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {

1119

VisitStmt(S);

1120

S->setSubStmt(Reader.ReadSubStmt());

1121

S->setAtLoc(ReadSourceLocation(Record, Idx));

1122

}

1123

1124

void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {

1125

VisitStmt(S);

1126

assert(Record[Idx] == S->getNumCatchStmts())((Record[Idx] == S->getNumCatchStmts()) ? static_cast<void
> (0) : __assert_fail ("Record[Idx] == S->getNumCatchStmts()"
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1126, __PRETTY_FUNCTION__));

1127

++Idx;

1128

bool HasFinally = Record[Idx++];

1129

S->setTryBody(Reader.ReadSubStmt());

1130

for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)

1131

S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Reader.ReadSubStmt()));

1132

1133

if (HasFinally)

1134

S->setFinallyStmt(Reader.ReadSubStmt());

1135

S->setAtTryLoc(ReadSourceLocation(Record, Idx));

1136

}

1137

1138

void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {

1139

VisitStmt(S);

1140

S->setSynchExpr(Reader.ReadSubStmt());

1141

S->setSynchBody(Reader.ReadSubStmt());

1142

S->setAtSynchronizedLoc(ReadSourceLocation(Record, Idx));

1143

}

1144

1145

void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {

1146

VisitStmt(S);

1147

S->setThrowExpr(Reader.ReadSubStmt());

1148

S->setThrowLoc(ReadSourceLocation(Record, Idx));

1149

}

1150

1151

void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {

1152

VisitExpr(E);

1153

E->setValue(Record[Idx++]);

1154

E->setLocation(ReadSourceLocation(Record, Idx));

1155

}

1156

1157

//===----------------------------------------------------------------------===//

1158

// C++ Expressions and Statements

1159

//===----------------------------------------------------------------------===//

1160

1161

void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {

1162

VisitStmt(S);

1163

S->CatchLoc = ReadSourceLocation(Record, Idx);

1164

S->ExceptionDecl = ReadDeclAs<VarDecl>(Record, Idx);

1165

S->HandlerBlock = Reader.ReadSubStmt();

1166

}

1167

1168

void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {

1169

VisitStmt(S);

1170

assert(Record[Idx] == S->getNumHandlers() && "NumStmtFields is wrong ?")((Record[Idx] == S->getNumHandlers() && "NumStmtFields is wrong ?"
) ? static_cast<void> (0) : __assert_fail ("Record[Idx] == S->getNumHandlers() && \"NumStmtFields is wrong ?\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1170, __PRETTY_FUNCTION__));

1171

++Idx;

1172

S->TryLoc = ReadSourceLocation(Record, Idx);

1173

S->getStmts()[0] = Reader.ReadSubStmt();

1174

for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)

1175

S->getStmts()[i + 1] = Reader.ReadSubStmt();

1176

}

1177

1178

void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {

1179

VisitStmt(S);

1180

S->setForLoc(ReadSourceLocation(Record, Idx));

1181

S->setColonLoc(ReadSourceLocation(Record, Idx));

1182

S->setRParenLoc(ReadSourceLocation(Record, Idx));

1183

S->setRangeStmt(Reader.ReadSubStmt());

1184

S->setBeginEndStmt(Reader.ReadSubStmt());

1185

S->setCond(Reader.ReadSubExpr());

1186

S->setInc(Reader.ReadSubExpr());

1187

S->setLoopVarStmt(Reader.ReadSubStmt());

1188

S->setBody(Reader.ReadSubStmt());

1189

}

1190

1191

void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {

1192

VisitStmt(S);

1193

S->KeywordLoc = ReadSourceLocation(Record, Idx);

1194

S->IsIfExists = Record[Idx++];

1195

S->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);

1196

ReadDeclarationNameInfo(S->NameInfo, Record, Idx);

1197

S->SubStmt = Reader.ReadSubStmt();

1198

}

1199

1200

void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {

1201

VisitCallExpr(E);

1202

E->Operator = (OverloadedOperatorKind)Record[Idx++];

1203

E->Range = Reader.ReadSourceRange(F, Record, Idx);

1204

E->setFPContractable((bool)Record[Idx++]);

1205

}

1206

1207

void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {

1208

VisitExpr(E);

1209

E->NumArgs = Record[Idx++];

1210

if (E->NumArgs)

1211

E->Args = new (Reader.getContext()) Stmt*[E->NumArgs];

1212

for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)

1213

E->setArg(I, Reader.ReadSubExpr());

1214

E->setConstructor(ReadDeclAs<CXXConstructorDecl>(Record, Idx));

1215

E->setLocation(ReadSourceLocation(Record, Idx));

1216

E->setElidable(Record[Idx++]);

1217

E->setHadMultipleCandidates(Record[Idx++]);

1218

E->setListInitialization(Record[Idx++]);

1219

E->setStdInitListInitialization(Record[Idx++]);

1220

E->setRequiresZeroInitialization(Record[Idx++]);

1221

E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]);

1222

E->ParenOrBraceRange = ReadSourceRange(Record, Idx);

1223

}

1224

1225

void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {

1226

VisitCXXConstructExpr(E);

1227

E->Type = GetTypeSourceInfo(Record, Idx);

1228

}

1229

1230

void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {

1231

VisitExpr(E);

1232

unsigned NumCaptures = Record[Idx++];

1233

assert(NumCaptures == E->NumCaptures)((NumCaptures == E->NumCaptures) ? static_cast<void>
(0) : __assert_fail ("NumCaptures == E->NumCaptures", "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1233, __PRETTY_FUNCTION__));(void)NumCaptures;

1234

unsigned NumArrayIndexVars = Record[Idx++];

1235

E->IntroducerRange = ReadSourceRange(Record, Idx);

1236

E->CaptureDefault = static_cast<LambdaCaptureDefault>(Record[Idx++]);

1237

E->CaptureDefaultLoc = ReadSourceLocation(Record, Idx);

1238

E->ExplicitParams = Record[Idx++];

1239

E->ExplicitResultType = Record[Idx++];

1240

E->ClosingBrace = ReadSourceLocation(Record, Idx);

1241

1242

// Read capture initializers.

1243

for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),

1244

CEnd = E->capture_init_end();

1245

C != CEnd; ++C)

1246

*C = Reader.ReadSubExpr();

1247

1248

// Read array capture index variables.

1249

if (NumArrayIndexVars > 0) {

1250

unsigned *ArrayIndexStarts = E->getArrayIndexStarts();

1251

for (unsigned I = 0; I != NumCaptures + 1; ++I)

1252

ArrayIndexStarts[I] = Record[Idx++];

1253

1254

VarDecl **ArrayIndexVars = E->getArrayIndexVars();

1255

for (unsigned I = 0; I != NumArrayIndexVars; ++I)

1256

ArrayIndexVars[I] = ReadDeclAs<VarDecl>(Record, Idx);

1257

}

1258

}

1259

1260

void

1261

ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {

1262

VisitExpr(E);

1263

E->SubExpr = Reader.ReadSubExpr();

1264

}

1265

1266

void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {

1267

VisitExplicitCastExpr(E);

1268

SourceRange R = ReadSourceRange(Record, Idx);

1269

E->Loc = R.getBegin();

1270

E->RParenLoc = R.getEnd();

1271

R = ReadSourceRange(Record, Idx);

1272

E->AngleBrackets = R;

1273

}

1274

1275

void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {

1276

return VisitCXXNamedCastExpr(E);

1277

}

1278

1279

void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {

1280

return VisitCXXNamedCastExpr(E);

1281

}

1282

1283

void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {

1284

return VisitCXXNamedCastExpr(E);

1285

}

1286

1287

void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {

1288

return VisitCXXNamedCastExpr(E);

1289

}

1290

1291

void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {

1292

VisitExplicitCastExpr(E);

1293

E->setLParenLoc(ReadSourceLocation(Record, Idx));

1294

E->setRParenLoc(ReadSourceLocation(Record, Idx));

1295

}

1296

1297

void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {

1298

VisitCallExpr(E);

1299

E->UDSuffixLoc = ReadSourceLocation(Record, Idx);

1300

}

1301

1302

void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {

1303

VisitExpr(E);

1304

E->setValue(Record[Idx++]);

1305

E->setLocation(ReadSourceLocation(Record, Idx));

1306

}

1307

1308

void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {

1309

VisitExpr(E);

1310

E->setLocation(ReadSourceLocation(Record, Idx));

1311

}

1312

1313

void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {

1314

VisitExpr(E);

1315

E->setSourceRange(ReadSourceRange(Record, Idx));

1316

if (E->isTypeOperand()) { // typeid(int)

1317

E->setTypeOperandSourceInfo(

1318

GetTypeSourceInfo(Record, Idx));

1319

return;

1320

}

1321

1322

// typeid(42+2)

1323

E->setExprOperand(Reader.ReadSubExpr());

1324

}

1325

1326

void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {

1327

VisitExpr(E);

1328

E->setLocation(ReadSourceLocation(Record, Idx));

1329

E->setImplicit(Record[Idx++]);

1330

}

1331

1332

void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {

1333

VisitExpr(E);

1334

E->ThrowLoc = ReadSourceLocation(Record, Idx);

1335

E->Op = Reader.ReadSubExpr();

1336

E->IsThrownVariableInScope = Record[Idx++];

1337

}

1338

1339

void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {

1340

VisitExpr(E);

1341

1342

assert((bool)Record[Idx] == E->Param.getInt() && "We messed up at creation ?")(((bool)Record[Idx] == E->Param.getInt() && "We messed up at creation ?"
) ? static_cast<void> (0) : __assert_fail ("(bool)Record[Idx] == E->Param.getInt() && \"We messed up at creation ?\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1342, __PRETTY_FUNCTION__));

1343

++Idx; // HasOtherExprStored and SubExpr was handled during creation.

1344

E->Param.setPointer(ReadDeclAs<ParmVarDecl>(Record, Idx));

1345

E->Loc = ReadSourceLocation(Record, Idx);

1346

}

1347

1348

void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {

1349

VisitExpr(E);

1350

E->Field = ReadDeclAs<FieldDecl>(Record, Idx);

1351

E->Loc = ReadSourceLocation(Record, Idx);

1352

}

1353

1354

void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {

1355

VisitExpr(E);

1356

E->setTemporary(Reader.ReadCXXTemporary(F, Record, Idx));

1357

E->setSubExpr(Reader.ReadSubExpr());

1358

}

1359

1360

void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {

1361

VisitExpr(E);

1362

E->TypeInfo = GetTypeSourceInfo(Record, Idx);

1363

E->RParenLoc = ReadSourceLocation(Record, Idx);

1364

}

1365

1366

void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {

1367

VisitExpr(E);

1368

E->GlobalNew = Record[Idx++];

1369

bool isArray = Record[Idx++];

1370

E->UsualArrayDeleteWantsSize = Record[Idx++];

1371

unsigned NumPlacementArgs = Record[Idx++];

1372

E->StoredInitializationStyle = Record[Idx++];

1373

E->setOperatorNew(ReadDeclAs<FunctionDecl>(Record, Idx));

1374

E->setOperatorDelete(ReadDeclAs<FunctionDecl>(Record, Idx));

1375

E->AllocatedTypeInfo = GetTypeSourceInfo(Record, Idx);

1376

E->TypeIdParens = ReadSourceRange(Record, Idx);

1377

E->Range = ReadSourceRange(Record, Idx);

1378

E->DirectInitRange = ReadSourceRange(Record, Idx);

1379

1380

E->AllocateArgsArray(Reader.getContext(), isArray, NumPlacementArgs,

1381

E->StoredInitializationStyle != 0);

1382

1383

// Install all the subexpressions.

1384

for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end();

1385

I != e; ++I)

1386

*I = Reader.ReadSubStmt();

1387

}

1388

1389

void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {

1390

VisitExpr(E);

1391

E->GlobalDelete = Record[Idx++];

1392

E->ArrayForm = Record[Idx++];

1393

E->ArrayFormAsWritten = Record[Idx++];

1394

E->UsualArrayDeleteWantsSize = Record[Idx++];

1395

E->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx);

1396

E->Argument = Reader.ReadSubExpr();

1397

E->Loc = ReadSourceLocation(Record, Idx);

1398

}

1399

1400

void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {

1401

VisitExpr(E);

1402

1403

E->Base = Reader.ReadSubExpr();

1404

E->IsArrow = Record[Idx++];

1405

E->OperatorLoc = ReadSourceLocation(Record, Idx);

1406

E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);

1407

E->ScopeType = GetTypeSourceInfo(Record, Idx);

1408

E->ColonColonLoc = ReadSourceLocation(Record, Idx);

1409

E->TildeLoc = ReadSourceLocation(Record, Idx);

1410

1411

IdentifierInfo *II = Reader.GetIdentifierInfo(F, Record, Idx);

1412

if (II)

1413

E->setDestroyedType(II, ReadSourceLocation(Record, Idx));

1414

else

1415

E->setDestroyedType(GetTypeSourceInfo(Record, Idx));

1416

}

1417

1418

void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {

1419

VisitExpr(E);

1420

1421

unsigned NumObjects = Record[Idx++];

1422

assert(NumObjects == E->getNumObjects())((NumObjects == E->getNumObjects()) ? static_cast<void>
(0) : __assert_fail ("NumObjects == E->getNumObjects()", "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1422, __PRETTY_FUNCTION__));

1423

for (unsigned i = 0; i != NumObjects; ++i)

1424

E->getObjectsBuffer()[i] = ReadDeclAs<BlockDecl>(Record, Idx);

1425

1426

E->SubExpr = Reader.ReadSubExpr();

1427

}

1428

1429

void

1430

ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){

1431

VisitExpr(E);

1432

1433

if (Record[Idx++]) // HasTemplateKWAndArgsInfo

1434

ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),

1435

/*NumTemplateArgs=*/Record[Idx++]);

1436

1437

E->Base = Reader.ReadSubExpr();

1438

E->BaseType = Reader.readType(F, Record, Idx);

1439

E->IsArrow = Record[Idx++];

1440

E->OperatorLoc = ReadSourceLocation(Record, Idx);

1441

E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);

1442

E->FirstQualifierFoundInScope = ReadDeclAs<NamedDecl>(Record, Idx);

1443

ReadDeclarationNameInfo(E->MemberNameInfo, Record, Idx);

1444

}

1445

1446

void

1447

ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {

1448

VisitExpr(E);

1449

1450

if (Record[Idx++]) // HasTemplateKWAndArgsInfo

1451

ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),

1452

/*NumTemplateArgs=*/Record[Idx++]);

1453

1454

E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);

1455

ReadDeclarationNameInfo(E->NameInfo, Record, Idx);

1456

}

1457

1458

void

1459

ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {

1460

VisitExpr(E);

1461

assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?")((Record[Idx] == E->arg_size() && "Read wrong record during creation ?"
) ? static_cast<void> (0) : __assert_fail ("Record[Idx] == E->arg_size() && \"Read wrong record during creation ?\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1461, __PRETTY_FUNCTION__));

1462

++Idx; // NumArgs;

1463

for (unsigned I = 0, N = E->arg_size(); I != N; ++I)

1464

E->setArg(I, Reader.ReadSubExpr());

1465

E->Type = GetTypeSourceInfo(Record, Idx);

1466

E->setLParenLoc(ReadSourceLocation(Record, Idx));

1467

E->setRParenLoc(ReadSourceLocation(Record, Idx));

1468

}

1469

1470

void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {

1471

VisitExpr(E);

1472

1473

if (Record[Idx++]) // HasTemplateKWAndArgsInfo

1474

ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),

1475

/*NumTemplateArgs=*/Record[Idx++]);

1476

1477

unsigned NumDecls = Record[Idx++];

1478

UnresolvedSet<8> Decls;

1479

for (unsigned i = 0; i != NumDecls; ++i) {

1480

NamedDecl *D = ReadDeclAs<NamedDecl>(Record, Idx);

1481

AccessSpecifier AS = (AccessSpecifier)Record[Idx++];

1482

Decls.addDecl(D, AS);

1483

}

1484

E->initializeResults(Reader.getContext(), Decls.begin(), Decls.end());

1485

1486

ReadDeclarationNameInfo(E->NameInfo, Record, Idx);

1487

E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);

1488

}

1489

1490

void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {

1491

VisitOverloadExpr(E);

1492

E->IsArrow = Record[Idx++];

1493

E->HasUnresolvedUsing = Record[Idx++];

1494

E->Base = Reader.ReadSubExpr();

1495

E->BaseType = Reader.readType(F, Record, Idx);

1496

E->OperatorLoc = ReadSourceLocation(Record, Idx);

1497

}

1498

1499

void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {

1500

VisitOverloadExpr(E);

1501

E->RequiresADL = Record[Idx++];

1502

E->Overloaded = Record[Idx++];

1503

E->NamingClass = ReadDeclAs<CXXRecordDecl>(Record, Idx);

1504

}

1505

1506

void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {

1507

VisitExpr(E);

1508

E->TypeTraitExprBits.NumArgs = Record[Idx++];

1509

E->TypeTraitExprBits.Kind = Record[Idx++];

1510

E->TypeTraitExprBits.Value = Record[Idx++];

1511

SourceRange Range = ReadSourceRange(Record, Idx);

1512

E->Loc = Range.getBegin();

1513

E->RParenLoc = Range.getEnd();

1514

1515

TypeSourceInfo **Args = E->getTypeSourceInfos();

1516

for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)

1517

Args[I] = GetTypeSourceInfo(Record, Idx);

1518

}

1519

1520

void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {

1521

VisitExpr(E);

1522

E->ATT = (ArrayTypeTrait)Record[Idx++];

1523

E->Value = (unsigned int)Record[Idx++];

1524

SourceRange Range = ReadSourceRange(Record, Idx);

1525

E->Loc = Range.getBegin();

1526

E->RParen = Range.getEnd();

1527

E->QueriedType = GetTypeSourceInfo(Record, Idx);

1528

}

1529

1530

void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {

1531

VisitExpr(E);

1532

E->ET = (ExpressionTrait)Record[Idx++];

1533

E->Value = (bool)Record[Idx++];

1534

SourceRange Range = ReadSourceRange(Record, Idx);

1535

E->QueriedExpression = Reader.ReadSubExpr();

1536

E->Loc = Range.getBegin();

1537

E->RParen = Range.getEnd();

1538

}

1539

1540

void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {

1541

VisitExpr(E);

1542

E->Value = (bool)Record[Idx++];

1543

E->Range = ReadSourceRange(Record, Idx);

1544

E->Operand = Reader.ReadSubExpr();

1545

}

1546

1547

void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {

1548

VisitExpr(E);

1549

E->EllipsisLoc = ReadSourceLocation(Record, Idx);

1550

E->NumExpansions = Record[Idx++];

1551

E->Pattern = Reader.ReadSubExpr();

1552

}

1553

1554

void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {

1555

VisitExpr(E);

1556

E->OperatorLoc = ReadSourceLocation(Record, Idx);

1557

E->PackLoc = ReadSourceLocation(Record, Idx);

1558

E->RParenLoc = ReadSourceLocation(Record, Idx);

1559

E->Length = Record[Idx++];

1560

E->Pack = ReadDeclAs<NamedDecl>(Record, Idx);

1561

}

1562

1563

void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(

1564

SubstNonTypeTemplateParmExpr *E) {

1565

VisitExpr(E);

1566

E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(Record, Idx);

1567

E->NameLoc = ReadSourceLocation(Record, Idx);

1568

E->Replacement = Reader.ReadSubExpr();

1569

}

1570

1571

void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(

1572

SubstNonTypeTemplateParmPackExpr *E) {

1573

VisitExpr(E);

1574

E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(Record, Idx);

1575

TemplateArgument ArgPack = Reader.ReadTemplateArgument(F, Record, Idx);

1576

if (ArgPack.getKind() != TemplateArgument::Pack)

1577

return;

1578

1579

E->Arguments = ArgPack.pack_begin();

1580

E->NumArguments = ArgPack.pack_size();

1581

E->NameLoc = ReadSourceLocation(Record, Idx);

1582

}

1583

1584

void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {

1585

VisitExpr(E);

1586

E->NumParameters = Record[Idx++];

1587

E->ParamPack = ReadDeclAs<ParmVarDecl>(Record, Idx);

1588

E->NameLoc = ReadSourceLocation(Record, Idx);

1589

ParmVarDecl **Parms = reinterpret_cast<ParmVarDecl**>(E+1);

1590

for (unsigned i = 0, n = E->NumParameters; i != n; ++i)

1591

Parms[i] = ReadDeclAs<ParmVarDecl>(Record, Idx);

1592

}

1593

1594

void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {

1595

VisitExpr(E);

1596

E->State = Reader.ReadSubExpr();

1597

auto VD = ReadDeclAs<ValueDecl>(Record, Idx);

1598

unsigned ManglingNumber = Record[Idx++];

1599

E->setExtendingDecl(VD, ManglingNumber);

1600

}

1601

1602

void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {

1603

VisitExpr(E);

1604

E->LParenLoc = ReadSourceLocation(Record, Idx);

1605

E->EllipsisLoc = ReadSourceLocation(Record, Idx);

1606

E->RParenLoc = ReadSourceLocation(Record, Idx);

1607

E->SubExprs[0] = Reader.ReadSubExpr();

1608

E->SubExprs[1] = Reader.ReadSubExpr();

1609

E->Opcode = (BinaryOperatorKind)Record[Idx++];

1610

}

1611

1612

void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {

1613

VisitExpr(E);

1614

E->SourceExpr = Reader.ReadSubExpr();

1615

E->Loc = ReadSourceLocation(Record, Idx);

1616

}

1617

1618

void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {

1619

llvm_unreachable("Cannot read TypoExpr nodes")::llvm::llvm_unreachable_internal("Cannot read TypoExpr nodes"
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1619);

1620

}

1621

1622

//===----------------------------------------------------------------------===//

1623

// Microsoft Expressions and Statements

1624

//===----------------------------------------------------------------------===//

1625

void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {

1626

VisitExpr(E);

1627

E->IsArrow = (Record[Idx++] != 0);

1628

E->BaseExpr = Reader.ReadSubExpr();

1629

E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);

1630

E->MemberLoc = ReadSourceLocation(Record, Idx);

1631

E->TheDecl = ReadDeclAs<MSPropertyDecl>(Record, Idx);

1632

}

1633

1634

void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {

1635

VisitExpr(E);

1636

E->setSourceRange(ReadSourceRange(Record, Idx));

1637

if (E->isTypeOperand()) { // __uuidof(ComType)

1638

E->setTypeOperandSourceInfo(

1639

GetTypeSourceInfo(Record, Idx));

1640

return;

1641

}

1642

1643

// __uuidof(expr)

1644

E->setExprOperand(Reader.ReadSubExpr());

1645

}

1646

1647

void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) {

1648

VisitStmt(S);

1649

S->setLeaveLoc(ReadSourceLocation(Record, Idx));

1650

}

1651

1652

void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {

1653

VisitStmt(S);

1654

S->Loc = ReadSourceLocation(Record, Idx);

1655

S->Children[SEHExceptStmt::FILTER_EXPR] = Reader.ReadSubStmt();

1656

S->Children[SEHExceptStmt::BLOCK] = Reader.ReadSubStmt();

1657

}

1658

1659

void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {

1660

VisitStmt(S);

1661

S->Loc = ReadSourceLocation(Record, Idx);

1662

S->Block = Reader.ReadSubStmt();

1663

}

1664

1665

void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {

1666

VisitStmt(S);

1667

S->IsCXXTry = Record[Idx++];

1668

S->TryLoc = ReadSourceLocation(Record, Idx);

1669

S->Children[SEHTryStmt::TRY] = Reader.ReadSubStmt();

1670

S->Children[SEHTryStmt::HANDLER] = Reader.ReadSubStmt();

1671

}

1672

1673

//===----------------------------------------------------------------------===//

1674

// CUDA Expressions and Statements

1675

//===----------------------------------------------------------------------===//

1676

1677

void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {

1678

VisitCallExpr(E);

1679

E->setConfig(cast<CallExpr>(Reader.ReadSubExpr()));

1680

}

1681

1682

//===----------------------------------------------------------------------===//

1683

// OpenCL Expressions and Statements.

1684

//===----------------------------------------------------------------------===//

1685

void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {

1686

VisitExpr(E);

1687

E->BuiltinLoc = ReadSourceLocation(Record, Idx);

1688

E->RParenLoc = ReadSourceLocation(Record, Idx);

1689

E->SrcExpr = Reader.ReadSubExpr();

1690

}

1691

1692

//===----------------------------------------------------------------------===//

1693

// OpenMP Clauses.

1694

//===----------------------------------------------------------------------===//

1695

1696

namespace clang {

1697

class OMPClauseReader : public OMPClauseVisitor<OMPClauseReader> {

1698

ASTStmtReader *Reader;

1699

ASTContext &Context;

1700

const ASTReader::RecordData &Record;

1701

unsigned &Idx;

1702

public:

1703

OMPClauseReader(ASTStmtReader *R, ASTContext &C,

1704

const ASTReader::RecordData &Record, unsigned &Idx)

1705

: Reader(R), Context(C), Record(Record), Idx(Idx) { }

1706

#define OPENMP_CLAUSE(Name, Class) \

1707

void Visit##Class(Class *S);

1708

#include "clang/Basic/OpenMPKinds.def"

1709

OMPClause *readClause();

1710

};

1711

}

1712

1713

OMPClause *OMPClauseReader::readClause() {

1714

OMPClause *C;

'C' declared without an initial value

→

1715

switch (Record[Idx++]) {

←

'Default' branch taken. Execution continues on line 1807

→

1716

case OMPC_if:

1717

C = new (Context) OMPIfClause();

1718

break;

1719

case OMPC_final:

1720

C = new (Context) OMPFinalClause();

1721

break;

1722

case OMPC_num_threads:

1723

C = new (Context) OMPNumThreadsClause();

1724

break;

1725

case OMPC_safelen:

1726

C = new (Context) OMPSafelenClause();

1727

break;

1728

case OMPC_simdlen:

1729

C = new (Context) OMPSimdlenClause();

1730

break;

1731

case OMPC_collapse:

1732

C = new (Context) OMPCollapseClause();

1733

break;

1734

case OMPC_default:

1735

C = new (Context) OMPDefaultClause();

1736

break;

1737

case OMPC_proc_bind:

1738

C = new (Context) OMPProcBindClause();

1739

break;

1740

case OMPC_schedule:

1741

C = new (Context) OMPScheduleClause();

1742

break;

1743

case OMPC_ordered:

1744

C = new (Context) OMPOrderedClause();

1745

break;

1746

case OMPC_nowait:

1747

C = new (Context) OMPNowaitClause();

1748

break;

1749

case OMPC_untied:

1750

C = new (Context) OMPUntiedClause();

1751

break;

1752

case OMPC_mergeable:

1753

C = new (Context) OMPMergeableClause();

1754

break;

1755

case OMPC_read:

1756

C = new (Context) OMPReadClause();

1757

break;

1758

case OMPC_write:

1759

C = new (Context) OMPWriteClause();

1760

break;

1761

case OMPC_update:

1762

C = new (Context) OMPUpdateClause();

1763

break;

1764

case OMPC_capture:

1765

C = new (Context) OMPCaptureClause();

1766

break;

1767

case OMPC_seq_cst:

1768

C = new (Context) OMPSeqCstClause();

1769

break;

1770

case OMPC_private:

1771

C = OMPPrivateClause::CreateEmpty(Context, Record[Idx++]);

1772

break;

1773

case OMPC_firstprivate:

1774

C = OMPFirstprivateClause::CreateEmpty(Context, Record[Idx++]);

1775

break;

1776

case OMPC_lastprivate:

1777

C = OMPLastprivateClause::CreateEmpty(Context, Record[Idx++]);

1778

break;

1779

case OMPC_shared:

1780

C = OMPSharedClause::CreateEmpty(Context, Record[Idx++]);

1781

break;

1782

case OMPC_reduction:

1783

C = OMPReductionClause::CreateEmpty(Context, Record[Idx++]);

1784

break;

1785

case OMPC_linear:

1786

C = OMPLinearClause::CreateEmpty(Context, Record[Idx++]);

1787

break;

1788

case OMPC_aligned:

1789

C = OMPAlignedClause::CreateEmpty(Context, Record[Idx++]);

1790

break;

1791

case OMPC_copyin:

1792

C = OMPCopyinClause::CreateEmpty(Context, Record[Idx++]);

1793

break;

1794

case OMPC_copyprivate:

1795

C = OMPCopyprivateClause::CreateEmpty(Context, Record[Idx++]);

1796

break;

1797

case OMPC_flush:

1798

C = OMPFlushClause::CreateEmpty(Context, Record[Idx++]);

1799

break;

1800

case OMPC_depend:

1801

C = OMPDependClause::CreateEmpty(Context, Record[Idx++]);

1802

break;

1803

case OMPC_device:

1804

C = new (Context) OMPDeviceClause();

1805

break;

1806

}

1807

Visit(C);

←

Function call argument is an uninitialized value

1808

C->setLocStart(Reader->ReadSourceLocation(Record, Idx));

1809

C->setLocEnd(Reader->ReadSourceLocation(Record, Idx));

1810

1811

return C;

1812

}

1813

1814

void OMPClauseReader::VisitOMPIfClause(OMPIfClause *C) {

1815

C->setCondition(Reader->Reader.ReadSubExpr());

1816

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

1817

}

1818

1819

void OMPClauseReader::VisitOMPFinalClause(OMPFinalClause *C) {

1820

C->setCondition(Reader->Reader.ReadSubExpr());

1821

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

1822

}

1823

1824

void OMPClauseReader::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {

1825

C->setNumThreads(Reader->Reader.ReadSubExpr());

1826

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

1827

}

1828

1829

void OMPClauseReader::VisitOMPSafelenClause(OMPSafelenClause *C) {

1830

C->setSafelen(Reader->Reader.ReadSubExpr());

1831

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

1832

}

1833

1834

void OMPClauseReader::VisitOMPSimdlenClause(OMPSimdlenClause *C) {

1835

C->setSimdlen(Reader->Reader.ReadSubExpr());

1836

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

1837

}

1838

1839

void OMPClauseReader::VisitOMPCollapseClause(OMPCollapseClause *C) {

1840

C->setNumForLoops(Reader->Reader.ReadSubExpr());

1841

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

1842

}

1843

1844

void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) {

1845

C->setDefaultKind(

1846

static_cast<OpenMPDefaultClauseKind>(Record[Idx++]));

1847

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

1848

C->setDefaultKindKwLoc(Reader->ReadSourceLocation(Record, Idx));

1849

}

1850

1851

void OMPClauseReader::VisitOMPProcBindClause(OMPProcBindClause *C) {

1852

C->setProcBindKind(

1853

static_cast<OpenMPProcBindClauseKind>(Record[Idx++]));

1854

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

1855

C->setProcBindKindKwLoc(Reader->ReadSourceLocation(Record, Idx));

1856

}

1857

1858

void OMPClauseReader::VisitOMPScheduleClause(OMPScheduleClause *C) {

1859

C->setScheduleKind(

1860

static_cast<OpenMPScheduleClauseKind>(Record[Idx++]));

1861

C->setChunkSize(Reader->Reader.ReadSubExpr());

1862

C->setHelperChunkSize(Reader->Reader.ReadSubExpr());

1863

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

1864

C->setScheduleKindLoc(Reader->ReadSourceLocation(Record, Idx));

1865

C->setCommaLoc(Reader->ReadSourceLocation(Record, Idx));

1866

}

1867

1868

void OMPClauseReader::VisitOMPOrderedClause(OMPOrderedClause *C) {

1869

C->setNumForLoops(Reader->Reader.ReadSubExpr());

1870

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

1871

}

1872

1873

void OMPClauseReader::VisitOMPNowaitClause(OMPNowaitClause *) {}

1874

1875

void OMPClauseReader::VisitOMPUntiedClause(OMPUntiedClause *) {}

1876

1877

void OMPClauseReader::VisitOMPMergeableClause(OMPMergeableClause *) {}

1878

1879

void OMPClauseReader::VisitOMPReadClause(OMPReadClause *) {}

1880

1881

void OMPClauseReader::VisitOMPWriteClause(OMPWriteClause *) {}

1882

1883

void OMPClauseReader::VisitOMPUpdateClause(OMPUpdateClause *) {}

1884

1885

void OMPClauseReader::VisitOMPCaptureClause(OMPCaptureClause *) {}

1886

1887

void OMPClauseReader::VisitOMPSeqCstClause(OMPSeqCstClause *) {}

1888

1889

void OMPClauseReader::VisitOMPPrivateClause(OMPPrivateClause *C) {

1890

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

1891

unsigned NumVars = C->varlist_size();

1892

SmallVector<Expr *, 16> Vars;

1893

Vars.reserve(NumVars);

1894

for (unsigned i = 0; i != NumVars; ++i)

1895

Vars.push_back(Reader->Reader.ReadSubExpr());

1896

C->setVarRefs(Vars);

1897

Vars.clear();

1898

for (unsigned i = 0; i != NumVars; ++i)

1899

Vars.push_back(Reader->Reader.ReadSubExpr());

1900

C->setPrivateCopies(Vars);

1901

}

1902

1903

void OMPClauseReader::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {

1904

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

1905

unsigned NumVars = C->varlist_size();

1906

SmallVector<Expr *, 16> Vars;

1907

Vars.reserve(NumVars);

1908

for (unsigned i = 0; i != NumVars; ++i)

1909

Vars.push_back(Reader->Reader.ReadSubExpr());

1910

C->setVarRefs(Vars);

1911

Vars.clear();

1912

for (unsigned i = 0; i != NumVars; ++i)

1913

Vars.push_back(Reader->Reader.ReadSubExpr());

1914

C->setPrivateCopies(Vars);

1915

Vars.clear();

1916

for (unsigned i = 0; i != NumVars; ++i)

1917

Vars.push_back(Reader->Reader.ReadSubExpr());

1918

C->setInits(Vars);

1919

}

1920

1921

void OMPClauseReader::VisitOMPLastprivateClause(OMPLastprivateClause *C) {

1922

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

1923

unsigned NumVars = C->varlist_size();

1924

SmallVector<Expr *, 16> Vars;

1925

Vars.reserve(NumVars);

1926

for (unsigned i = 0; i != NumVars; ++i)

1927

Vars.push_back(Reader->Reader.ReadSubExpr());

1928

C->setVarRefs(Vars);

1929

Vars.clear();

1930

for (unsigned i = 0; i != NumVars; ++i)

1931

Vars.push_back(Reader->Reader.ReadSubExpr());

1932

C->setPrivateCopies(Vars);

1933

Vars.clear();

1934

for (unsigned i = 0; i != NumVars; ++i)

1935

Vars.push_back(Reader->Reader.ReadSubExpr());

1936

C->setSourceExprs(Vars);

1937

Vars.clear();

1938

for (unsigned i = 0; i != NumVars; ++i)

1939

Vars.push_back(Reader->Reader.ReadSubExpr());

1940

C->setDestinationExprs(Vars);

1941

Vars.clear();

1942

for (unsigned i = 0; i != NumVars; ++i)

1943

Vars.push_back(Reader->Reader.ReadSubExpr());

1944

C->setAssignmentOps(Vars);

1945

}

1946

1947

void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) {

1948

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

1949

unsigned NumVars = C->varlist_size();

1950

SmallVector<Expr *, 16> Vars;

1951

Vars.reserve(NumVars);

1952

for (unsigned i = 0; i != NumVars; ++i)

1953

Vars.push_back(Reader->Reader.ReadSubExpr());

1954

C->setVarRefs(Vars);

1955

}

1956

1957

void OMPClauseReader::VisitOMPReductionClause(OMPReductionClause *C) {

1958

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

1959

C->setColonLoc(Reader->ReadSourceLocation(Record, Idx));

1960

NestedNameSpecifierLoc NNSL =

1961

Reader->Reader.ReadNestedNameSpecifierLoc(Reader->F, Record, Idx);

1962

DeclarationNameInfo DNI;

1963

Reader->ReadDeclarationNameInfo(DNI, Record, Idx);

1964

C->setQualifierLoc(NNSL);

1965

C->setNameInfo(DNI);

1966

1967

unsigned NumVars = C->varlist_size();

1968

SmallVector<Expr *, 16> Vars;

1969

Vars.reserve(NumVars);

1970

for (unsigned i = 0; i != NumVars; ++i)

1971

Vars.push_back(Reader->Reader.ReadSubExpr());

1972

C->setVarRefs(Vars);

1973

Vars.clear();

1974

for (unsigned i = 0; i != NumVars; ++i)

1975

Vars.push_back(Reader->Reader.ReadSubExpr());

1976

C->setLHSExprs(Vars);

1977

Vars.clear();

1978

for (unsigned i = 0; i != NumVars; ++i)

1979

Vars.push_back(Reader->Reader.ReadSubExpr());

1980

C->setRHSExprs(Vars);

1981

Vars.clear();

1982

for (unsigned i = 0; i != NumVars; ++i)

1983

Vars.push_back(Reader->Reader.ReadSubExpr());

1984

C->setReductionOps(Vars);

1985

}

1986

1987

void OMPClauseReader::VisitOMPLinearClause(OMPLinearClause *C) {

1988

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

1989

C->setColonLoc(Reader->ReadSourceLocation(Record, Idx));

1990

C->setModifier(static_cast<OpenMPLinearClauseKind>(Record[Idx++]));

1991

C->setModifierLoc(Reader->ReadSourceLocation(Record, Idx));

1992

unsigned NumVars = C->varlist_size();

1993

SmallVector<Expr *, 16> Vars;

1994

Vars.reserve(NumVars);

1995

for (unsigned i = 0; i != NumVars; ++i)

1996

Vars.push_back(Reader->Reader.ReadSubExpr());

1997

C->setVarRefs(Vars);

1998

Vars.clear();

1999

for (unsigned i = 0; i != NumVars; ++i)

2000

Vars.push_back(Reader->Reader.ReadSubExpr());

2001

C->setPrivates(Vars);

2002

Vars.clear();

2003

for (unsigned i = 0; i != NumVars; ++i)

2004

Vars.push_back(Reader->Reader.ReadSubExpr());

2005

C->setInits(Vars);

2006

Vars.clear();

2007

for (unsigned i = 0; i != NumVars; ++i)

2008

Vars.push_back(Reader->Reader.ReadSubExpr());

2009

C->setUpdates(Vars);

2010

Vars.clear();

2011

for (unsigned i = 0; i != NumVars; ++i)

2012

Vars.push_back(Reader->Reader.ReadSubExpr());

2013

C->setFinals(Vars);

2014

C->setStep(Reader->Reader.ReadSubExpr());

2015

C->setCalcStep(Reader->Reader.ReadSubExpr());

2016

}

2017

2018

void OMPClauseReader::VisitOMPAlignedClause(OMPAlignedClause *C) {

2019

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

2020

C->setColonLoc(Reader->ReadSourceLocation(Record, Idx));

2021

unsigned NumVars = C->varlist_size();

2022

SmallVector<Expr *, 16> Vars;

2023

Vars.reserve(NumVars);

2024

for (unsigned i = 0; i != NumVars; ++i)

2025

Vars.push_back(Reader->Reader.ReadSubExpr());

2026

C->setVarRefs(Vars);

2027

C->setAlignment(Reader->Reader.ReadSubExpr());

2028

}

2029

2030

void OMPClauseReader::VisitOMPCopyinClause(OMPCopyinClause *C) {

2031

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

2032

unsigned NumVars = C->varlist_size();

2033

SmallVector<Expr *, 16> Exprs;

2034

Exprs.reserve(NumVars);

2035

for (unsigned i = 0; i != NumVars; ++i)

2036

Exprs.push_back(Reader->Reader.ReadSubExpr());

2037

C->setVarRefs(Exprs);

2038

Exprs.clear();

2039

for (unsigned i = 0; i != NumVars; ++i)

2040

Exprs.push_back(Reader->Reader.ReadSubExpr());

2041

C->setSourceExprs(Exprs);

2042

Exprs.clear();

2043

for (unsigned i = 0; i != NumVars; ++i)

2044

Exprs.push_back(Reader->Reader.ReadSubExpr());

2045

C->setDestinationExprs(Exprs);

2046

Exprs.clear();

2047

for (unsigned i = 0; i != NumVars; ++i)

2048

Exprs.push_back(Reader->Reader.ReadSubExpr());

2049

C->setAssignmentOps(Exprs);

2050

}

2051

2052

void OMPClauseReader::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) {

2053

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

2054

unsigned NumVars = C->varlist_size();

2055

SmallVector<Expr *, 16> Exprs;

2056

Exprs.reserve(NumVars);

2057

for (unsigned i = 0; i != NumVars; ++i)

2058

Exprs.push_back(Reader->Reader.ReadSubExpr());

2059

C->setVarRefs(Exprs);

2060

Exprs.clear();

2061

for (unsigned i = 0; i != NumVars; ++i)

2062

Exprs.push_back(Reader->Reader.ReadSubExpr());

2063

C->setSourceExprs(Exprs);

2064

Exprs.clear();

2065

for (unsigned i = 0; i != NumVars; ++i)

2066

Exprs.push_back(Reader->Reader.ReadSubExpr());

2067

C->setDestinationExprs(Exprs);

2068

Exprs.clear();

2069

for (unsigned i = 0; i != NumVars; ++i)

2070

Exprs.push_back(Reader->Reader.ReadSubExpr());

2071

C->setAssignmentOps(Exprs);

2072

}

2073

2074

void OMPClauseReader::VisitOMPFlushClause(OMPFlushClause *C) {

2075

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

2076

unsigned NumVars = C->varlist_size();

2077

SmallVector<Expr *, 16> Vars;

2078

Vars.reserve(NumVars);

2079

for (unsigned i = 0; i != NumVars; ++i)

2080

Vars.push_back(Reader->Reader.ReadSubExpr());

2081

C->setVarRefs(Vars);

2082

}

2083

2084

void OMPClauseReader::VisitOMPDependClause(OMPDependClause *C) {

2085

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

2086

C->setDependencyKind(static_cast<OpenMPDependClauseKind>(Record[Idx++]));

2087

C->setDependencyLoc(Reader->ReadSourceLocation(Record, Idx));

2088

C->setColonLoc(Reader->ReadSourceLocation(Record, Idx));

2089

unsigned NumVars = C->varlist_size();

2090

SmallVector<Expr *, 16> Vars;

2091

Vars.reserve(NumVars);

2092

for (unsigned i = 0; i != NumVars; ++i)

2093

Vars.push_back(Reader->Reader.ReadSubExpr());

2094

C->setVarRefs(Vars);

2095

}

2096

2097

void OMPClauseReader::VisitOMPDeviceClause(OMPDeviceClause *C) {

2098

C->setDevice(Reader->Reader.ReadSubExpr());

2099

C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));

2100

}

2101

2102

//===----------------------------------------------------------------------===//

2103

// OpenMP Directives.

2104

//===----------------------------------------------------------------------===//

2105

void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {

2106

E->setLocStart(ReadSourceLocation(Record, Idx));

2107

E->setLocEnd(ReadSourceLocation(Record, Idx));

2108

OMPClauseReader ClauseReader(this, Reader.getContext(), Record, Idx);

2109

SmallVector<OMPClause *, 5> Clauses;

2110

for (unsigned i = 0; i < E->getNumClauses(); ++i)

2111

Clauses.push_back(ClauseReader.readClause());

2112

E->setClauses(Clauses);

2113

if (E->hasAssociatedStmt())

2114

E->setAssociatedStmt(Reader.ReadSubStmt());

2115

}

2116

2117

void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) {

2118

VisitStmt(D);

2119

// Two fields (NumClauses and CollapsedNum) were read in ReadStmtFromStream.

2120

Idx += 2;

2121

VisitOMPExecutableDirective(D);

2122

D->setIterationVariable(Reader.ReadSubExpr());

2123

D->setLastIteration(Reader.ReadSubExpr());

2124

D->setCalcLastIteration(Reader.ReadSubExpr());

2125

D->setPreCond(Reader.ReadSubExpr());

2126

D->setCond(Reader.ReadSubExpr());

2127

D->setInit(Reader.ReadSubExpr());

2128

D->setInc(Reader.ReadSubExpr());

2129

if (isOpenMPWorksharingDirective(D->getDirectiveKind())) {

2130

D->setIsLastIterVariable(Reader.ReadSubExpr());

2131

D->setLowerBoundVariable(Reader.ReadSubExpr());

2132

D->setUpperBoundVariable(Reader.ReadSubExpr());

2133

D->setStrideVariable(Reader.ReadSubExpr());

2134

D->setEnsureUpperBound(Reader.ReadSubExpr());

2135

D->setNextLowerBound(Reader.ReadSubExpr());

2136

D->setNextUpperBound(Reader.ReadSubExpr());

2137

}

2138

SmallVector<Expr *, 4> Sub;

2139

unsigned CollapsedNum = D->getCollapsedNumber();

2140

Sub.reserve(CollapsedNum);

2141

for (unsigned i = 0; i < CollapsedNum; ++i)

2142

Sub.push_back(Reader.ReadSubExpr());

2143

D->setCounters(Sub);

2144

Sub.clear();

2145

for (unsigned i = 0; i < CollapsedNum; ++i)

2146

Sub.push_back(Reader.ReadSubExpr());

2147

D->setPrivateCounters(Sub);

2148

Sub.clear();

2149

for (unsigned i = 0; i < CollapsedNum; ++i)

2150

Sub.push_back(Reader.ReadSubExpr());

2151

D->setInits(Sub);

2152

Sub.clear();

2153

for (unsigned i = 0; i < CollapsedNum; ++i)

2154

Sub.push_back(Reader.ReadSubExpr());

2155

D->setUpdates(Sub);

2156

Sub.clear();

2157

for (unsigned i = 0; i < CollapsedNum; ++i)

2158

Sub.push_back(Reader.ReadSubExpr());

2159

D->setFinals(Sub);

2160

}

2161

2162

void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {

2163

VisitStmt(D);

2164

// The NumClauses field was read in ReadStmtFromStream.

2165

++Idx;

2166

VisitOMPExecutableDirective(D);

2167

}

2168

2169

void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {

2170

VisitOMPLoopDirective(D);

2171

}

2172

2173

void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) {

2174

VisitOMPLoopDirective(D);

2175

}

2176

2177

void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) {

2178

VisitOMPLoopDirective(D);

2179

}

2180

2181

void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) {

2182

VisitStmt(D);

2183

// The NumClauses field was read in ReadStmtFromStream.

2184

++Idx;

2185

VisitOMPExecutableDirective(D);

2186

}

2187

2188

void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {

2189

VisitStmt(D);

2190

VisitOMPExecutableDirective(D);

2191

}

2192

2193

void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) {

2194

VisitStmt(D);

2195

// The NumClauses field was read in ReadStmtFromStream.

2196

++Idx;

2197

VisitOMPExecutableDirective(D);

2198

}

2199

2200

void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) {

2201

VisitStmt(D);

2202

VisitOMPExecutableDirective(D);

2203

}

2204

2205

void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) {

2206

VisitStmt(D);

2207

VisitOMPExecutableDirective(D);

2208

ReadDeclarationNameInfo(D->DirName, Record, Idx);

2209

}

2210

2211

void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) {

2212

VisitOMPLoopDirective(D);

2213

}

2214

2215

void ASTStmtReader::VisitOMPParallelForSimdDirective(

2216

OMPParallelForSimdDirective *D) {

2217

VisitOMPLoopDirective(D);

2218

}

2219

2220

void ASTStmtReader::VisitOMPParallelSectionsDirective(

2221

OMPParallelSectionsDirective *D) {

2222

VisitStmt(D);

2223

// The NumClauses field was read in ReadStmtFromStream.

2224

++Idx;

2225

VisitOMPExecutableDirective(D);

2226

}

2227

2228

void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) {

2229

VisitStmt(D);

2230

// The NumClauses field was read in ReadStmtFromStream.

2231

++Idx;

2232

VisitOMPExecutableDirective(D);

2233

}

2234

2235

void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {

2236

VisitStmt(D);

2237

VisitOMPExecutableDirective(D);

2238

}

2239

2240

void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) {

2241

VisitStmt(D);

2242

VisitOMPExecutableDirective(D);

2243

}

2244

2245

void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {

2246

VisitStmt(D);

2247

VisitOMPExecutableDirective(D);

2248

}

2249

2250

void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {

2251

VisitStmt(D);

2252

VisitOMPExecutableDirective(D);

2253

}

2254

2255

void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) {

2256

VisitStmt(D);

2257

// The NumClauses field was read in ReadStmtFromStream.

2258

++Idx;

2259

VisitOMPExecutableDirective(D);

2260

}

2261

2262

void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) {

2263

VisitStmt(D);

2264

VisitOMPExecutableDirective(D);

2265

}

2266

2267

void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) {

2268

VisitStmt(D);

2269

// The NumClauses field was read in ReadStmtFromStream.

2270

++Idx;

2271

VisitOMPExecutableDirective(D);

2272

D->setX(Reader.ReadSubExpr());

2273

D->setV(Reader.ReadSubExpr());

2274

D->setExpr(Reader.ReadSubExpr());

2275

D->setUpdateExpr(Reader.ReadSubExpr());

2276

D->IsXLHSInRHSPart = Record[Idx++] != 0;

2277

D->IsPostfixUpdate = Record[Idx++] != 0;

2278

}

2279

2280

void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {

2281

VisitStmt(D);

2282

// The NumClauses field was read in ReadStmtFromStream.

2283

++Idx;

2284

VisitOMPExecutableDirective(D);

2285

}

2286

2287

void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {

2288

VisitStmt(D);

2289

++Idx;

2290

VisitOMPExecutableDirective(D);

2291

}

2292

2293

void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) {

2294

VisitStmt(D);

2295

// The NumClauses field was read in ReadStmtFromStream.

2296

++Idx;

2297

VisitOMPExecutableDirective(D);

2298

}

2299

2300

void ASTStmtReader::VisitOMPCancellationPointDirective(

2301

OMPCancellationPointDirective *D) {

2302

VisitStmt(D);

2303

VisitOMPExecutableDirective(D);

2304

D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record[Idx++]));

2305

}

2306

2307

void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) {

2308

VisitStmt(D);

2309

VisitOMPExecutableDirective(D);

2310

D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record[Idx++]));

2311

}

2312

2313

//===----------------------------------------------------------------------===//

2314

// ASTReader Implementation

2315

//===----------------------------------------------------------------------===//

2316

2317

Stmt *ASTReader::ReadStmt(ModuleFile &F) {

2318

switch (ReadingKind) {

2319

case Read_None:

2320

llvm_unreachable("should not call this when not reading anything")::llvm::llvm_unreachable_internal("should not call this when not reading anything"
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 2320);

2321

case Read_Decl:

2322

case Read_Type:

2323

return ReadStmtFromStream(F);

2324

case Read_Stmt:

2325

return ReadSubStmt();

2326

}

2327

2328

llvm_unreachable("ReadingKind not set ?")::llvm::llvm_unreachable_internal("ReadingKind not set ?", "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 2328);

2329

}

2330

2331

Expr *ASTReader::ReadExpr(ModuleFile &F) {

2332

return cast_or_null<Expr>(ReadStmt(F));

2333

}

2334

2335

Expr *ASTReader::ReadSubExpr() {

2336

return cast_or_null<Expr>(ReadSubStmt());

2337

}

2338

2339

// Within the bitstream, expressions are stored in Reverse Polish

2340

// Notation, with each of the subexpressions preceding the

2341

// expression they are stored in. Subexpressions are stored from last to first.

2342

// To evaluate expressions, we continue reading expressions and placing them on

2343

// the stack, with expressions having operands removing those operands from the

2344

// stack. Evaluation terminates when we see a STMT_STOP record, and

2345

// the single remaining expression on the stack is our result.

2346

Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {

2347

2348

ReadingKindTracker ReadingKind(Read_Stmt, *this);

2349

llvm::BitstreamCursor &Cursor = F.DeclsCursor;

2350

2351

// Map of offset to previously deserialized stmt. The offset points

2352

/// just after the stmt record.

2353

llvm::DenseMap<uint64_t, Stmt *> StmtEntries;

2354

2355

#ifndef NDEBUG

2356

unsigned PrevNumStmts = StmtStack.size();

2357

#endif

2358

2359

RecordData Record;

2360

unsigned Idx;

2361

ASTStmtReader Reader(*this, F, Cursor, Record, Idx);

2362

Stmt::EmptyShell Empty;

2363

2364

while (true) {

2365

llvm::BitstreamEntry Entry = Cursor.advanceSkippingSubblocks();

2366

2367

switch (Entry.Kind) {

2368

case llvm::BitstreamEntry::SubBlock: // Handled for us already.

2369

case llvm::BitstreamEntry::Error:

2370

Error("malformed block record in AST file");

2371

return nullptr;

2372

case llvm::BitstreamEntry::EndBlock:

2373

goto Done;

2374

case llvm::BitstreamEntry::Record:

2375

// The interesting case.

2376

break;

2377

}

2378

2379

Stmt *S = nullptr;

2380

Idx = 0;

2381

Record.clear();

2382

bool Finished = false;

2383

bool IsStmtReference = false;

2384

switch ((StmtCode)Cursor.readRecord(Entry.ID, Record)) {

2385

case STMT_STOP:

2386

Finished = true;

2387

break;

2388

2389

case STMT_REF_PTR:

2390

IsStmtReference = true;

2391

assert(StmtEntries.find(Record[0]) != StmtEntries.end() &&((StmtEntries.find(Record[0]) != StmtEntries.end() &&
"No stmt was recorded for this offset reference!") ? static_cast
<void> (0) : __assert_fail ("StmtEntries.find(Record[0]) != StmtEntries.end() && \"No stmt was recorded for this offset reference!\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 2392, __PRETTY_FUNCTION__))

2392

"No stmt was recorded for this offset reference!")((StmtEntries.find(Record[0]) != StmtEntries.end() &&
"No stmt was recorded for this offset reference!") ? static_cast
<void> (0) : __assert_fail ("StmtEntries.find(Record[0]) != StmtEntries.end() && \"No stmt was recorded for this offset reference!\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 2392, __PRETTY_FUNCTION__));

2393

S = StmtEntries[Record[Idx++]];

2394

break;

2395

2396

case STMT_NULL_PTR:

2397

S = nullptr;

2398

break;

2399

2400

case STMT_NULL:

2401

S = new (Context) NullStmt(Empty);

2402

break;

2403

2404

case STMT_COMPOUND:

2405

S = new (Context) CompoundStmt(Empty);

2406

break;

2407

2408

case STMT_CASE:

2409

S = new (Context) CaseStmt(Empty);

2410

break;

2411

2412

case STMT_DEFAULT:

2413

S = new (Context) DefaultStmt(Empty);

2414

break;

2415

2416

case STMT_LABEL:

2417

S = new (Context) LabelStmt(Empty);

2418

break;

2419

2420

case STMT_ATTRIBUTED:

2421

S = AttributedStmt::CreateEmpty(

2422

Context,

2423

/*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);

2424

break;

2425

2426

case STMT_IF:

2427

S = new (Context) IfStmt(Empty);

2428

break;

2429

2430

case STMT_SWITCH:

2431

S = new (Context) SwitchStmt(Empty);

2432

break;

2433

2434

case STMT_WHILE:

2435

S = new (Context) WhileStmt(Empty);

2436

break;

2437

2438

case STMT_DO:

2439

S = new (Context) DoStmt(Empty);

2440

break;

2441

2442

case STMT_FOR:

2443

S = new (Context) ForStmt(Empty);

2444

break;

2445

2446

case STMT_GOTO:

2447

S = new (Context) GotoStmt(Empty);

2448

break;

2449

2450

case STMT_INDIRECT_GOTO:

2451

S = new (Context) IndirectGotoStmt(Empty);

2452

break;

2453

2454

case STMT_CONTINUE:

2455

S = new (Context) ContinueStmt(Empty);

2456

break;

2457

2458

case STMT_BREAK:

2459

S = new (Context) BreakStmt(Empty);

2460

break;

2461

2462

case STMT_RETURN:

2463

S = new (Context) ReturnStmt(Empty);

2464

break;

2465

2466

case STMT_DECL:

2467

S = new (Context) DeclStmt(Empty);

2468

break;

2469

2470

case STMT_GCCASM:

2471

S = new (Context) GCCAsmStmt(Empty);

2472

break;

2473

2474

case STMT_MSASM:

2475

S = new (Context) MSAsmStmt(Empty);

2476

break;

2477

2478

case STMT_CAPTURED:

2479

S = CapturedStmt::CreateDeserialized(Context,

2480

Record[ASTStmtReader::NumStmtFields]);

2481

break;

2482

2483

case EXPR_PREDEFINED:

2484

S = new (Context) PredefinedExpr(Empty);

2485

break;

2486

2487

case EXPR_DECL_REF:

2488

S = DeclRefExpr::CreateEmpty(

2489

Context,

2490

/*HasQualifier=*/Record[ASTStmtReader::NumExprFields],

2491

/*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1],

2492

/*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 2],

2493

/*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?

2494

Record[ASTStmtReader::NumExprFields + 5] : 0);

2495

break;

2496

2497

case EXPR_INTEGER_LITERAL:

2498

S = IntegerLiteral::Create(Context, Empty);

2499

break;

2500

2501

case EXPR_FLOATING_LITERAL:

2502

S = FloatingLiteral::Create(Context, Empty);

2503

break;

2504

2505

case EXPR_IMAGINARY_LITERAL:

2506

S = new (Context) ImaginaryLiteral(Empty);

2507

break;

2508

2509

case EXPR_STRING_LITERAL:

2510

S = StringLiteral::CreateEmpty(Context,

2511

Record[ASTStmtReader::NumExprFields + 1]);

2512

break;

2513

2514

case EXPR_CHARACTER_LITERAL:

2515

S = new (Context) CharacterLiteral(Empty);

2516

break;

2517

2518

case EXPR_PAREN:

2519

S = new (Context) ParenExpr(Empty);

2520

break;

2521

2522

case EXPR_PAREN_LIST:

2523

S = new (Context) ParenListExpr(Empty);

2524

break;

2525

2526

case EXPR_UNARY_OPERATOR:

2527

S = new (Context) UnaryOperator(Empty);

2528

break;

2529

2530

case EXPR_OFFSETOF:

2531

S = OffsetOfExpr::CreateEmpty(Context,

2532

Record[ASTStmtReader::NumExprFields],

2533

Record[ASTStmtReader::NumExprFields + 1]);

2534

break;

2535

2536

case EXPR_SIZEOF_ALIGN_OF:

2537

S = new (Context) UnaryExprOrTypeTraitExpr(Empty);

2538

break;

2539

2540

case EXPR_ARRAY_SUBSCRIPT:

2541

S = new (Context) ArraySubscriptExpr(Empty);

2542

break;

2543

2544

case EXPR_OMP_ARRAY_SECTION:

2545

S = new (Context) OMPArraySectionExpr(Empty);

2546

break;

2547

2548

case EXPR_CALL:

2549

S = new (Context) CallExpr(Context, Stmt::CallExprClass, Empty);

2550

break;

2551

2552

case EXPR_MEMBER: {

2553

// We load everything here and fully initialize it at creation.

2554

// That way we can use MemberExpr::Create and don't have to duplicate its

2555

// logic with a MemberExpr::CreateEmpty.

2556

2557

assert(Idx == 0)((Idx == 0) ? static_cast<void> (0) : __assert_fail ("Idx == 0"
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 2557, __PRETTY_FUNCTION__));

2558

NestedNameSpecifierLoc QualifierLoc;

2559

if (Record[Idx++]) { // HasQualifier.

2560

QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);

2561

}

2562

2563

SourceLocation TemplateKWLoc;

2564

TemplateArgumentListInfo ArgInfo;

2565

bool HasTemplateKWAndArgsInfo = Record[Idx++];

2566

if (HasTemplateKWAndArgsInfo) {

2567

TemplateKWLoc = ReadSourceLocation(F, Record, Idx);

2568

unsigned NumTemplateArgs = Record[Idx++];

2569

ArgInfo.setLAngleLoc(ReadSourceLocation(F, Record, Idx));

2570

ArgInfo.setRAngleLoc(ReadSourceLocation(F, Record, Idx));

2571

for (unsigned i = 0; i != NumTemplateArgs; ++i)

2572

ArgInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Idx));

2573

}

2574

2575

bool HadMultipleCandidates = Record[Idx++];

2576

2577

NamedDecl *FoundD = ReadDeclAs<NamedDecl>(F, Record, Idx);

2578

AccessSpecifier AS = (AccessSpecifier)Record[Idx++];

2579

DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);

2580

2581

QualType T = readType(F, Record, Idx);

2582

ExprValueKind VK = static_cast<ExprValueKind>(Record[Idx++]);

2583

ExprObjectKind OK = static_cast<ExprObjectKind>(Record[Idx++]);

2584

Expr *Base = ReadSubExpr();

2585

ValueDecl *MemberD = ReadDeclAs<ValueDecl>(F, Record, Idx);

2586

SourceLocation MemberLoc = ReadSourceLocation(F, Record, Idx);

2587

DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);

2588

bool IsArrow = Record[Idx++];

2589

SourceLocation OperatorLoc = ReadSourceLocation(F, Record, Idx);

2590

2591

S = MemberExpr::Create(Context, Base, IsArrow, OperatorLoc, QualifierLoc,

2592

TemplateKWLoc, MemberD, FoundDecl, MemberNameInfo,

2593

HasTemplateKWAndArgsInfo ? &ArgInfo : nullptr, T,

2594

VK, OK);

2595

ReadDeclarationNameLoc(F, cast<MemberExpr>(S)->MemberDNLoc,

2596

MemberD->getDeclName(), Record, Idx);

2597

if (HadMultipleCandidates)

2598

cast<MemberExpr>(S)->setHadMultipleCandidates(true);

2599

break;

2600

}

2601

2602

case EXPR_BINARY_OPERATOR:

2603

S = new (Context) BinaryOperator(Empty);

2604

break;

2605

2606

case EXPR_COMPOUND_ASSIGN_OPERATOR:

2607

S = new (Context) CompoundAssignOperator(Empty);

2608

break;

2609

2610

case EXPR_CONDITIONAL_OPERATOR:

2611

S = new (Context) ConditionalOperator(Empty);

2612

break;

2613

2614

case EXPR_BINARY_CONDITIONAL_OPERATOR:

2615

S = new (Context) BinaryConditionalOperator(Empty);

2616

break;

2617

2618

case EXPR_IMPLICIT_CAST:

2619

S = ImplicitCastExpr::CreateEmpty(Context,

2620

/*PathSize*/ Record[ASTStmtReader::NumExprFields]);

2621

break;

2622

2623

case EXPR_CSTYLE_CAST:

2624

S = CStyleCastExpr::CreateEmpty(Context,

2625

/*PathSize*/ Record[ASTStmtReader::NumExprFields]);

2626

break;

2627

2628

case EXPR_COMPOUND_LITERAL:

2629

S = new (Context) CompoundLiteralExpr(Empty);

2630

break;

2631

2632

case EXPR_EXT_VECTOR_ELEMENT:

2633

S = new (Context) ExtVectorElementExpr(Empty);

2634

break;

2635

2636

case EXPR_INIT_LIST:

2637

S = new (Context) InitListExpr(Empty);

2638

break;

2639

2640

case EXPR_DESIGNATED_INIT:

2641

S = DesignatedInitExpr::CreateEmpty(Context,

2642

Record[ASTStmtReader::NumExprFields] - 1);

2643

2644

break;

2645

2646

case EXPR_DESIGNATED_INIT_UPDATE:

2647

S = new (Context) DesignatedInitUpdateExpr(Empty);

2648

break;

2649

2650

case EXPR_IMPLICIT_VALUE_INIT:

2651

S = new (Context) ImplicitValueInitExpr(Empty);

2652

break;

2653

2654

case EXPR_NO_INIT:

2655

S = new (Context) NoInitExpr(Empty);

2656

break;

2657

2658

case EXPR_VA_ARG:

2659

S = new (Context) VAArgExpr(Empty);

2660

break;

2661

2662

case EXPR_ADDR_LABEL:

2663

S = new (Context) AddrLabelExpr(Empty);

2664

break;

2665

2666

case EXPR_STMT:

2667

S = new (Context) StmtExpr(Empty);

2668

break;

2669

2670

case EXPR_CHOOSE:

2671

S = new (Context) ChooseExpr(Empty);

2672

break;

2673

2674

case EXPR_GNU_NULL:

2675

S = new (Context) GNUNullExpr(Empty);

2676

break;

2677

2678

case EXPR_SHUFFLE_VECTOR:

2679

S = new (Context) ShuffleVectorExpr(Empty);

2680

break;

2681

2682

case EXPR_CONVERT_VECTOR:

2683

S = new (Context) ConvertVectorExpr(Empty);

2684

break;

2685

2686

case EXPR_BLOCK:

2687

S = new (Context) BlockExpr(Empty);

2688

break;

2689

2690

case EXPR_GENERIC_SELECTION:

2691

S = new (Context) GenericSelectionExpr(Empty);

2692

break;

2693

2694

case EXPR_OBJC_STRING_LITERAL:

2695

S = new (Context) ObjCStringLiteral(Empty);

2696

break;

2697

case EXPR_OBJC_BOXED_EXPRESSION:

2698

S = new (Context) ObjCBoxedExpr(Empty);

2699

break;

2700

case EXPR_OBJC_ARRAY_LITERAL:

2701

S = ObjCArrayLiteral::CreateEmpty(Context,

2702

Record[ASTStmtReader::NumExprFields]);

2703

break;

2704

case EXPR_OBJC_DICTIONARY_LITERAL:

2705

S = ObjCDictionaryLiteral::CreateEmpty(Context,

2706

Record[ASTStmtReader::NumExprFields],

2707

Record[ASTStmtReader::NumExprFields + 1]);

2708

break;

2709

case EXPR_OBJC_ENCODE:

2710

S = new (Context) ObjCEncodeExpr(Empty);

2711

break;

2712

case EXPR_OBJC_SELECTOR_EXPR:

2713

S = new (Context) ObjCSelectorExpr(Empty);

2714

break;

2715

case EXPR_OBJC_PROTOCOL_EXPR:

2716

S = new (Context) ObjCProtocolExpr(Empty);

2717

break;

2718

case EXPR_OBJC_IVAR_REF_EXPR:

2719

S = new (Context) ObjCIvarRefExpr(Empty);

2720

break;

2721

case EXPR_OBJC_PROPERTY_REF_EXPR:

2722

S = new (Context) ObjCPropertyRefExpr(Empty);

2723

break;

2724

case EXPR_OBJC_SUBSCRIPT_REF_EXPR:

2725

S = new (Context) ObjCSubscriptRefExpr(Empty);

2726

break;

2727

case EXPR_OBJC_KVC_REF_EXPR:

2728

llvm_unreachable("mismatching AST file")::llvm::llvm_unreachable_internal("mismatching AST file", "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 2728);

2729

case EXPR_OBJC_MESSAGE_EXPR:

2730

S = ObjCMessageExpr::CreateEmpty(Context,

2731

Record[ASTStmtReader::NumExprFields],

2732

Record[ASTStmtReader::NumExprFields + 1]);

2733

break;

2734

case EXPR_OBJC_ISA:

2735

S = new (Context) ObjCIsaExpr(Empty);

2736

break;

2737

case EXPR_OBJC_INDIRECT_COPY_RESTORE:

2738

S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);

2739

break;

2740

case EXPR_OBJC_BRIDGED_CAST:

2741

S = new (Context) ObjCBridgedCastExpr(Empty);

2742

break;

2743

case STMT_OBJC_FOR_COLLECTION:

2744

S = new (Context) ObjCForCollectionStmt(Empty);

2745

break;

2746

case STMT_OBJC_CATCH:

2747

S = new (Context) ObjCAtCatchStmt(Empty);

2748

break;

2749

case STMT_OBJC_FINALLY:

2750

S = new (Context) ObjCAtFinallyStmt(Empty);

2751

break;

2752

case STMT_OBJC_AT_TRY:

2753

S = ObjCAtTryStmt::CreateEmpty(Context,

2754

Record[ASTStmtReader::NumStmtFields],

2755

Record[ASTStmtReader::NumStmtFields + 1]);

2756

break;

2757

case STMT_OBJC_AT_SYNCHRONIZED:

2758

S = new (Context) ObjCAtSynchronizedStmt(Empty);

2759

break;

2760

case STMT_OBJC_AT_THROW:

2761

S = new (Context) ObjCAtThrowStmt(Empty);

2762

break;

2763

case STMT_OBJC_AUTORELEASE_POOL:

2764

S = new (Context) ObjCAutoreleasePoolStmt(Empty);

2765

break;

2766

case EXPR_OBJC_BOOL_LITERAL:

2767

S = new (Context) ObjCBoolLiteralExpr(Empty);

2768

break;

2769

case STMT_SEH_LEAVE:

2770

S = new (Context) SEHLeaveStmt(Empty);

2771

break;

2772

case STMT_SEH_EXCEPT:

2773

S = new (Context) SEHExceptStmt(Empty);

2774

break;

2775

case STMT_SEH_FINALLY:

2776

S = new (Context) SEHFinallyStmt(Empty);

2777

break;

2778

case STMT_SEH_TRY:

2779

S = new (Context) SEHTryStmt(Empty);

2780

break;

2781

case STMT_CXX_CATCH:

2782

S = new (Context) CXXCatchStmt(Empty);

2783

break;

2784

2785

case STMT_CXX_TRY:

2786

S = CXXTryStmt::Create(Context, Empty,

2787

/*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]);

2788

break;

2789

2790

case STMT_CXX_FOR_RANGE:

2791

S = new (Context) CXXForRangeStmt(Empty);

2792

break;

2793

2794

case STMT_MS_DEPENDENT_EXISTS:

2795

S = new (Context) MSDependentExistsStmt(SourceLocation(), true,

2796

NestedNameSpecifierLoc(),

2797

DeclarationNameInfo(),

2798

nullptr);

2799

break;

2800

2801

case STMT_OMP_PARALLEL_DIRECTIVE:

2802

S =

2803

OMPParallelDirective::CreateEmpty(Context,

2804

Record[ASTStmtReader::NumStmtFields],

2805

Empty);

2806

break;

2807

2808

case STMT_OMP_SIMD_DIRECTIVE: {

2809

unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];

2810

unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];

2811

S = OMPSimdDirective::CreateEmpty(Context, NumClauses,

2812

CollapsedNum, Empty);

2813

break;

2814

}

2815

2816

case STMT_OMP_FOR_DIRECTIVE: {

2817

unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];

2818

unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];

2819

S = OMPForDirective::CreateEmpty(Context, NumClauses, CollapsedNum,

2820

Empty);

2821

break;

2822

}

2823

2824

case STMT_OMP_FOR_SIMD_DIRECTIVE: {

2825

unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];

2826

unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];

2827

S = OMPForSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,

2828

Empty);

2829

break;

2830

}

2831

2832

case STMT_OMP_SECTIONS_DIRECTIVE:

2833

S = OMPSectionsDirective::CreateEmpty(

2834

Context, Record[ASTStmtReader::NumStmtFields], Empty);

2835

break;

2836

2837

case STMT_OMP_SECTION_DIRECTIVE:

2838

S = OMPSectionDirective::CreateEmpty(Context, Empty);

2839

break;

2840

2841

case STMT_OMP_SINGLE_DIRECTIVE:

2842

S = OMPSingleDirective::CreateEmpty(

2843

Context, Record[ASTStmtReader::NumStmtFields], Empty);

2844

break;

2845

2846

case STMT_OMP_MASTER_DIRECTIVE:

2847

S = OMPMasterDirective::CreateEmpty(Context, Empty);

2848

break;

2849

2850

case STMT_OMP_CRITICAL_DIRECTIVE:

2851

S = OMPCriticalDirective::CreateEmpty(Context, Empty);

2852

break;

2853

2854

case STMT_OMP_PARALLEL_FOR_DIRECTIVE: {

2855

unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];

2856

unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];

2857

S = OMPParallelForDirective::CreateEmpty(Context, NumClauses,

2858

CollapsedNum, Empty);

2859

break;

2860

}

2861

2862

case STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE: {

2863

unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];

2864

unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];

2865

S = OMPParallelForSimdDirective::CreateEmpty(Context, NumClauses,

2866

CollapsedNum, Empty);

2867

break;

2868

}

2869

2870

case STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE:

2871

S = OMPParallelSectionsDirective::CreateEmpty(

2872

Context, Record[ASTStmtReader::NumStmtFields], Empty);

2873

break;

2874

2875

case STMT_OMP_TASK_DIRECTIVE:

2876

S = OMPTaskDirective::CreateEmpty(

2877

Context, Record[ASTStmtReader::NumStmtFields], Empty);

2878

break;

2879

2880

case STMT_OMP_TASKYIELD_DIRECTIVE:

2881

S = OMPTaskyieldDirective::CreateEmpty(Context, Empty);

2882

break;

2883

2884

case STMT_OMP_BARRIER_DIRECTIVE:

2885

S = OMPBarrierDirective::CreateEmpty(Context, Empty);

2886

break;

2887

2888

case STMT_OMP_TASKWAIT_DIRECTIVE:

2889

S = OMPTaskwaitDirective::CreateEmpty(Context, Empty);

2890

break;

2891

2892

case STMT_OMP_TASKGROUP_DIRECTIVE:

2893

S = OMPTaskgroupDirective::CreateEmpty(Context, Empty);

2894

break;

2895

2896

case STMT_OMP_FLUSH_DIRECTIVE:

2897

S = OMPFlushDirective::CreateEmpty(

2898

Context, Record[ASTStmtReader::NumStmtFields], Empty);

2899

break;

2900

2901

case STMT_OMP_ORDERED_DIRECTIVE:

2902

S = OMPOrderedDirective::CreateEmpty(Context, Empty);

2903

break;

2904

2905

case STMT_OMP_ATOMIC_DIRECTIVE:

2906

S = OMPAtomicDirective::CreateEmpty(

2907

Context, Record[ASTStmtReader::NumStmtFields], Empty);

2908

break;

2909

2910

case STMT_OMP_TARGET_DIRECTIVE:

2911

S = OMPTargetDirective::CreateEmpty(

2912

Context, Record[ASTStmtReader::NumStmtFields], Empty);

2913

break;

2914

2915

case STMT_OMP_TARGET_DATA_DIRECTIVE:

2916

S = OMPTargetDataDirective::CreateEmpty(

2917

Context, Record[ASTStmtReader::NumStmtFields], Empty);

2918

break;

2919

2920

case STMT_OMP_TEAMS_DIRECTIVE:

2921

S = OMPTeamsDirective::CreateEmpty(

2922

Context, Record[ASTStmtReader::NumStmtFields], Empty);

2923

break;

2924

2925

case STMT_OMP_CANCELLATION_POINT_DIRECTIVE:

2926

S = OMPCancellationPointDirective::CreateEmpty(Context, Empty);

2927

break;

2928

2929

case STMT_OMP_CANCEL_DIRECTIVE:

2930

S = OMPCancelDirective::CreateEmpty(Context, Empty);

2931

break;

2932

2933

case EXPR_CXX_OPERATOR_CALL:

2934

S = new (Context) CXXOperatorCallExpr(Context, Empty);

2935

break;

2936

2937

case EXPR_CXX_MEMBER_CALL:

2938

S = new (Context) CXXMemberCallExpr(Context, Empty);

2939

break;

2940

2941

case EXPR_CXX_CONSTRUCT:

2942

S = new (Context) CXXConstructExpr(Empty);

2943

break;

2944

2945

case EXPR_CXX_TEMPORARY_OBJECT:

2946

S = new (Context) CXXTemporaryObjectExpr(Empty);

2947

break;

2948

2949

case EXPR_CXX_STATIC_CAST:

2950

S = CXXStaticCastExpr::CreateEmpty(Context,

2951

/*PathSize*/ Record[ASTStmtReader::NumExprFields]);

2952

break;

2953

2954

case EXPR_CXX_DYNAMIC_CAST:

2955

S = CXXDynamicCastExpr::CreateEmpty(Context,

2956

/*PathSize*/ Record[ASTStmtReader::NumExprFields]);

2957

break;

2958

2959

case EXPR_CXX_REINTERPRET_CAST:

2960

S = CXXReinterpretCastExpr::CreateEmpty(Context,

2961

/*PathSize*/ Record[ASTStmtReader::NumExprFields]);

2962

break;

2963

2964

case EXPR_CXX_CONST_CAST:

2965

S = CXXConstCastExpr::CreateEmpty(Context);

2966

break;

2967

2968

case EXPR_CXX_FUNCTIONAL_CAST:

2969

S = CXXFunctionalCastExpr::CreateEmpty(Context,

2970

/*PathSize*/ Record[ASTStmtReader::NumExprFields]);

2971

break;

2972

2973

case EXPR_USER_DEFINED_LITERAL:

2974

S = new (Context) UserDefinedLiteral(Context, Empty);

2975

break;

2976

2977

case EXPR_CXX_STD_INITIALIZER_LIST:

2978

S = new (Context) CXXStdInitializerListExpr(Empty);

2979

break;

2980

2981

case EXPR_CXX_BOOL_LITERAL:

2982

S = new (Context) CXXBoolLiteralExpr(Empty);

2983

break;

2984

2985

case EXPR_CXX_NULL_PTR_LITERAL:

2986

S = new (Context) CXXNullPtrLiteralExpr(Empty);

2987

break;

2988

case EXPR_CXX_TYPEID_EXPR:

2989

S = new (Context) CXXTypeidExpr(Empty, true);

2990

break;

2991

case EXPR_CXX_TYPEID_TYPE:

2992

S = new (Context) CXXTypeidExpr(Empty, false);

2993

break;

2994

case EXPR_CXX_UUIDOF_EXPR:

2995

S = new (Context) CXXUuidofExpr(Empty, true);

2996

break;

2997

case EXPR_CXX_PROPERTY_REF_EXPR:

2998

S = new (Context) MSPropertyRefExpr(Empty);

2999

break;

3000

case EXPR_CXX_UUIDOF_TYPE:

3001

S = new (Context) CXXUuidofExpr(Empty, false);

3002

break;

3003

case EXPR_CXX_THIS:

3004

S = new (Context) CXXThisExpr(Empty);

3005

break;

3006

case EXPR_CXX_THROW:

3007

S = new (Context) CXXThrowExpr(Empty);

3008

break;

3009

case EXPR_CXX_DEFAULT_ARG: {

3010

bool HasOtherExprStored = Record[ASTStmtReader::NumExprFields];

3011

if (HasOtherExprStored) {

3012

Expr *SubExpr = ReadSubExpr();

3013

S = CXXDefaultArgExpr::Create(Context, SourceLocation(), nullptr,

3014

SubExpr);

3015

} else

3016

S = new (Context) CXXDefaultArgExpr(Empty);

3017

break;

3018

}

3019

case EXPR_CXX_DEFAULT_INIT:

3020

S = new (Context) CXXDefaultInitExpr(Empty);

3021

break;

3022

case EXPR_CXX_BIND_TEMPORARY:

3023

S = new (Context) CXXBindTemporaryExpr(Empty);

3024

break;

3025

3026

case EXPR_CXX_SCALAR_VALUE_INIT:

3027

S = new (Context) CXXScalarValueInitExpr(Empty);

3028

break;

3029

case EXPR_CXX_NEW:

3030

S = new (Context) CXXNewExpr(Empty);

3031

break;

3032

case EXPR_CXX_DELETE:

3033

S = new (Context) CXXDeleteExpr(Empty);

3034

break;

3035

case EXPR_CXX_PSEUDO_DESTRUCTOR:

3036

S = new (Context) CXXPseudoDestructorExpr(Empty);

3037

break;

3038

3039

case EXPR_EXPR_WITH_CLEANUPS:

3040

S = ExprWithCleanups::Create(Context, Empty,

3041

Record[ASTStmtReader::NumExprFields]);

3042

break;

3043

3044

case EXPR_CXX_DEPENDENT_SCOPE_MEMBER:

3045

S = CXXDependentScopeMemberExpr::CreateEmpty(Context,

3046

/*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],

3047

/*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]

3048

? Record[ASTStmtReader::NumExprFields + 1]

3049

: 0);

3050

break;

3051

3052

case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:

3053

S = DependentScopeDeclRefExpr::CreateEmpty(Context,

3054

/*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],

3055

/*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]

3056

? Record[ASTStmtReader::NumExprFields + 1]

3057

: 0);

3058

break;

3059

3060

case EXPR_CXX_UNRESOLVED_CONSTRUCT:

3061

S = CXXUnresolvedConstructExpr::CreateEmpty(Context,

3062

/*NumArgs=*/Record[ASTStmtReader::NumExprFields]);

3063

break;

3064

3065

case EXPR_CXX_UNRESOLVED_MEMBER:

3066

S = UnresolvedMemberExpr::CreateEmpty(Context,

3067

/*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],

3068

/*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]

3069

? Record[ASTStmtReader::NumExprFields + 1]

3070

: 0);

3071

break;

3072

3073

case EXPR_CXX_UNRESOLVED_LOOKUP:

3074

S = UnresolvedLookupExpr::CreateEmpty(Context,

3075

/*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],

3076

/*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]

3077

? Record[ASTStmtReader::NumExprFields + 1]

3078

: 0);

3079

break;

3080

3081

case EXPR_TYPE_TRAIT:

3082

S = TypeTraitExpr::CreateDeserialized(Context,

3083

Record[ASTStmtReader::NumExprFields]);

3084

break;

3085

3086

case EXPR_ARRAY_TYPE_TRAIT:

3087

S = new (Context) ArrayTypeTraitExpr(Empty);

3088

break;

3089

3090

case EXPR_CXX_EXPRESSION_TRAIT:

3091

S = new (Context) ExpressionTraitExpr(Empty);

3092

break;

3093

3094

case EXPR_CXX_NOEXCEPT:

3095

S = new (Context) CXXNoexceptExpr(Empty);

3096

break;

3097

3098

case EXPR_PACK_EXPANSION:

3099

S = new (Context) PackExpansionExpr(Empty);

3100

break;

3101

3102

case EXPR_SIZEOF_PACK:

3103

S = new (Context) SizeOfPackExpr(Empty);

3104

break;

3105

3106

case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM:

3107

S = new (Context) SubstNonTypeTemplateParmExpr(Empty);

3108

break;

3109

3110

case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:

3111

S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);

3112

break;

3113

3114

case EXPR_FUNCTION_PARM_PACK:

3115

S = FunctionParmPackExpr::CreateEmpty(Context,

3116

Record[ASTStmtReader::NumExprFields]);

3117

break;

3118

3119

case EXPR_MATERIALIZE_TEMPORARY:

3120

S = new (Context) MaterializeTemporaryExpr(Empty);

3121

break;

3122

3123

case EXPR_CXX_FOLD:

3124

S = new (Context) CXXFoldExpr(Empty);

3125

break;

3126

3127

case EXPR_OPAQUE_VALUE:

3128

S = new (Context) OpaqueValueExpr(Empty);

3129

break;

3130

3131

case EXPR_CUDA_KERNEL_CALL:

3132

S = new (Context) CUDAKernelCallExpr(Context, Empty);

3133

break;

3134

3135

case EXPR_ASTYPE:

3136

S = new (Context) AsTypeExpr(Empty);

3137

break;

3138

3139

case EXPR_PSEUDO_OBJECT: {

3140

unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];

3141

S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs);

3142

break;

3143

}

3144

3145

case EXPR_ATOMIC:

3146

S = new (Context) AtomicExpr(Empty);

3147

break;

3148

3149

case EXPR_LAMBDA: {

3150

unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];

3151

unsigned NumArrayIndexVars = Record[ASTStmtReader::NumExprFields + 1];

3152

S = LambdaExpr::CreateDeserialized(Context, NumCaptures,

3153

NumArrayIndexVars);

3154

break;

3155

}

3156

}

3157

3158

// We hit a STMT_STOP, so we're done with this expression.

3159

if (Finished)

3160

break;

3161

3162

++NumStatementsRead;

3163

3164

if (S && !IsStmtReference) {

3165

Reader.Visit(S);

3166

StmtEntries[Cursor.GetCurrentBitNo()] = S;

3167

}

3168

3169

3170

assert(Idx == Record.size() && "Invalid deserialization of statement")((Idx == Record.size() && "Invalid deserialization of statement"
) ? static_cast<void> (0) : __assert_fail ("Idx == Record.size() && \"Invalid deserialization of statement\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 3170, __PRETTY_FUNCTION__));

3171

StmtStack.push_back(S);

3172

}

3173

Done:

3174

assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!")((StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!"
) ? static_cast<void> (0) : __assert_fail ("StmtStack.size() > PrevNumStmts && \"Read too many sub-stmts!\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 3174, __PRETTY_FUNCTION__));

3175

assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!")((StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!"
) ? static_cast<void> (0) : __assert_fail ("StmtStack.size() == PrevNumStmts + 1 && \"Extra expressions on stack!\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn246424/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 3175, __PRETTY_FUNCTION__));

3176

return StmtStack.pop_back_val();

3177

}