/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp

Bug Summary

File:	tools/clang/lib/Serialization/ASTReaderStmt.cpp
Location:	line 1789, 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.7~svn239931/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.7~svn239931/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.7~svn239931/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.7~svn239931/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.7~svn239931/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.7~svn239931/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.7~svn239931/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.7~svn239931/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::VisitCallExpr(CallExpr *E) {

593

VisitExpr(E);

594

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

595

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

596

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

597

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

598

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

599

}

600

601

void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {

602

VisitCallExpr(E);

603

}

604

605

void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {

606

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

607

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.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 608, __PRETTY_FUNCTION__))

608

"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.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 608, __PRETTY_FUNCTION__));

609

}

610

611

void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {

612

VisitExpr(E);

613

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

614

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

615

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

616

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

617

}

618

619

void ASTStmtReader::

620

VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {

621

VisitExpr(E);

622

E->Operand = Reader.ReadSubExpr();

623

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

624

}

625

626

void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {

627

VisitExplicitCastExpr(E);

628

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

629

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

630

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

631

}

632

633

void ASTStmtReader::VisitCastExpr(CastExpr *E) {

634

VisitExpr(E);

635

unsigned NumBaseSpecs = Record[Idx++];

636

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.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 636, __PRETTY_FUNCTION__));

637

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

638

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

639

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

640

while (NumBaseSpecs--) {

641

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

642

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

643

*BaseI++ = BaseSpec;

644

}

645

}

646

647

void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {

648

VisitExpr(E);

649

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

650

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

651

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

652

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

653

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

654

}

655

656

void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {

657

VisitBinaryOperator(E);

658

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

659

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

660

}

661

662

void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {

663

VisitExpr(E);

664

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

665

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

666

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

667

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

668

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

669

}

670

671

void

672

ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {

673

VisitExpr(E);

674

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

675

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

676

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

677

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

678

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

679

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

680

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

681

}

682

683

void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {

684

VisitCastExpr(E);

685

}

686

687

void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {

688

VisitCastExpr(E);

689

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

690

}

691

692

void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {

693

VisitExplicitCastExpr(E);

694

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

695

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

696

}

697

698

void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {

699

VisitExpr(E);

700

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

701

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

702

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

703

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

704

}

705

706

void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {

707

VisitExpr(E);

708

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

709

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

710

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

711

}

712

713

void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {

714

VisitExpr(E);

715

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

716

E->setSyntacticForm(SyntForm);

717

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

718

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

719

bool isArrayFiller = Record[Idx++];

720

Expr *filler = nullptr;

721

if (isArrayFiller) {

722

filler = Reader.ReadSubExpr();

723

E->ArrayFillerOrUnionFieldInit = filler;

724

} else

725

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

726

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

727

unsigned NumInits = Record[Idx++];

728

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

729

if (isArrayFiller) {

730

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

731

Expr *init = Reader.ReadSubExpr();

732

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

733

}

734

} else {

735

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

736

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

737

}

738

}

739

740

void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {

741

typedef DesignatedInitExpr::Designator Designator;

742

743

VisitExpr(E);

744

unsigned NumSubExprs = Record[Idx++];

745

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.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 745, __PRETTY_FUNCTION__));

746

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

747

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

748

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

749

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

750

751

SmallVector<Designator, 4> Designators;

752

while (Idx < Record.size()) {

753

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

754

case DESIG_FIELD_DECL: {

755

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

756

SourceLocation DotLoc

757

= ReadSourceLocation(Record, Idx);

758

SourceLocation FieldLoc

759

= ReadSourceLocation(Record, Idx);

760

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

761

FieldLoc));

762

Designators.back().setField(Field);

763

break;

764

}

765

766

case DESIG_FIELD_NAME: {

767

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

768

SourceLocation DotLoc

769

= ReadSourceLocation(Record, Idx);

770

SourceLocation FieldLoc

771

= ReadSourceLocation(Record, Idx);

772

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

773

break;

774

}

775

776

case DESIG_ARRAY: {

777

unsigned Index = Record[Idx++];

778

SourceLocation LBracketLoc

779

= ReadSourceLocation(Record, Idx);

780

SourceLocation RBracketLoc

781

= ReadSourceLocation(Record, Idx);

782

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

783

break;

784

}

785

786

case DESIG_ARRAY_RANGE: {

787

unsigned Index = Record[Idx++];

788

SourceLocation LBracketLoc

789

= ReadSourceLocation(Record, Idx);

790

SourceLocation EllipsisLoc

791

= ReadSourceLocation(Record, Idx);

792

SourceLocation RBracketLoc

793

= ReadSourceLocation(Record, Idx);

794

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

795

RBracketLoc));

796

break;

797

}

798

}

799

}

800

E->setDesignators(Reader.getContext(),

801

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

802

}

803

804

void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {

805

VisitExpr(E);

806

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

807

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

808

}

809

810

void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) {

811

VisitExpr(E);

812

}

813

814

void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {

815

VisitExpr(E);

816

}

817

818

void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {

819

VisitExpr(E);

820

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

821

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

822

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

823

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

824

}

825

826

void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {

827

VisitExpr(E);

828

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

829

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

830

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

831

}

832

833

void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {

834

VisitExpr(E);

835

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

836

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

837

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

838

}

839

840

void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {

841

VisitExpr(E);

842

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

843

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

844

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

845

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

846

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

847

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

848

}

849

850

void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {

851

VisitExpr(E);

852

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

853

}

854

855

void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {

856

VisitExpr(E);

857

SmallVector<Expr *, 16> Exprs;

858

unsigned NumExprs = Record[Idx++];

859

while (NumExprs--)

860

Exprs.push_back(Reader.ReadSubExpr());

861

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

862

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

863

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

864

}

865

866

void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) {

867

VisitExpr(E);

868

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

869

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

870

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

871

E->SrcExpr = Reader.ReadSubExpr();

872

}

873

874

void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {

875

VisitExpr(E);

876

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

877

}

878

879

void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {

880

VisitExpr(E);

881

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

882

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

883

E->SubExprs =

884

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

885

886

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

887

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

888

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

889

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

890

}

891

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

892

893

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

894

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

895

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

896

}

897

898

void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {

899

VisitExpr(E);

900

unsigned numSemanticExprs = Record[Idx++];

901

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.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 901, __PRETTY_FUNCTION__));

902

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

903

904

// Read the syntactic expression.

905

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

906

907

// Read all the semantic expressions.

908

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

909

Expr *subExpr = Reader.ReadSubExpr();

910

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

911

}

912

}

913

914

void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {

915

VisitExpr(E);

916

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

917

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

918

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

919

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

920

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

921

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

922

}

923

924

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

925

// Objective-C Expressions and Statements

926

927

void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {

928

VisitExpr(E);

929

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

930

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

931

}

932

933

void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {

934

VisitExpr(E);

935

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

936

E->SubExpr = Reader.ReadSubStmt();

937

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

938

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

939

}

940

941

void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {

942

VisitExpr(E);

943

unsigned NumElements = Record[Idx++];

944

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.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 944, __PRETTY_FUNCTION__));

945

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

946

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

947

Elements[I] = Reader.ReadSubExpr();

948

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

949

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

950

}

951

952

void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {

953

VisitExpr(E);

954

unsigned NumElements = Record[Idx++];

955

956

bool HasPackExpansions = Record[Idx++];

957

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.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 957, __PRETTY_FUNCTION__));

958

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

959

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

960

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

961

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

962

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

963

if (HasPackExpansions) {

964

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

965

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

966

}

967

}

968

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

969

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

970

}

971

972

void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {

973

VisitExpr(E);

974

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

975

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

976

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

977

}

978

979

void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {

980

VisitExpr(E);

981

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

982

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

983

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

984

}

985

986

void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {

987

VisitExpr(E);

988

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

989

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

990

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

991

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

992

}

993

994

void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {

995

VisitExpr(E);

996

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

997

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

998

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

999

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

1000

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

1001

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

1002

}

1003

1004

void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {

1005

VisitExpr(E);

1006

unsigned MethodRefFlags = Record[Idx++];

1007

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

1008

if (Implicit) {

1009

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

1010

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

1011

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

1012

} else {

1013

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

1014

MethodRefFlags);

1015

}

1016

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

1017

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

1018

switch (Record[Idx++]) {

1019

case 0:

1020

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

1021

break;

1022

case 1:

1023

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

1024

break;

1025

case 2:

1026

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

1027

break;

1028

}

1029

}

1030

1031

void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {

1032

VisitExpr(E);

1033

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

1034

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

1035

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

1036

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

1037

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

1038

}

1039

1040

void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {

1041

VisitExpr(E);

1042

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.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1042, __PRETTY_FUNCTION__));

1043

++Idx;

1044

unsigned NumStoredSelLocs = Record[Idx++];

1045

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

1046

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

1047

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

1048

ObjCMessageExpr::ReceiverKind Kind

1049

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

1050

switch (Kind) {

1051

case ObjCMessageExpr::Instance:

1052

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

1053

break;

1054

1055

case ObjCMessageExpr::Class:

1056

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

1057

break;

1058

1059

case ObjCMessageExpr::SuperClass:

1060

case ObjCMessageExpr::SuperInstance: {

1061

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

1062

SourceLocation SuperLoc = ReadSourceLocation(Record, Idx);

1063

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

1064

break;

1065

}

1066

}

1067

1068

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

1069

1070

if (Record[Idx++])

1071

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

1072

else

1073

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

1074

1075

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

1076

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

1077

1078

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

1079

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

1080

1081

SourceLocation *Locs = E->getStoredSelLocs();

1082

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

1083

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

1084

}

1085

1086

void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {

1087

VisitStmt(S);

1088

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

1089

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

1090

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

1091

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

1092

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

1093

}

1094

1095

void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {

1096

VisitStmt(S);

1097

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

1098

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

1099

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

1100

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

1101

}

1102

1103

void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {

1104

VisitStmt(S);

1105

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

1106

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

1107

}

1108

1109

void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {

1110

VisitStmt(S);

1111

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

1112

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

1113

}

1114

1115

void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {

1116

VisitStmt(S);

1117

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.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1117, __PRETTY_FUNCTION__));

1118

++Idx;

1119

bool HasFinally = Record[Idx++];

1120

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

1121

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

1122

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

1123

1124

if (HasFinally)

1125

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

1126

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

1127

}

1128

1129

void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {

1130

VisitStmt(S);

1131

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

1132

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

1133

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

1134

}

1135

1136

void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {

1137

VisitStmt(S);

1138

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

1139

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

1140

}

1141

1142

void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {

1143

VisitExpr(E);

1144

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

1145

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

1146

}

1147

1148

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

1149

// C++ Expressions and Statements

1150

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

1151

1152

void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {

1153

VisitStmt(S);

1154

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

1155

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

1156

S->HandlerBlock = Reader.ReadSubStmt();

1157

}

1158

1159

void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {

1160

VisitStmt(S);

1161

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.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1161, __PRETTY_FUNCTION__));

1162

++Idx;

1163

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

1164

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

1165

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

1166

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

1167

}

1168

1169

void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {

1170

VisitStmt(S);

1171

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

1172

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

1173

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

1174

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

1175

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

1176

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

1177

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

1178

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

1179

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

1180

}

1181

1182

void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {

1183

VisitStmt(S);

1184

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

1185

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

1186

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

1187

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

1188

S->SubStmt = Reader.ReadSubStmt();

1189

}

1190

1191

void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {

1192

VisitCallExpr(E);

1193

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

1194

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

1195

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

1196

}

1197

1198

void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {

1199

VisitExpr(E);

1200

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

1201

if (E->NumArgs)

1202

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

1203

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

1204

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

1205

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

1206

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

1207

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

1208

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

1209

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

1210

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

1211

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

1212

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

1213

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

1214

}

1215

1216

void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {

1217

VisitCXXConstructExpr(E);

1218

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

1219

}

1220

1221

void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {

1222

VisitExpr(E);

1223

unsigned NumCaptures = Record[Idx++];

1224

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

1225

unsigned NumArrayIndexVars = Record[Idx++];

1226

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

1227

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

1228

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

1229

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

1230

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

1231

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

1232

1233

// Read capture initializers.

1234

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

1235

CEnd = E->capture_init_end();

1236

C != CEnd; ++C)

1237

*C = Reader.ReadSubExpr();

1238

1239

// Read array capture index variables.

1240

if (NumArrayIndexVars > 0) {

1241

unsigned *ArrayIndexStarts = E->getArrayIndexStarts();

1242

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

1243

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

1244

1245

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

1246

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

1247

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

1248

}

1249

}

1250

1251

void

1252

ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {

1253

VisitExpr(E);

1254

E->SubExpr = Reader.ReadSubExpr();

1255

}

1256

1257

void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {

1258

VisitExplicitCastExpr(E);

1259

SourceRange R = ReadSourceRange(Record, Idx);

1260

E->Loc = R.getBegin();

1261

E->RParenLoc = R.getEnd();

1262

R = ReadSourceRange(Record, Idx);

1263

E->AngleBrackets = R;

1264

}

1265

1266

void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {

1267

return VisitCXXNamedCastExpr(E);

1268

}

1269

1270

void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {

1271

return VisitCXXNamedCastExpr(E);

1272

}

1273

1274

void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {

1275

return VisitCXXNamedCastExpr(E);

1276

}

1277

1278

void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {

1279

return VisitCXXNamedCastExpr(E);

1280

}

1281

1282

void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {

1283

VisitExplicitCastExpr(E);

1284

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

1285

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

1286

}

1287

1288

void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {

1289

VisitCallExpr(E);

1290

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

1291

}

1292

1293

void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {

1294

VisitExpr(E);

1295

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

1296

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

1297

}

1298

1299

void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {

1300

VisitExpr(E);

1301

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

1302

}

1303

1304

void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {

1305

VisitExpr(E);

1306

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

1307

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

1308

E->setTypeOperandSourceInfo(

1309

GetTypeSourceInfo(Record, Idx));

1310

return;

1311

}

1312

1313

// typeid(42+2)

1314

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

1315

}

1316

1317

void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {

1318

VisitExpr(E);

1319

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

1320

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

1321

}

1322

1323

void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {

1324

VisitExpr(E);

1325

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

1326

E->Op = Reader.ReadSubExpr();

1327

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

1328

}

1329

1330

void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {

1331

VisitExpr(E);

1332

1333

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.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1333, __PRETTY_FUNCTION__));

1334

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

1335

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

1336

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

1337

}

1338

1339

void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {

1340

VisitExpr(E);

1341

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

1342

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

1343

}

1344

1345

void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {

1346

VisitExpr(E);

1347

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

1348

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

1349

}

1350

1351

void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {

1352

VisitExpr(E);

1353

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

1354

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

1355

}

1356

1357

void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {

1358

VisitExpr(E);

1359

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

1360

bool isArray = Record[Idx++];

1361

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

1362

unsigned NumPlacementArgs = Record[Idx++];

1363

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

1364

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

1365

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

1366

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

1367

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

1368

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

1369

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

1370

1371

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

1372

E->StoredInitializationStyle != 0);

1373

1374

// Install all the subexpressions.

1375

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

1376

I != e; ++I)

1377

*I = Reader.ReadSubStmt();

1378

}

1379

1380

void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {

1381

VisitExpr(E);

1382

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

1383

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

1384

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

1385

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

1386

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

1387

E->Argument = Reader.ReadSubExpr();

1388

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

1389

}

1390

1391

void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {

1392

VisitExpr(E);

1393

1394

E->Base = Reader.ReadSubExpr();

1395

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

1396

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

1397

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

1398

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

1399

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

1400

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

1401

1402

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

1403

if (II)

1404

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

1405

else

1406

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

1407

}

1408

1409

void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {

1410

VisitExpr(E);

1411

1412

unsigned NumObjects = Record[Idx++];

1413

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

1414

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

1415

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

1416

1417

E->SubExpr = Reader.ReadSubExpr();

1418

}

1419

1420

void

1421

ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){

1422

VisitExpr(E);

1423

1424

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

1425

ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),

1426

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

1427

1428

E->Base = Reader.ReadSubExpr();

1429

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

1430

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

1431

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

1432

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

1433

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

1434

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

1435

}

1436

1437

void

1438

ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {

1439

VisitExpr(E);

1440

1441

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

1442

ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),

1443

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

1444

1445

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

1446

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

1447

}

1448

1449

void

1450

ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {

1451

VisitExpr(E);

1452

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.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 1452, __PRETTY_FUNCTION__));

1453

++Idx; // NumArgs;

1454

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

1455

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

1456

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

1457

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

1458

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

1459

}

1460

1461

void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {

1462

VisitExpr(E);

1463

1464

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

1465

ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),

1466

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

1467

1468

unsigned NumDecls = Record[Idx++];

1469

UnresolvedSet<8> Decls;

1470

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

1471

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

1472

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

1473

Decls.addDecl(D, AS);

1474

}

1475

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

1476

1477

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

1478

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

1479

}

1480

1481

void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {

1482

VisitOverloadExpr(E);

1483

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

1484

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

1485

E->Base = Reader.ReadSubExpr();

1486

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

1487

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

1488

}

1489

1490

void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {

1491

VisitOverloadExpr(E);

1492

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

1493

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

1494

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

1495

}

1496

1497

void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {

1498

VisitExpr(E);

1499

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

1500

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

1501

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

1502

SourceRange Range = ReadSourceRange(Record, Idx);

1503

E->Loc = Range.getBegin();

1504

E->RParenLoc = Range.getEnd();

1505

1506

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

1507

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

1508

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

1509

}

1510

1511

void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {

1512

VisitExpr(E);

1513

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

1514

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

1515

SourceRange Range = ReadSourceRange(Record, Idx);

1516

E->Loc = Range.getBegin();

1517

E->RParen = Range.getEnd();

1518

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

1519

}

1520

1521

void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {

1522

VisitExpr(E);

1523

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

1524

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

1525

SourceRange Range = ReadSourceRange(Record, Idx);

1526

E->QueriedExpression = Reader.ReadSubExpr();

1527

E->Loc = Range.getBegin();

1528

E->RParen = Range.getEnd();

1529

}

1530

1531

void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {

1532

VisitExpr(E);

1533

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

1534

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

1535

E->Operand = Reader.ReadSubExpr();

1536

}

1537

1538

void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {

1539

VisitExpr(E);

1540

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

1541

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

1542

E->Pattern = Reader.ReadSubExpr();

1543

}

1544

1545

void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {

1546

VisitExpr(E);

1547

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

1548

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

1549

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

1550

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

1551

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

1552

}

1553

1554

void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(

1555

SubstNonTypeTemplateParmExpr *E) {

1556

VisitExpr(E);

1557

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

1558

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

1559

E->Replacement = Reader.ReadSubExpr();

1560

}

1561

1562

void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(

1563

SubstNonTypeTemplateParmPackExpr *E) {

1564

VisitExpr(E);

1565

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

1566

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

1567

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

1568

return;

1569

1570

E->Arguments = ArgPack.pack_begin();

1571

E->NumArguments = ArgPack.pack_size();

1572

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

1573

}

1574

1575

void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {

1576

VisitExpr(E);

1577

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

1578

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

1579

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

1580

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

1581

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

1582

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

1583

}

1584

1585

void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {

1586

VisitExpr(E);

1587

E->State = Reader.ReadSubExpr();

1588

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

1589

unsigned ManglingNumber = Record[Idx++];

1590

E->setExtendingDecl(VD, ManglingNumber);

1591

}

1592

1593

void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {

1594

VisitExpr(E);

1595

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

1596

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

1597

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

1598

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

1599

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

1600

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

1601

}

1602

1603

void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {

1604

VisitExpr(E);

1605

E->SourceExpr = Reader.ReadSubExpr();

1606

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

1607

}

1608

1609

void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {

1610

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

1611

}

1612

1613

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

1614

// Microsoft Expressions and Statements

1615

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

1616

void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {

1617

VisitExpr(E);

1618

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

1619

E->BaseExpr = Reader.ReadSubExpr();

1620

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

1621

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

1622

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

1623

}

1624

1625

void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {

1626

VisitExpr(E);

1627

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

1628

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

1629

E->setTypeOperandSourceInfo(

1630

GetTypeSourceInfo(Record, Idx));

1631

return;

1632

}

1633

1634

// __uuidof(expr)

1635

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

1636

}

1637

1638

void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) {

1639

VisitStmt(S);

1640

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

1641

}

1642

1643

void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {

1644

VisitStmt(S);

1645

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

1646

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

1647

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

1648

}

1649

1650

void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {

1651

VisitStmt(S);

1652

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

1653

S->Block = Reader.ReadSubStmt();

1654

}

1655

1656

void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {

1657

VisitStmt(S);

1658

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

1659

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

1660

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

1661

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

1662

}

1663

1664

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

1665

// CUDA Expressions and Statements

1666

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

1667

1668

void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {

1669

VisitCallExpr(E);

1670

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

1671

}

1672

1673

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

1674

// OpenCL Expressions and Statements.

1675

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

1676

void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {

1677

VisitExpr(E);

1678

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

1679

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

1680

E->SrcExpr = Reader.ReadSubExpr();

1681

}

1682

1683

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

1684

// OpenMP Clauses.

1685

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

1686

1687

namespace clang {

1688

class OMPClauseReader : public OMPClauseVisitor<OMPClauseReader> {

1689

ASTStmtReader *Reader;

1690

ASTContext &Context;

1691

const ASTReader::RecordData &Record;

1692

unsigned &Idx;

1693

public:

1694

OMPClauseReader(ASTStmtReader *R, ASTContext &C,

1695

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

1696

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

1697

#define OPENMP_CLAUSE(Name, Class) \

1698

void Visit##Class(Class *S);

1699

#include "clang/Basic/OpenMPKinds.def"

1700

OMPClause *readClause();

1701

};

1702

}

1703

1704

OMPClause *OMPClauseReader::readClause() {

1705

OMPClause *C;

'C' declared without an initial value

→

1706

switch (Record[Idx++]) {

←

'Default' branch taken. Execution continues on line 1789

→

1707

case OMPC_if:

1708

C = new (Context) OMPIfClause();

1709

break;

1710

case OMPC_final:

1711

C = new (Context) OMPFinalClause();

1712

break;

1713

case OMPC_num_threads:

1714

C = new (Context) OMPNumThreadsClause();

1715

break;

1716

case OMPC_safelen:

1717

C = new (Context) OMPSafelenClause();

1718

break;

1719

case OMPC_collapse:

1720

C = new (Context) OMPCollapseClause();

1721

break;

1722

case OMPC_default:

1723

C = new (Context) OMPDefaultClause();

1724

break;

1725

case OMPC_proc_bind:

1726

C = new (Context) OMPProcBindClause();

1727

break;

1728

case OMPC_schedule:

1729

C = new (Context) OMPScheduleClause();

1730

break;

1731

case OMPC_ordered:

1732

C = new (Context) OMPOrderedClause();

1733

break;

1734

case OMPC_nowait:

1735

C = new (Context) OMPNowaitClause();

1736

break;

1737

case OMPC_untied:

1738

C = new (Context) OMPUntiedClause();

1739

break;

1740

case OMPC_mergeable:

1741

C = new (Context) OMPMergeableClause();

1742

break;

1743

case OMPC_read:

1744

C = new (Context) OMPReadClause();

1745

break;

1746

case OMPC_write:

1747

C = new (Context) OMPWriteClause();

1748

break;

1749

case OMPC_update:

1750

C = new (Context) OMPUpdateClause();

1751

break;

1752

case OMPC_capture:

1753

C = new (Context) OMPCaptureClause();

1754

break;

1755

case OMPC_seq_cst:

1756

C = new (Context) OMPSeqCstClause();

1757

break;

1758

case OMPC_private:

1759

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

1760

break;

1761

case OMPC_firstprivate:

1762

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

1763

break;

1764

case OMPC_lastprivate:

1765

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

1766

break;

1767

case OMPC_shared:

1768

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

1769

break;

1770

case OMPC_reduction:

1771

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

1772

break;

1773

case OMPC_linear:

1774

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

1775

break;

1776

case OMPC_aligned:

1777

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

1778

break;

1779

case OMPC_copyin:

1780

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

1781

break;

1782

case OMPC_copyprivate:

1783

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

1784

break;

1785

case OMPC_flush:

1786

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

1787

break;

1788

}

1789

Visit(C);

←

Function call argument is an uninitialized value

1790

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

1791

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

1792

1793

return C;

1794

}

1795

1796

void OMPClauseReader::VisitOMPIfClause(OMPIfClause *C) {

1797

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

1798

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

1799

}

1800

1801

void OMPClauseReader::VisitOMPFinalClause(OMPFinalClause *C) {

1802

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

1803

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

1804

}

1805

1806

void OMPClauseReader::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {

1807

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

1808

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

1809

}

1810

1811

void OMPClauseReader::VisitOMPSafelenClause(OMPSafelenClause *C) {

1812

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

1813

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

1814

}

1815

1816

void OMPClauseReader::VisitOMPCollapseClause(OMPCollapseClause *C) {

1817

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

1818

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

1819

}

1820

1821

void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) {

1822

C->setDefaultKind(

1823

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

1824

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

1825

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

1826

}

1827

1828

void OMPClauseReader::VisitOMPProcBindClause(OMPProcBindClause *C) {

1829

C->setProcBindKind(

1830

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

1831

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

1832

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

1833

}

1834

1835

void OMPClauseReader::VisitOMPScheduleClause(OMPScheduleClause *C) {

1836

C->setScheduleKind(

1837

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

1838

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

1839

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

1840

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

1841

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

1842

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

1843

}

1844

1845

void OMPClauseReader::VisitOMPOrderedClause(OMPOrderedClause *) {}

1846

1847

void OMPClauseReader::VisitOMPNowaitClause(OMPNowaitClause *) {}

1848

1849

void OMPClauseReader::VisitOMPUntiedClause(OMPUntiedClause *) {}

1850

1851

void OMPClauseReader::VisitOMPMergeableClause(OMPMergeableClause *) {}

1852

1853

void OMPClauseReader::VisitOMPReadClause(OMPReadClause *) {}

1854

1855

void OMPClauseReader::VisitOMPWriteClause(OMPWriteClause *) {}

1856

1857

void OMPClauseReader::VisitOMPUpdateClause(OMPUpdateClause *) {}

1858

1859

void OMPClauseReader::VisitOMPCaptureClause(OMPCaptureClause *) {}

1860

1861

void OMPClauseReader::VisitOMPSeqCstClause(OMPSeqCstClause *) {}

1862

1863

void OMPClauseReader::VisitOMPPrivateClause(OMPPrivateClause *C) {

1864

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

1865

unsigned NumVars = C->varlist_size();

1866

SmallVector<Expr *, 16> Vars;

1867

Vars.reserve(NumVars);

1868

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

1869

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

1870

C->setVarRefs(Vars);

1871

Vars.clear();

1872

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

1873

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

1874

C->setPrivateCopies(Vars);

1875

}

1876

1877

void OMPClauseReader::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {

1878

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

1879

unsigned NumVars = C->varlist_size();

1880

SmallVector<Expr *, 16> Vars;

1881

Vars.reserve(NumVars);

1882

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

1883

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

1884

C->setVarRefs(Vars);

1885

Vars.clear();

1886

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

1887

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

1888

C->setPrivateCopies(Vars);

1889

Vars.clear();

1890

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

1891

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

1892

C->setInits(Vars);

1893

}

1894

1895

void OMPClauseReader::VisitOMPLastprivateClause(OMPLastprivateClause *C) {

1896

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

1897

unsigned NumVars = C->varlist_size();

1898

SmallVector<Expr *, 16> Vars;

1899

Vars.reserve(NumVars);

1900

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

1901

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

1902

C->setVarRefs(Vars);

1903

Vars.clear();

1904

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

1905

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

1906

C->setPrivateCopies(Vars);

1907

Vars.clear();

1908

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

1909

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

1910

C->setSourceExprs(Vars);

1911

Vars.clear();

1912

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

1913

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

1914

C->setDestinationExprs(Vars);

1915

Vars.clear();

1916

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

1917

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

1918

C->setAssignmentOps(Vars);

1919

}

1920

1921

void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *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

}

1930

1931

void OMPClauseReader::VisitOMPReductionClause(OMPReductionClause *C) {

1932

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

1933

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

1934

NestedNameSpecifierLoc NNSL =

1935

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

1936

DeclarationNameInfo DNI;

1937

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

1938

C->setQualifierLoc(NNSL);

1939

C->setNameInfo(DNI);

1940

1941

unsigned NumVars = C->varlist_size();

1942

SmallVector<Expr *, 16> Vars;

1943

Vars.reserve(NumVars);

1944

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

1945

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

1946

C->setVarRefs(Vars);

1947

Vars.clear();

1948

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

1949

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

1950

C->setLHSExprs(Vars);

1951

Vars.clear();

1952

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

1953

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

1954

C->setRHSExprs(Vars);

1955

Vars.clear();

1956

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

1957

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

1958

C->setReductionOps(Vars);

1959

}

1960

1961

void OMPClauseReader::VisitOMPLinearClause(OMPLinearClause *C) {

1962

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

1963

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

1964

unsigned NumVars = C->varlist_size();

1965

SmallVector<Expr *, 16> Vars;

1966

Vars.reserve(NumVars);

1967

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

1968

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

1969

C->setVarRefs(Vars);

1970

Vars.clear();

1971

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

1972

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

1973

C->setInits(Vars);

1974

Vars.clear();

1975

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

1976

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

1977

C->setUpdates(Vars);

1978

Vars.clear();

1979

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

1980

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

1981

C->setFinals(Vars);

1982

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

1983

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

1984

}

1985

1986

void OMPClauseReader::VisitOMPAlignedClause(OMPAlignedClause *C) {

1987

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

1988

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

1989

unsigned NumVars = C->varlist_size();

1990

SmallVector<Expr *, 16> Vars;

1991

Vars.reserve(NumVars);

1992

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

1993

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

1994

C->setVarRefs(Vars);

1995

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

1996

}

1997

1998

void OMPClauseReader::VisitOMPCopyinClause(OMPCopyinClause *C) {

1999

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

2000

unsigned NumVars = C->varlist_size();

2001

SmallVector<Expr *, 16> Exprs;

2002

Exprs.reserve(NumVars);

2003

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

2004

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

2005

C->setVarRefs(Exprs);

2006

Exprs.clear();

2007

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

2008

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

2009

C->setSourceExprs(Exprs);

2010

Exprs.clear();

2011

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

2012

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

2013

C->setDestinationExprs(Exprs);

2014

Exprs.clear();

2015

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

2016

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

2017

C->setAssignmentOps(Exprs);

2018

}

2019

2020

void OMPClauseReader::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) {

2021

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

2022

unsigned NumVars = C->varlist_size();

2023

SmallVector<Expr *, 16> Exprs;

2024

Exprs.reserve(NumVars);

2025

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

2026

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

2027

C->setVarRefs(Exprs);

2028

Exprs.clear();

2029

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

2030

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

2031

C->setSourceExprs(Exprs);

2032

Exprs.clear();

2033

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

2034

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

2035

C->setDestinationExprs(Exprs);

2036

Exprs.clear();

2037

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

2038

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

2039

C->setAssignmentOps(Exprs);

2040

}

2041

2042

void OMPClauseReader::VisitOMPFlushClause(OMPFlushClause *C) {

2043

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

2044

unsigned NumVars = C->varlist_size();

2045

SmallVector<Expr *, 16> Vars;

2046

Vars.reserve(NumVars);

2047

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

2048

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

2049

C->setVarRefs(Vars);

2050

}

2051

2052

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

2053

// OpenMP Directives.

2054

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

2055

void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {

2056

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

2057

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

2058

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

2059

SmallVector<OMPClause *, 5> Clauses;

2060

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

2061

Clauses.push_back(ClauseReader.readClause());

2062

E->setClauses(Clauses);

2063

if (E->hasAssociatedStmt())

2064

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

2065

}

2066

2067

void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) {

2068

VisitStmt(D);

2069

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

2070

Idx += 2;

2071

VisitOMPExecutableDirective(D);

2072

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

2073

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

2074

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

2075

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

2076

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

2077

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

2078

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

2079

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

2080

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

2081

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

2082

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

2083

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

2084

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

2085

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

2086

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

2087

}

2088

SmallVector<Expr *, 4> Sub;

2089

unsigned CollapsedNum = D->getCollapsedNumber();

2090

Sub.reserve(CollapsedNum);

2091

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

2092

Sub.push_back(Reader.ReadSubExpr());

2093

D->setCounters(Sub);

2094

Sub.clear();

2095

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

2096

Sub.push_back(Reader.ReadSubExpr());

2097

D->setUpdates(Sub);

2098

Sub.clear();

2099

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

2100

Sub.push_back(Reader.ReadSubExpr());

2101

D->setFinals(Sub);

2102

}

2103

2104

void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {

2105

VisitStmt(D);

2106

// The NumClauses field was read in ReadStmtFromStream.

2107

++Idx;

2108

VisitOMPExecutableDirective(D);

2109

}

2110

2111

void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {

2112

VisitOMPLoopDirective(D);

2113

}

2114

2115

void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) {

2116

VisitOMPLoopDirective(D);

2117

}

2118

2119

void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) {

2120

VisitOMPLoopDirective(D);

2121

}

2122

2123

void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) {

2124

VisitStmt(D);

2125

// The NumClauses field was read in ReadStmtFromStream.

2126

++Idx;

2127

VisitOMPExecutableDirective(D);

2128

}

2129

2130

void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {

2131

VisitStmt(D);

2132

VisitOMPExecutableDirective(D);

2133

}

2134

2135

void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) {

2136

VisitStmt(D);

2137

// The NumClauses field was read in ReadStmtFromStream.

2138

++Idx;

2139

VisitOMPExecutableDirective(D);

2140

}

2141

2142

void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) {

2143

VisitStmt(D);

2144

VisitOMPExecutableDirective(D);

2145

}

2146

2147

void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) {

2148

VisitStmt(D);

2149

VisitOMPExecutableDirective(D);

2150

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

2151

}

2152

2153

void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) {

2154

VisitOMPLoopDirective(D);

2155

}

2156

2157

void ASTStmtReader::VisitOMPParallelForSimdDirective(

2158

OMPParallelForSimdDirective *D) {

2159

VisitOMPLoopDirective(D);

2160

}

2161

2162

void ASTStmtReader::VisitOMPParallelSectionsDirective(

2163

OMPParallelSectionsDirective *D) {

2164

VisitStmt(D);

2165

// The NumClauses field was read in ReadStmtFromStream.

2166

++Idx;

2167

VisitOMPExecutableDirective(D);

2168

}

2169

2170

void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) {

2171

VisitStmt(D);

2172

// The NumClauses field was read in ReadStmtFromStream.

2173

++Idx;

2174

VisitOMPExecutableDirective(D);

2175

}

2176

2177

void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {

2178

VisitStmt(D);

2179

VisitOMPExecutableDirective(D);

2180

}

2181

2182

void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) {

2183

VisitStmt(D);

2184

VisitOMPExecutableDirective(D);

2185

}

2186

2187

void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {

2188

VisitStmt(D);

2189

VisitOMPExecutableDirective(D);

2190

}

2191

2192

void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) {

2193

VisitStmt(D);

2194

// The NumClauses field was read in ReadStmtFromStream.

2195

++Idx;

2196

VisitOMPExecutableDirective(D);

2197

}

2198

2199

void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) {

2200

VisitStmt(D);

2201

VisitOMPExecutableDirective(D);

2202

}

2203

2204

void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) {

2205

VisitStmt(D);

2206

// The NumClauses field was read in ReadStmtFromStream.

2207

++Idx;

2208

VisitOMPExecutableDirective(D);

2209

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

2210

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

2211

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

2212

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

2213

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

2214

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

2215

}

2216

2217

void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {

2218

VisitStmt(D);

2219

// The NumClauses field was read in ReadStmtFromStream.

2220

++Idx;

2221

VisitOMPExecutableDirective(D);

2222

}

2223

2224

void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) {

2225

VisitStmt(D);

2226

// The NumClauses field was read in ReadStmtFromStream.

2227

++Idx;

2228

VisitOMPExecutableDirective(D);

2229

}

2230

2231

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

2232

// ASTReader Implementation

2233

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

2234

2235

Stmt *ASTReader::ReadStmt(ModuleFile &F) {

2236

switch (ReadingKind) {

2237

case Read_None:

2238

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.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 2238);

2239

case Read_Decl:

2240

case Read_Type:

2241

return ReadStmtFromStream(F);

2242

case Read_Stmt:

2243

return ReadSubStmt();

2244

}

2245

2246

llvm_unreachable("ReadingKind not set ?")::llvm::llvm_unreachable_internal("ReadingKind not set ?", "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 2246);

2247

}

2248

2249

Expr *ASTReader::ReadExpr(ModuleFile &F) {

2250

return cast_or_null<Expr>(ReadStmt(F));

2251

}

2252

2253

Expr *ASTReader::ReadSubExpr() {

2254

return cast_or_null<Expr>(ReadSubStmt());

2255

}

2256

2257

// Within the bitstream, expressions are stored in Reverse Polish

2258

// Notation, with each of the subexpressions preceding the

2259

// expression they are stored in. Subexpressions are stored from last to first.

2260

// To evaluate expressions, we continue reading expressions and placing them on

2261

// the stack, with expressions having operands removing those operands from the

2262

// stack. Evaluation terminates when we see a STMT_STOP record, and

2263

// the single remaining expression on the stack is our result.

2264

Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {

2265

2266

ReadingKindTracker ReadingKind(Read_Stmt, *this);

2267

llvm::BitstreamCursor &Cursor = F.DeclsCursor;

2268

2269

// Map of offset to previously deserialized stmt. The offset points

2270

/// just after the stmt record.

2271

llvm::DenseMap<uint64_t, Stmt *> StmtEntries;

2272

2273

#ifndef NDEBUG

2274

unsigned PrevNumStmts = StmtStack.size();

2275

#endif

2276

2277

RecordData Record;

2278

unsigned Idx;

2279

ASTStmtReader Reader(*this, F, Cursor, Record, Idx);

2280

Stmt::EmptyShell Empty;

2281

2282

while (true) {

2283

llvm::BitstreamEntry Entry = Cursor.advanceSkippingSubblocks();

2284

2285

switch (Entry.Kind) {

2286

case llvm::BitstreamEntry::SubBlock: // Handled for us already.

2287

case llvm::BitstreamEntry::Error:

2288

Error("malformed block record in AST file");

2289

return nullptr;

2290

case llvm::BitstreamEntry::EndBlock:

2291

goto Done;

2292

case llvm::BitstreamEntry::Record:

2293

// The interesting case.

2294

break;

2295

}

2296

2297

Stmt *S = nullptr;

2298

Idx = 0;

2299

Record.clear();

2300

bool Finished = false;

2301

bool IsStmtReference = false;

2302

switch ((StmtCode)Cursor.readRecord(Entry.ID, Record)) {

2303

case STMT_STOP:

2304

Finished = true;

2305

break;

2306

2307

case STMT_REF_PTR:

2308

IsStmtReference = true;

2309

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.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 2310, __PRETTY_FUNCTION__))

2310

"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.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 2310, __PRETTY_FUNCTION__));

2311

S = StmtEntries[Record[Idx++]];

2312

break;

2313

2314

case STMT_NULL_PTR:

2315

S = nullptr;

2316

break;

2317

2318

case STMT_NULL:

2319

S = new (Context) NullStmt(Empty);

2320

break;

2321

2322

case STMT_COMPOUND:

2323

S = new (Context) CompoundStmt(Empty);

2324

break;

2325

2326

case STMT_CASE:

2327

S = new (Context) CaseStmt(Empty);

2328

break;

2329

2330

case STMT_DEFAULT:

2331

S = new (Context) DefaultStmt(Empty);

2332

break;

2333

2334

case STMT_LABEL:

2335

S = new (Context) LabelStmt(Empty);

2336

break;

2337

2338

case STMT_ATTRIBUTED:

2339

S = AttributedStmt::CreateEmpty(

2340

Context,

2341

/*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);

2342

break;

2343

2344

case STMT_IF:

2345

S = new (Context) IfStmt(Empty);

2346

break;

2347

2348

case STMT_SWITCH:

2349

S = new (Context) SwitchStmt(Empty);

2350

break;

2351

2352

case STMT_WHILE:

2353

S = new (Context) WhileStmt(Empty);

2354

break;

2355

2356

case STMT_DO:

2357

S = new (Context) DoStmt(Empty);

2358

break;

2359

2360

case STMT_FOR:

2361

S = new (Context) ForStmt(Empty);

2362

break;

2363

2364

case STMT_GOTO:

2365

S = new (Context) GotoStmt(Empty);

2366

break;

2367

2368

case STMT_INDIRECT_GOTO:

2369

S = new (Context) IndirectGotoStmt(Empty);

2370

break;

2371

2372

case STMT_CONTINUE:

2373

S = new (Context) ContinueStmt(Empty);

2374

break;

2375

2376

case STMT_BREAK:

2377

S = new (Context) BreakStmt(Empty);

2378

break;

2379

2380

case STMT_RETURN:

2381

S = new (Context) ReturnStmt(Empty);

2382

break;

2383

2384

case STMT_DECL:

2385

S = new (Context) DeclStmt(Empty);

2386

break;

2387

2388

case STMT_GCCASM:

2389

S = new (Context) GCCAsmStmt(Empty);

2390

break;

2391

2392

case STMT_MSASM:

2393

S = new (Context) MSAsmStmt(Empty);

2394

break;

2395

2396

case STMT_CAPTURED:

2397

S = CapturedStmt::CreateDeserialized(Context,

2398

Record[ASTStmtReader::NumStmtFields]);

2399

break;

2400

2401

case EXPR_PREDEFINED:

2402

S = new (Context) PredefinedExpr(Empty);

2403

break;

2404

2405

case EXPR_DECL_REF:

2406

S = DeclRefExpr::CreateEmpty(

2407

Context,

2408

/*HasQualifier=*/Record[ASTStmtReader::NumExprFields],

2409

/*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1],

2410

/*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 2],

2411

/*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?

2412

Record[ASTStmtReader::NumExprFields + 5] : 0);

2413

break;

2414

2415

case EXPR_INTEGER_LITERAL:

2416

S = IntegerLiteral::Create(Context, Empty);

2417

break;

2418

2419

case EXPR_FLOATING_LITERAL:

2420

S = FloatingLiteral::Create(Context, Empty);

2421

break;

2422

2423

case EXPR_IMAGINARY_LITERAL:

2424

S = new (Context) ImaginaryLiteral(Empty);

2425

break;

2426

2427

case EXPR_STRING_LITERAL:

2428

S = StringLiteral::CreateEmpty(Context,

2429

Record[ASTStmtReader::NumExprFields + 1]);

2430

break;

2431

2432

case EXPR_CHARACTER_LITERAL:

2433

S = new (Context) CharacterLiteral(Empty);

2434

break;

2435

2436

case EXPR_PAREN:

2437

S = new (Context) ParenExpr(Empty);

2438

break;

2439

2440

case EXPR_PAREN_LIST:

2441

S = new (Context) ParenListExpr(Empty);

2442

break;

2443

2444

case EXPR_UNARY_OPERATOR:

2445

S = new (Context) UnaryOperator(Empty);

2446

break;

2447

2448

case EXPR_OFFSETOF:

2449

S = OffsetOfExpr::CreateEmpty(Context,

2450

Record[ASTStmtReader::NumExprFields],

2451

Record[ASTStmtReader::NumExprFields + 1]);

2452

break;

2453

2454

case EXPR_SIZEOF_ALIGN_OF:

2455

S = new (Context) UnaryExprOrTypeTraitExpr(Empty);

2456

break;

2457

2458

case EXPR_ARRAY_SUBSCRIPT:

2459

S = new (Context) ArraySubscriptExpr(Empty);

2460

break;

2461

2462

case EXPR_CALL:

2463

S = new (Context) CallExpr(Context, Stmt::CallExprClass, Empty);

2464

break;

2465

2466

case EXPR_MEMBER: {

2467

// We load everything here and fully initialize it at creation.

2468

// That way we can use MemberExpr::Create and don't have to duplicate its

2469

// logic with a MemberExpr::CreateEmpty.

2470

2471

assert(Idx == 0)((Idx == 0) ? static_cast<void> (0) : __assert_fail ("Idx == 0"
, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 2471, __PRETTY_FUNCTION__));

2472

NestedNameSpecifierLoc QualifierLoc;

2473

if (Record[Idx++]) { // HasQualifier.

2474

QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);

2475

}

2476

2477

SourceLocation TemplateKWLoc;

2478

TemplateArgumentListInfo ArgInfo;

2479

bool HasTemplateKWAndArgsInfo = Record[Idx++];

2480

if (HasTemplateKWAndArgsInfo) {

2481

TemplateKWLoc = ReadSourceLocation(F, Record, Idx);

2482

unsigned NumTemplateArgs = Record[Idx++];

2483

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

2484

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

2485

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

2486

ArgInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Idx));

2487

}

2488

2489

bool HadMultipleCandidates = Record[Idx++];

2490

2491

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

2492

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

2493

DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);

2494

2495

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

2496

ExprValueKind VK = static_cast<ExprValueKind>(Record[Idx++]);

2497

ExprObjectKind OK = static_cast<ExprObjectKind>(Record[Idx++]);

2498

Expr *Base = ReadSubExpr();

2499

ValueDecl *MemberD = ReadDeclAs<ValueDecl>(F, Record, Idx);

2500

SourceLocation MemberLoc = ReadSourceLocation(F, Record, Idx);

2501

DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);

2502

bool IsArrow = Record[Idx++];

2503

SourceLocation OperatorLoc = ReadSourceLocation(F, Record, Idx);

2504

2505

S = MemberExpr::Create(Context, Base, IsArrow, OperatorLoc, QualifierLoc,

2506

TemplateKWLoc, MemberD, FoundDecl, MemberNameInfo,

2507

HasTemplateKWAndArgsInfo ? &ArgInfo : nullptr, T,

2508

VK, OK);

2509

ReadDeclarationNameLoc(F, cast<MemberExpr>(S)->MemberDNLoc,

2510

MemberD->getDeclName(), Record, Idx);

2511

if (HadMultipleCandidates)

2512

cast<MemberExpr>(S)->setHadMultipleCandidates(true);

2513

break;

2514

}

2515

2516

case EXPR_BINARY_OPERATOR:

2517

S = new (Context) BinaryOperator(Empty);

2518

break;

2519

2520

case EXPR_COMPOUND_ASSIGN_OPERATOR:

2521

S = new (Context) CompoundAssignOperator(Empty);

2522

break;

2523

2524

case EXPR_CONDITIONAL_OPERATOR:

2525

S = new (Context) ConditionalOperator(Empty);

2526

break;

2527

2528

case EXPR_BINARY_CONDITIONAL_OPERATOR:

2529

S = new (Context) BinaryConditionalOperator(Empty);

2530

break;

2531

2532

case EXPR_IMPLICIT_CAST:

2533

S = ImplicitCastExpr::CreateEmpty(Context,

2534

/*PathSize*/ Record[ASTStmtReader::NumExprFields]);

2535

break;

2536

2537

case EXPR_CSTYLE_CAST:

2538

S = CStyleCastExpr::CreateEmpty(Context,

2539

/*PathSize*/ Record[ASTStmtReader::NumExprFields]);

2540

break;

2541

2542

case EXPR_COMPOUND_LITERAL:

2543

S = new (Context) CompoundLiteralExpr(Empty);

2544

break;

2545

2546

case EXPR_EXT_VECTOR_ELEMENT:

2547

S = new (Context) ExtVectorElementExpr(Empty);

2548

break;

2549

2550

case EXPR_INIT_LIST:

2551

S = new (Context) InitListExpr(Empty);

2552

break;

2553

2554

case EXPR_DESIGNATED_INIT:

2555

S = DesignatedInitExpr::CreateEmpty(Context,

2556

Record[ASTStmtReader::NumExprFields] - 1);

2557

2558

break;

2559

2560

case EXPR_DESIGNATED_INIT_UPDATE:

2561

S = new (Context) DesignatedInitUpdateExpr(Empty);

2562

break;

2563

2564

case EXPR_IMPLICIT_VALUE_INIT:

2565

S = new (Context) ImplicitValueInitExpr(Empty);

2566

break;

2567

2568

case EXPR_NO_INIT:

2569

S = new (Context) NoInitExpr(Empty);

2570

break;

2571

2572

case EXPR_VA_ARG:

2573

S = new (Context) VAArgExpr(Empty);

2574

break;

2575

2576

case EXPR_ADDR_LABEL:

2577

S = new (Context) AddrLabelExpr(Empty);

2578

break;

2579

2580

case EXPR_STMT:

2581

S = new (Context) StmtExpr(Empty);

2582

break;

2583

2584

case EXPR_CHOOSE:

2585

S = new (Context) ChooseExpr(Empty);

2586

break;

2587

2588

case EXPR_GNU_NULL:

2589

S = new (Context) GNUNullExpr(Empty);

2590

break;

2591

2592

case EXPR_SHUFFLE_VECTOR:

2593

S = new (Context) ShuffleVectorExpr(Empty);

2594

break;

2595

2596

case EXPR_CONVERT_VECTOR:

2597

S = new (Context) ConvertVectorExpr(Empty);

2598

break;

2599

2600

case EXPR_BLOCK:

2601

S = new (Context) BlockExpr(Empty);

2602

break;

2603

2604

case EXPR_GENERIC_SELECTION:

2605

S = new (Context) GenericSelectionExpr(Empty);

2606

break;

2607

2608

case EXPR_OBJC_STRING_LITERAL:

2609

S = new (Context) ObjCStringLiteral(Empty);

2610

break;

2611

case EXPR_OBJC_BOXED_EXPRESSION:

2612

S = new (Context) ObjCBoxedExpr(Empty);

2613

break;

2614

case EXPR_OBJC_ARRAY_LITERAL:

2615

S = ObjCArrayLiteral::CreateEmpty(Context,

2616

Record[ASTStmtReader::NumExprFields]);

2617

break;

2618

case EXPR_OBJC_DICTIONARY_LITERAL:

2619

S = ObjCDictionaryLiteral::CreateEmpty(Context,

2620

Record[ASTStmtReader::NumExprFields],

2621

Record[ASTStmtReader::NumExprFields + 1]);

2622

break;

2623

case EXPR_OBJC_ENCODE:

2624

S = new (Context) ObjCEncodeExpr(Empty);

2625

break;

2626

case EXPR_OBJC_SELECTOR_EXPR:

2627

S = new (Context) ObjCSelectorExpr(Empty);

2628

break;

2629

case EXPR_OBJC_PROTOCOL_EXPR:

2630

S = new (Context) ObjCProtocolExpr(Empty);

2631

break;

2632

case EXPR_OBJC_IVAR_REF_EXPR:

2633

S = new (Context) ObjCIvarRefExpr(Empty);

2634

break;

2635

case EXPR_OBJC_PROPERTY_REF_EXPR:

2636

S = new (Context) ObjCPropertyRefExpr(Empty);

2637

break;

2638

case EXPR_OBJC_SUBSCRIPT_REF_EXPR:

2639

S = new (Context) ObjCSubscriptRefExpr(Empty);

2640

break;

2641

case EXPR_OBJC_KVC_REF_EXPR:

2642

llvm_unreachable("mismatching AST file")::llvm::llvm_unreachable_internal("mismatching AST file", "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 2642);

2643

case EXPR_OBJC_MESSAGE_EXPR:

2644

S = ObjCMessageExpr::CreateEmpty(Context,

2645

Record[ASTStmtReader::NumExprFields],

2646

Record[ASTStmtReader::NumExprFields + 1]);

2647

break;

2648

case EXPR_OBJC_ISA:

2649

S = new (Context) ObjCIsaExpr(Empty);

2650

break;

2651

case EXPR_OBJC_INDIRECT_COPY_RESTORE:

2652

S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);

2653

break;

2654

case EXPR_OBJC_BRIDGED_CAST:

2655

S = new (Context) ObjCBridgedCastExpr(Empty);

2656

break;

2657

case STMT_OBJC_FOR_COLLECTION:

2658

S = new (Context) ObjCForCollectionStmt(Empty);

2659

break;

2660

case STMT_OBJC_CATCH:

2661

S = new (Context) ObjCAtCatchStmt(Empty);

2662

break;

2663

case STMT_OBJC_FINALLY:

2664

S = new (Context) ObjCAtFinallyStmt(Empty);

2665

break;

2666

case STMT_OBJC_AT_TRY:

2667

S = ObjCAtTryStmt::CreateEmpty(Context,

2668

Record[ASTStmtReader::NumStmtFields],

2669

Record[ASTStmtReader::NumStmtFields + 1]);

2670

break;

2671

case STMT_OBJC_AT_SYNCHRONIZED:

2672

S = new (Context) ObjCAtSynchronizedStmt(Empty);

2673

break;

2674

case STMT_OBJC_AT_THROW:

2675

S = new (Context) ObjCAtThrowStmt(Empty);

2676

break;

2677

case STMT_OBJC_AUTORELEASE_POOL:

2678

S = new (Context) ObjCAutoreleasePoolStmt(Empty);

2679

break;

2680

case EXPR_OBJC_BOOL_LITERAL:

2681

S = new (Context) ObjCBoolLiteralExpr(Empty);

2682

break;

2683

case STMT_SEH_LEAVE:

2684

S = new (Context) SEHLeaveStmt(Empty);

2685

break;

2686

case STMT_SEH_EXCEPT:

2687

S = new (Context) SEHExceptStmt(Empty);

2688

break;

2689

case STMT_SEH_FINALLY:

2690

S = new (Context) SEHFinallyStmt(Empty);

2691

break;

2692

case STMT_SEH_TRY:

2693

S = new (Context) SEHTryStmt(Empty);

2694

break;

2695

case STMT_CXX_CATCH:

2696

S = new (Context) CXXCatchStmt(Empty);

2697

break;

2698

2699

case STMT_CXX_TRY:

2700

S = CXXTryStmt::Create(Context, Empty,

2701

/*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]);

2702

break;

2703

2704

case STMT_CXX_FOR_RANGE:

2705

S = new (Context) CXXForRangeStmt(Empty);

2706

break;

2707

2708

case STMT_MS_DEPENDENT_EXISTS:

2709

S = new (Context) MSDependentExistsStmt(SourceLocation(), true,

2710

NestedNameSpecifierLoc(),

2711

DeclarationNameInfo(),

2712

nullptr);

2713

break;

2714

2715

case STMT_OMP_PARALLEL_DIRECTIVE:

2716

S =

2717

OMPParallelDirective::CreateEmpty(Context,

2718

Record[ASTStmtReader::NumStmtFields],

2719

Empty);

2720

break;

2721

2722

case STMT_OMP_SIMD_DIRECTIVE: {

2723

unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];

2724

unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];

2725

S = OMPSimdDirective::CreateEmpty(Context, NumClauses,

2726

CollapsedNum, Empty);

2727

break;

2728

}

2729

2730

case STMT_OMP_FOR_DIRECTIVE: {

2731

unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];

2732

unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];

2733

S = OMPForDirective::CreateEmpty(Context, NumClauses, CollapsedNum,

2734

Empty);

2735

break;

2736

}

2737

2738

case STMT_OMP_FOR_SIMD_DIRECTIVE: {

2739

unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];

2740

unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];

2741

S = OMPForSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,

2742

Empty);

2743

break;

2744

}

2745

2746

case STMT_OMP_SECTIONS_DIRECTIVE:

2747

S = OMPSectionsDirective::CreateEmpty(

2748

Context, Record[ASTStmtReader::NumStmtFields], Empty);

2749

break;

2750

2751

case STMT_OMP_SECTION_DIRECTIVE:

2752

S = OMPSectionDirective::CreateEmpty(Context, Empty);

2753

break;

2754

2755

case STMT_OMP_SINGLE_DIRECTIVE:

2756

S = OMPSingleDirective::CreateEmpty(

2757

Context, Record[ASTStmtReader::NumStmtFields], Empty);

2758

break;

2759

2760

case STMT_OMP_MASTER_DIRECTIVE:

2761

S = OMPMasterDirective::CreateEmpty(Context, Empty);

2762

break;

2763

2764

case STMT_OMP_CRITICAL_DIRECTIVE:

2765

S = OMPCriticalDirective::CreateEmpty(Context, Empty);

2766

break;

2767

2768

case STMT_OMP_PARALLEL_FOR_DIRECTIVE: {

2769

unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];

2770

unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];

2771

S = OMPParallelForDirective::CreateEmpty(Context, NumClauses,

2772

CollapsedNum, Empty);

2773

break;

2774

}

2775

2776

case STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE: {

2777

unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];

2778

unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];

2779

S = OMPParallelForSimdDirective::CreateEmpty(Context, NumClauses,

2780

CollapsedNum, Empty);

2781

break;

2782

}

2783

2784

case STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE:

2785

S = OMPParallelSectionsDirective::CreateEmpty(

2786

Context, Record[ASTStmtReader::NumStmtFields], Empty);

2787

break;

2788

2789

case STMT_OMP_TASK_DIRECTIVE:

2790

S = OMPTaskDirective::CreateEmpty(

2791

Context, Record[ASTStmtReader::NumStmtFields], Empty);

2792

break;

2793

2794

case STMT_OMP_TASKYIELD_DIRECTIVE:

2795

S = OMPTaskyieldDirective::CreateEmpty(Context, Empty);

2796

break;

2797

2798

case STMT_OMP_BARRIER_DIRECTIVE:

2799

S = OMPBarrierDirective::CreateEmpty(Context, Empty);

2800

break;

2801

2802

case STMT_OMP_TASKWAIT_DIRECTIVE:

2803

S = OMPTaskwaitDirective::CreateEmpty(Context, Empty);

2804

break;

2805

2806

case STMT_OMP_FLUSH_DIRECTIVE:

2807

S = OMPFlushDirective::CreateEmpty(

2808

Context, Record[ASTStmtReader::NumStmtFields], Empty);

2809

break;

2810

2811

case STMT_OMP_ORDERED_DIRECTIVE:

2812

S = OMPOrderedDirective::CreateEmpty(Context, Empty);

2813

break;

2814

2815

case STMT_OMP_ATOMIC_DIRECTIVE:

2816

S = OMPAtomicDirective::CreateEmpty(

2817

Context, Record[ASTStmtReader::NumStmtFields], Empty);

2818

break;

2819

2820

case STMT_OMP_TARGET_DIRECTIVE:

2821

S = OMPTargetDirective::CreateEmpty(

2822

Context, Record[ASTStmtReader::NumStmtFields], Empty);

2823

break;

2824

2825

case STMT_OMP_TEAMS_DIRECTIVE:

2826

S = OMPTeamsDirective::CreateEmpty(

2827

Context, Record[ASTStmtReader::NumStmtFields], Empty);

2828

break;

2829

2830

case EXPR_CXX_OPERATOR_CALL:

2831

S = new (Context) CXXOperatorCallExpr(Context, Empty);

2832

break;

2833

2834

case EXPR_CXX_MEMBER_CALL:

2835

S = new (Context) CXXMemberCallExpr(Context, Empty);

2836

break;

2837

2838

case EXPR_CXX_CONSTRUCT:

2839

S = new (Context) CXXConstructExpr(Empty);

2840

break;

2841

2842

case EXPR_CXX_TEMPORARY_OBJECT:

2843

S = new (Context) CXXTemporaryObjectExpr(Empty);

2844

break;

2845

2846

case EXPR_CXX_STATIC_CAST:

2847

S = CXXStaticCastExpr::CreateEmpty(Context,

2848

/*PathSize*/ Record[ASTStmtReader::NumExprFields]);

2849

break;

2850

2851

case EXPR_CXX_DYNAMIC_CAST:

2852

S = CXXDynamicCastExpr::CreateEmpty(Context,

2853

/*PathSize*/ Record[ASTStmtReader::NumExprFields]);

2854

break;

2855

2856

case EXPR_CXX_REINTERPRET_CAST:

2857

S = CXXReinterpretCastExpr::CreateEmpty(Context,

2858

/*PathSize*/ Record[ASTStmtReader::NumExprFields]);

2859

break;

2860

2861

case EXPR_CXX_CONST_CAST:

2862

S = CXXConstCastExpr::CreateEmpty(Context);

2863

break;

2864

2865

case EXPR_CXX_FUNCTIONAL_CAST:

2866

S = CXXFunctionalCastExpr::CreateEmpty(Context,

2867

/*PathSize*/ Record[ASTStmtReader::NumExprFields]);

2868

break;

2869

2870

case EXPR_USER_DEFINED_LITERAL:

2871

S = new (Context) UserDefinedLiteral(Context, Empty);

2872

break;

2873

2874

case EXPR_CXX_STD_INITIALIZER_LIST:

2875

S = new (Context) CXXStdInitializerListExpr(Empty);

2876

break;

2877

2878

case EXPR_CXX_BOOL_LITERAL:

2879

S = new (Context) CXXBoolLiteralExpr(Empty);

2880

break;

2881

2882

case EXPR_CXX_NULL_PTR_LITERAL:

2883

S = new (Context) CXXNullPtrLiteralExpr(Empty);

2884

break;

2885

case EXPR_CXX_TYPEID_EXPR:

2886

S = new (Context) CXXTypeidExpr(Empty, true);

2887

break;

2888

case EXPR_CXX_TYPEID_TYPE:

2889

S = new (Context) CXXTypeidExpr(Empty, false);

2890

break;

2891

case EXPR_CXX_UUIDOF_EXPR:

2892

S = new (Context) CXXUuidofExpr(Empty, true);

2893

break;

2894

case EXPR_CXX_PROPERTY_REF_EXPR:

2895

S = new (Context) MSPropertyRefExpr(Empty);

2896

break;

2897

case EXPR_CXX_UUIDOF_TYPE:

2898

S = new (Context) CXXUuidofExpr(Empty, false);

2899

break;

2900

case EXPR_CXX_THIS:

2901

S = new (Context) CXXThisExpr(Empty);

2902

break;

2903

case EXPR_CXX_THROW:

2904

S = new (Context) CXXThrowExpr(Empty);

2905

break;

2906

case EXPR_CXX_DEFAULT_ARG: {

2907

bool HasOtherExprStored = Record[ASTStmtReader::NumExprFields];

2908

if (HasOtherExprStored) {

2909

Expr *SubExpr = ReadSubExpr();

2910

S = CXXDefaultArgExpr::Create(Context, SourceLocation(), nullptr,

2911

SubExpr);

2912

} else

2913

S = new (Context) CXXDefaultArgExpr(Empty);

2914

break;

2915

}

2916

case EXPR_CXX_DEFAULT_INIT:

2917

S = new (Context) CXXDefaultInitExpr(Empty);

2918

break;

2919

case EXPR_CXX_BIND_TEMPORARY:

2920

S = new (Context) CXXBindTemporaryExpr(Empty);

2921

break;

2922

2923

case EXPR_CXX_SCALAR_VALUE_INIT:

2924

S = new (Context) CXXScalarValueInitExpr(Empty);

2925

break;

2926

case EXPR_CXX_NEW:

2927

S = new (Context) CXXNewExpr(Empty);

2928

break;

2929

case EXPR_CXX_DELETE:

2930

S = new (Context) CXXDeleteExpr(Empty);

2931

break;

2932

case EXPR_CXX_PSEUDO_DESTRUCTOR:

2933

S = new (Context) CXXPseudoDestructorExpr(Empty);

2934

break;

2935

2936

case EXPR_EXPR_WITH_CLEANUPS:

2937

S = ExprWithCleanups::Create(Context, Empty,

2938

Record[ASTStmtReader::NumExprFields]);

2939

break;

2940

2941

case EXPR_CXX_DEPENDENT_SCOPE_MEMBER:

2942

S = CXXDependentScopeMemberExpr::CreateEmpty(Context,

2943

/*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],

2944

/*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]

2945

? Record[ASTStmtReader::NumExprFields + 1]

2946

: 0);

2947

break;

2948

2949

case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:

2950

S = DependentScopeDeclRefExpr::CreateEmpty(Context,

2951

/*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],

2952

/*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]

2953

? Record[ASTStmtReader::NumExprFields + 1]

2954

: 0);

2955

break;

2956

2957

case EXPR_CXX_UNRESOLVED_CONSTRUCT:

2958

S = CXXUnresolvedConstructExpr::CreateEmpty(Context,

2959

/*NumArgs=*/Record[ASTStmtReader::NumExprFields]);

2960

break;

2961

2962

case EXPR_CXX_UNRESOLVED_MEMBER:

2963

S = UnresolvedMemberExpr::CreateEmpty(Context,

2964

/*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],

2965

/*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]

2966

? Record[ASTStmtReader::NumExprFields + 1]

2967

: 0);

2968

break;

2969

2970

case EXPR_CXX_UNRESOLVED_LOOKUP:

2971

S = UnresolvedLookupExpr::CreateEmpty(Context,

2972

/*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],

2973

/*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]

2974

? Record[ASTStmtReader::NumExprFields + 1]

2975

: 0);

2976

break;

2977

2978

case EXPR_TYPE_TRAIT:

2979

S = TypeTraitExpr::CreateDeserialized(Context,

2980

Record[ASTStmtReader::NumExprFields]);

2981

break;

2982

2983

case EXPR_ARRAY_TYPE_TRAIT:

2984

S = new (Context) ArrayTypeTraitExpr(Empty);

2985

break;

2986

2987

case EXPR_CXX_EXPRESSION_TRAIT:

2988

S = new (Context) ExpressionTraitExpr(Empty);

2989

break;

2990

2991

case EXPR_CXX_NOEXCEPT:

2992

S = new (Context) CXXNoexceptExpr(Empty);

2993

break;

2994

2995

case EXPR_PACK_EXPANSION:

2996

S = new (Context) PackExpansionExpr(Empty);

2997

break;

2998

2999

case EXPR_SIZEOF_PACK:

3000

S = new (Context) SizeOfPackExpr(Empty);

3001

break;

3002

3003

case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM:

3004

S = new (Context) SubstNonTypeTemplateParmExpr(Empty);

3005

break;

3006

3007

case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:

3008

S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);

3009

break;

3010

3011

case EXPR_FUNCTION_PARM_PACK:

3012

S = FunctionParmPackExpr::CreateEmpty(Context,

3013

Record[ASTStmtReader::NumExprFields]);

3014

break;

3015

3016

case EXPR_MATERIALIZE_TEMPORARY:

3017

S = new (Context) MaterializeTemporaryExpr(Empty);

3018

break;

3019

3020

case EXPR_CXX_FOLD:

3021

S = new (Context) CXXFoldExpr(Empty);

3022

break;

3023

3024

case EXPR_OPAQUE_VALUE:

3025

S = new (Context) OpaqueValueExpr(Empty);

3026

break;

3027

3028

case EXPR_CUDA_KERNEL_CALL:

3029

S = new (Context) CUDAKernelCallExpr(Context, Empty);

3030

break;

3031

3032

case EXPR_ASTYPE:

3033

S = new (Context) AsTypeExpr(Empty);

3034

break;

3035

3036

case EXPR_PSEUDO_OBJECT: {

3037

unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];

3038

S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs);

3039

break;

3040

}

3041

3042

case EXPR_ATOMIC:

3043

S = new (Context) AtomicExpr(Empty);

3044

break;

3045

3046

case EXPR_LAMBDA: {

3047

unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];

3048

unsigned NumArrayIndexVars = Record[ASTStmtReader::NumExprFields + 1];

3049

S = LambdaExpr::CreateDeserialized(Context, NumCaptures,

3050

NumArrayIndexVars);

3051

break;

3052

}

3053

}

3054

3055

// We hit a STMT_STOP, so we're done with this expression.

3056

if (Finished)

3057

break;

3058

3059

++NumStatementsRead;

3060

3061

if (S && !IsStmtReference) {

3062

Reader.Visit(S);

3063

StmtEntries[Cursor.GetCurrentBitNo()] = S;

3064

}

3065

3066

3067

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.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 3067, __PRETTY_FUNCTION__));

3068

StmtStack.push_back(S);

3069

}

3070

Done:

3071

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.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 3071, __PRETTY_FUNCTION__));

3072

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.7~svn239931/tools/clang/lib/Serialization/ASTReaderStmt.cpp"
, 3072, __PRETTY_FUNCTION__));

3073

return StmtStack.pop_back_val();

3074

}