1 //===-- BitcodeWriter.cpp - ClangDoc Bitcode Writer ------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "BitcodeWriter.h" 10 #include "llvm/ADT/IndexedMap.h" 11 #include <initializer_list> 12 13 namespace clang { 14 namespace doc { 15 16 // Empty SymbolID for comparison, so we don't have to construct one every time. 17 static const SymbolID EmptySID = SymbolID(); 18 19 // Since id enums are not zero-indexed, we need to transform the given id into 20 // its associated index. 21 struct BlockIdToIndexFunctor { 22 using argument_type = unsigned; 23 unsigned operator()(unsigned ID) const { return ID - BI_FIRST; } 24 }; 25 26 struct RecordIdToIndexFunctor { 27 using argument_type = unsigned; 28 unsigned operator()(unsigned ID) const { return ID - RI_FIRST; } 29 }; 30 31 using AbbrevDsc = void (*)(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev); 32 33 static void AbbrevGen(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev, 34 const std::initializer_list<llvm::BitCodeAbbrevOp> Ops) { 35 for (const auto &Op : Ops) 36 Abbrev->Add(Op); 37 } 38 39 static void BoolAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) { 40 AbbrevGen(Abbrev, 41 {// 0. Boolean 42 llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, 43 BitCodeConstants::BoolSize)}); 44 } 45 46 static void IntAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) { 47 AbbrevGen(Abbrev, 48 {// 0. Fixed-size integer 49 llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, 50 BitCodeConstants::IntSize)}); 51 } 52 53 static void SymbolIDAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) { 54 AbbrevGen(Abbrev, 55 {// 0. Fixed-size integer (length of the sha1'd USR) 56 llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, 57 BitCodeConstants::USRLengthSize), 58 // 1. Fixed-size array of Char6 (USR) 59 llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Array), 60 llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, 61 BitCodeConstants::USRBitLengthSize)}); 62 } 63 64 static void StringAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) { 65 AbbrevGen(Abbrev, 66 {// 0. Fixed-size integer (length of the following string) 67 llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, 68 BitCodeConstants::StringLengthSize), 69 // 1. The string blob 70 llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)}); 71 } 72 73 // Assumes that the file will not have more than 65535 lines. 74 static void LocationAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) { 75 AbbrevGen( 76 Abbrev, 77 {// 0. Fixed-size integer (line number) 78 llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, 79 BitCodeConstants::LineNumberSize), 80 // 1. Fixed-size integer (length of the following string (filename)) 81 llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed, 82 BitCodeConstants::StringLengthSize), 83 // 2. The string blob 84 llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)}); 85 } 86 87 struct RecordIdDsc { 88 llvm::StringRef Name; 89 AbbrevDsc Abbrev = nullptr; 90 91 RecordIdDsc() = default; 92 RecordIdDsc(llvm::StringRef Name, AbbrevDsc Abbrev) 93 : Name(Name), Abbrev(Abbrev) {} 94 95 // Is this 'description' valid? 96 operator bool() const { 97 return Abbrev != nullptr && Name.data() != nullptr && !Name.empty(); 98 } 99 }; 100 101 static const llvm::IndexedMap<llvm::StringRef, BlockIdToIndexFunctor> 102 BlockIdNameMap = []() { 103 llvm::IndexedMap<llvm::StringRef, BlockIdToIndexFunctor> BlockIdNameMap; 104 BlockIdNameMap.resize(BlockIdCount); 105 106 // There is no init-list constructor for the IndexedMap, so have to 107 // improvise 108 static const std::vector<std::pair<BlockId, const char *const>> Inits = { 109 {BI_VERSION_BLOCK_ID, "VersionBlock"}, 110 {BI_NAMESPACE_BLOCK_ID, "NamespaceBlock"}, 111 {BI_ENUM_BLOCK_ID, "EnumBlock"}, 112 {BI_TYPE_BLOCK_ID, "TypeBlock"}, 113 {BI_FIELD_TYPE_BLOCK_ID, "FieldTypeBlock"}, 114 {BI_MEMBER_TYPE_BLOCK_ID, "MemberTypeBlock"}, 115 {BI_RECORD_BLOCK_ID, "RecordBlock"}, 116 {BI_FUNCTION_BLOCK_ID, "FunctionBlock"}, 117 {BI_COMMENT_BLOCK_ID, "CommentBlock"}, 118 {BI_REFERENCE_BLOCK_ID, "ReferenceBlock"}}; 119 assert(Inits.size() == BlockIdCount); 120 for (const auto &Init : Inits) 121 BlockIdNameMap[Init.first] = Init.second; 122 assert(BlockIdNameMap.size() == BlockIdCount); 123 return BlockIdNameMap; 124 }(); 125 126 static const llvm::IndexedMap<RecordIdDsc, RecordIdToIndexFunctor> 127 RecordIdNameMap = []() { 128 llvm::IndexedMap<RecordIdDsc, RecordIdToIndexFunctor> RecordIdNameMap; 129 RecordIdNameMap.resize(RecordIdCount); 130 131 // There is no init-list constructor for the IndexedMap, so have to 132 // improvise 133 static const std::vector<std::pair<RecordId, RecordIdDsc>> Inits = { 134 {VERSION, {"Version", &IntAbbrev}}, 135 {COMMENT_KIND, {"Kind", &StringAbbrev}}, 136 {COMMENT_TEXT, {"Text", &StringAbbrev}}, 137 {COMMENT_NAME, {"Name", &StringAbbrev}}, 138 {COMMENT_DIRECTION, {"Direction", &StringAbbrev}}, 139 {COMMENT_PARAMNAME, {"ParamName", &StringAbbrev}}, 140 {COMMENT_CLOSENAME, {"CloseName", &StringAbbrev}}, 141 {COMMENT_SELFCLOSING, {"SelfClosing", &BoolAbbrev}}, 142 {COMMENT_EXPLICIT, {"Explicit", &BoolAbbrev}}, 143 {COMMENT_ATTRKEY, {"AttrKey", &StringAbbrev}}, 144 {COMMENT_ATTRVAL, {"AttrVal", &StringAbbrev}}, 145 {COMMENT_ARG, {"Arg", &StringAbbrev}}, 146 {FIELD_TYPE_NAME, {"Name", &StringAbbrev}}, 147 {MEMBER_TYPE_NAME, {"Name", &StringAbbrev}}, 148 {MEMBER_TYPE_ACCESS, {"Access", &IntAbbrev}}, 149 {NAMESPACE_USR, {"USR", &SymbolIDAbbrev}}, 150 {NAMESPACE_NAME, {"Name", &StringAbbrev}}, 151 {ENUM_USR, {"USR", &SymbolIDAbbrev}}, 152 {ENUM_NAME, {"Name", &StringAbbrev}}, 153 {ENUM_DEFLOCATION, {"DefLocation", &LocationAbbrev}}, 154 {ENUM_LOCATION, {"Location", &LocationAbbrev}}, 155 {ENUM_MEMBER, {"Member", &StringAbbrev}}, 156 {ENUM_SCOPED, {"Scoped", &BoolAbbrev}}, 157 {RECORD_USR, {"USR", &SymbolIDAbbrev}}, 158 {RECORD_NAME, {"Name", &StringAbbrev}}, 159 {RECORD_DEFLOCATION, {"DefLocation", &LocationAbbrev}}, 160 {RECORD_LOCATION, {"Location", &LocationAbbrev}}, 161 {RECORD_TAG_TYPE, {"TagType", &IntAbbrev}}, 162 {RECORD_IS_TYPE_DEF, {"IsTypeDef", &BoolAbbrev}}, 163 {FUNCTION_USR, {"USR", &SymbolIDAbbrev}}, 164 {FUNCTION_NAME, {"Name", &StringAbbrev}}, 165 {FUNCTION_DEFLOCATION, {"DefLocation", &LocationAbbrev}}, 166 {FUNCTION_LOCATION, {"Location", &LocationAbbrev}}, 167 {FUNCTION_ACCESS, {"Access", &IntAbbrev}}, 168 {FUNCTION_IS_METHOD, {"IsMethod", &BoolAbbrev}}, 169 {REFERENCE_USR, {"USR", &SymbolIDAbbrev}}, 170 {REFERENCE_NAME, {"Name", &StringAbbrev}}, 171 {REFERENCE_TYPE, {"RefType", &IntAbbrev}}, 172 {REFERENCE_FIELD, {"Field", &IntAbbrev}}}; 173 assert(Inits.size() == RecordIdCount); 174 for (const auto &Init : Inits) { 175 RecordIdNameMap[Init.first] = Init.second; 176 assert((Init.second.Name.size() + 1) <= BitCodeConstants::RecordSize); 177 } 178 assert(RecordIdNameMap.size() == RecordIdCount); 179 return RecordIdNameMap; 180 }(); 181 182 static const std::vector<std::pair<BlockId, std::vector<RecordId>>> 183 RecordsByBlock{ 184 // Version Block 185 {BI_VERSION_BLOCK_ID, {VERSION}}, 186 // Comment Block 187 {BI_COMMENT_BLOCK_ID, 188 {COMMENT_KIND, COMMENT_TEXT, COMMENT_NAME, COMMENT_DIRECTION, 189 COMMENT_PARAMNAME, COMMENT_CLOSENAME, COMMENT_SELFCLOSING, 190 COMMENT_EXPLICIT, COMMENT_ATTRKEY, COMMENT_ATTRVAL, COMMENT_ARG}}, 191 // Type Block 192 {BI_TYPE_BLOCK_ID, {}}, 193 // FieldType Block 194 {BI_FIELD_TYPE_BLOCK_ID, {FIELD_TYPE_NAME}}, 195 // MemberType Block 196 {BI_MEMBER_TYPE_BLOCK_ID, {MEMBER_TYPE_NAME, MEMBER_TYPE_ACCESS}}, 197 // Enum Block 198 {BI_ENUM_BLOCK_ID, 199 {ENUM_USR, ENUM_NAME, ENUM_DEFLOCATION, ENUM_LOCATION, ENUM_MEMBER, 200 ENUM_SCOPED}}, 201 // Namespace Block 202 {BI_NAMESPACE_BLOCK_ID, {NAMESPACE_USR, NAMESPACE_NAME}}, 203 // Record Block 204 {BI_RECORD_BLOCK_ID, 205 {RECORD_USR, RECORD_NAME, RECORD_DEFLOCATION, RECORD_LOCATION, 206 RECORD_TAG_TYPE, RECORD_IS_TYPE_DEF}}, 207 // Function Block 208 {BI_FUNCTION_BLOCK_ID, 209 {FUNCTION_USR, FUNCTION_NAME, FUNCTION_DEFLOCATION, FUNCTION_LOCATION, 210 FUNCTION_ACCESS, FUNCTION_IS_METHOD}}, 211 // Reference Block 212 {BI_REFERENCE_BLOCK_ID, 213 {REFERENCE_USR, REFERENCE_NAME, REFERENCE_TYPE, REFERENCE_FIELD}}}; 214 215 // AbbreviationMap 216 217 constexpr char BitCodeConstants::Signature[]; 218 219 void ClangDocBitcodeWriter::AbbreviationMap::add(RecordId RID, 220 unsigned AbbrevID) { 221 assert(RecordIdNameMap[RID] && "Unknown RecordId."); 222 assert(Abbrevs.find(RID) == Abbrevs.end() && "Abbreviation already added."); 223 Abbrevs[RID] = AbbrevID; 224 } 225 226 unsigned ClangDocBitcodeWriter::AbbreviationMap::get(RecordId RID) const { 227 assert(RecordIdNameMap[RID] && "Unknown RecordId."); 228 assert(Abbrevs.find(RID) != Abbrevs.end() && "Unknown abbreviation."); 229 return Abbrevs.lookup(RID); 230 } 231 232 // Validation and Overview Blocks 233 234 /// \brief Emits the magic number header to check that its the right format, 235 /// in this case, 'DOCS'. 236 void ClangDocBitcodeWriter::emitHeader() { 237 for (char C : BitCodeConstants::Signature) 238 Stream.Emit((unsigned)C, BitCodeConstants::SignatureBitSize); 239 } 240 241 void ClangDocBitcodeWriter::emitVersionBlock() { 242 StreamSubBlockGuard Block(Stream, BI_VERSION_BLOCK_ID); 243 emitRecord(VersionNumber, VERSION); 244 } 245 246 /// \brief Emits a block ID and the block name to the BLOCKINFO block. 247 void ClangDocBitcodeWriter::emitBlockID(BlockId BID) { 248 const auto &BlockIdName = BlockIdNameMap[BID]; 249 assert(BlockIdName.data() && BlockIdName.size() && "Unknown BlockId."); 250 251 Record.clear(); 252 Record.push_back(BID); 253 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record); 254 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, 255 ArrayRef<unsigned char>(BlockIdName.bytes_begin(), 256 BlockIdName.bytes_end())); 257 } 258 259 /// \brief Emits a record name to the BLOCKINFO block. 260 void ClangDocBitcodeWriter::emitRecordID(RecordId ID) { 261 assert(RecordIdNameMap[ID] && "Unknown RecordId."); 262 prepRecordData(ID); 263 Record.append(RecordIdNameMap[ID].Name.begin(), 264 RecordIdNameMap[ID].Name.end()); 265 Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record); 266 } 267 268 // Abbreviations 269 270 void ClangDocBitcodeWriter::emitAbbrev(RecordId ID, BlockId Block) { 271 assert(RecordIdNameMap[ID] && "Unknown abbreviation."); 272 auto Abbrev = std::make_shared<llvm::BitCodeAbbrev>(); 273 Abbrev->Add(llvm::BitCodeAbbrevOp(ID)); 274 RecordIdNameMap[ID].Abbrev(Abbrev); 275 Abbrevs.add(ID, Stream.EmitBlockInfoAbbrev(Block, std::move(Abbrev))); 276 } 277 278 // Records 279 280 void ClangDocBitcodeWriter::emitRecord(const SymbolID &Sym, RecordId ID) { 281 assert(RecordIdNameMap[ID] && "Unknown RecordId."); 282 assert(RecordIdNameMap[ID].Abbrev == &SymbolIDAbbrev && 283 "Abbrev type mismatch."); 284 if (!prepRecordData(ID, Sym != EmptySID)) 285 return; 286 assert(Sym.size() == 20); 287 Record.push_back(Sym.size()); 288 Record.append(Sym.begin(), Sym.end()); 289 Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record); 290 } 291 292 void ClangDocBitcodeWriter::emitRecord(llvm::StringRef Str, RecordId ID) { 293 assert(RecordIdNameMap[ID] && "Unknown RecordId."); 294 assert(RecordIdNameMap[ID].Abbrev == &StringAbbrev && 295 "Abbrev type mismatch."); 296 if (!prepRecordData(ID, !Str.empty())) 297 return; 298 assert(Str.size() < (1U << BitCodeConstants::StringLengthSize)); 299 Record.push_back(Str.size()); 300 Stream.EmitRecordWithBlob(Abbrevs.get(ID), Record, Str); 301 } 302 303 void ClangDocBitcodeWriter::emitRecord(const Location &Loc, RecordId ID) { 304 assert(RecordIdNameMap[ID] && "Unknown RecordId."); 305 assert(RecordIdNameMap[ID].Abbrev == &LocationAbbrev && 306 "Abbrev type mismatch."); 307 if (!prepRecordData(ID, true)) 308 return; 309 // FIXME: Assert that the line number is of the appropriate size. 310 Record.push_back(Loc.LineNumber); 311 assert(Loc.Filename.size() < (1U << BitCodeConstants::StringLengthSize)); 312 Record.push_back(Loc.Filename.size()); 313 Stream.EmitRecordWithBlob(Abbrevs.get(ID), Record, Loc.Filename); 314 } 315 316 void ClangDocBitcodeWriter::emitRecord(bool Val, RecordId ID) { 317 assert(RecordIdNameMap[ID] && "Unknown RecordId."); 318 assert(RecordIdNameMap[ID].Abbrev == &BoolAbbrev && "Abbrev type mismatch."); 319 if (!prepRecordData(ID, Val)) 320 return; 321 Record.push_back(Val); 322 Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record); 323 } 324 325 void ClangDocBitcodeWriter::emitRecord(int Val, RecordId ID) { 326 assert(RecordIdNameMap[ID] && "Unknown RecordId."); 327 assert(RecordIdNameMap[ID].Abbrev == &IntAbbrev && "Abbrev type mismatch."); 328 if (!prepRecordData(ID, Val)) 329 return; 330 // FIXME: Assert that the integer is of the appropriate size. 331 Record.push_back(Val); 332 Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record); 333 } 334 335 void ClangDocBitcodeWriter::emitRecord(unsigned Val, RecordId ID) { 336 assert(RecordIdNameMap[ID] && "Unknown RecordId."); 337 assert(RecordIdNameMap[ID].Abbrev == &IntAbbrev && "Abbrev type mismatch."); 338 if (!prepRecordData(ID, Val)) 339 return; 340 assert(Val < (1U << BitCodeConstants::IntSize)); 341 Record.push_back(Val); 342 Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record); 343 } 344 345 bool ClangDocBitcodeWriter::prepRecordData(RecordId ID, bool ShouldEmit) { 346 assert(RecordIdNameMap[ID] && "Unknown RecordId."); 347 if (!ShouldEmit) 348 return false; 349 Record.clear(); 350 Record.push_back(ID); 351 return true; 352 } 353 354 // BlockInfo Block 355 356 void ClangDocBitcodeWriter::emitBlockInfoBlock() { 357 Stream.EnterBlockInfoBlock(); 358 for (const auto &Block : RecordsByBlock) { 359 assert(Block.second.size() < (1U << BitCodeConstants::SubblockIDSize)); 360 emitBlockInfo(Block.first, Block.second); 361 } 362 Stream.ExitBlock(); 363 } 364 365 void ClangDocBitcodeWriter::emitBlockInfo(BlockId BID, 366 const std::vector<RecordId> &RIDs) { 367 assert(RIDs.size() < (1U << BitCodeConstants::SubblockIDSize)); 368 emitBlockID(BID); 369 for (RecordId RID : RIDs) { 370 emitRecordID(RID); 371 emitAbbrev(RID, BID); 372 } 373 } 374 375 // Block emission 376 377 void ClangDocBitcodeWriter::emitBlock(const Reference &R, FieldId Field) { 378 if (R.USR == EmptySID && R.Name.empty()) 379 return; 380 StreamSubBlockGuard Block(Stream, BI_REFERENCE_BLOCK_ID); 381 emitRecord(R.USR, REFERENCE_USR); 382 emitRecord(R.Name, REFERENCE_NAME); 383 emitRecord((unsigned)R.RefType, REFERENCE_TYPE); 384 emitRecord((unsigned)Field, REFERENCE_FIELD); 385 } 386 387 void ClangDocBitcodeWriter::emitBlock(const TypeInfo &T) { 388 StreamSubBlockGuard Block(Stream, BI_TYPE_BLOCK_ID); 389 emitBlock(T.Type, FieldId::F_type); 390 } 391 392 void ClangDocBitcodeWriter::emitBlock(const FieldTypeInfo &T) { 393 StreamSubBlockGuard Block(Stream, BI_FIELD_TYPE_BLOCK_ID); 394 emitBlock(T.Type, FieldId::F_type); 395 emitRecord(T.Name, FIELD_TYPE_NAME); 396 } 397 398 void ClangDocBitcodeWriter::emitBlock(const MemberTypeInfo &T) { 399 StreamSubBlockGuard Block(Stream, BI_MEMBER_TYPE_BLOCK_ID); 400 emitBlock(T.Type, FieldId::F_type); 401 emitRecord(T.Name, MEMBER_TYPE_NAME); 402 emitRecord(T.Access, MEMBER_TYPE_ACCESS); 403 } 404 405 void ClangDocBitcodeWriter::emitBlock(const CommentInfo &I) { 406 StreamSubBlockGuard Block(Stream, BI_COMMENT_BLOCK_ID); 407 for (const auto &L : std::vector<std::pair<llvm::StringRef, RecordId>>{ 408 {I.Kind, COMMENT_KIND}, 409 {I.Text, COMMENT_TEXT}, 410 {I.Name, COMMENT_NAME}, 411 {I.Direction, COMMENT_DIRECTION}, 412 {I.ParamName, COMMENT_PARAMNAME}, 413 {I.CloseName, COMMENT_CLOSENAME}}) 414 emitRecord(L.first, L.second); 415 emitRecord(I.SelfClosing, COMMENT_SELFCLOSING); 416 emitRecord(I.Explicit, COMMENT_EXPLICIT); 417 for (const auto &A : I.AttrKeys) 418 emitRecord(A, COMMENT_ATTRKEY); 419 for (const auto &A : I.AttrValues) 420 emitRecord(A, COMMENT_ATTRVAL); 421 for (const auto &A : I.Args) 422 emitRecord(A, COMMENT_ARG); 423 for (const auto &C : I.Children) 424 emitBlock(*C); 425 } 426 427 void ClangDocBitcodeWriter::emitBlock(const NamespaceInfo &I) { 428 StreamSubBlockGuard Block(Stream, BI_NAMESPACE_BLOCK_ID); 429 emitRecord(I.USR, NAMESPACE_USR); 430 emitRecord(I.Name, NAMESPACE_NAME); 431 for (const auto &N : I.Namespace) 432 emitBlock(N, FieldId::F_namespace); 433 for (const auto &CI : I.Description) 434 emitBlock(CI); 435 for (const auto &C : I.ChildNamespaces) 436 emitBlock(C, FieldId::F_child_namespace); 437 for (const auto &C : I.ChildRecords) 438 emitBlock(C, FieldId::F_child_record); 439 for (const auto &C : I.ChildFunctions) 440 emitBlock(C); 441 for (const auto &C : I.ChildEnums) 442 emitBlock(C); 443 } 444 445 void ClangDocBitcodeWriter::emitBlock(const EnumInfo &I) { 446 StreamSubBlockGuard Block(Stream, BI_ENUM_BLOCK_ID); 447 emitRecord(I.USR, ENUM_USR); 448 emitRecord(I.Name, ENUM_NAME); 449 for (const auto &N : I.Namespace) 450 emitBlock(N, FieldId::F_namespace); 451 for (const auto &CI : I.Description) 452 emitBlock(CI); 453 if (I.DefLoc) 454 emitRecord(I.DefLoc.getValue(), ENUM_DEFLOCATION); 455 for (const auto &L : I.Loc) 456 emitRecord(L, ENUM_LOCATION); 457 emitRecord(I.Scoped, ENUM_SCOPED); 458 for (const auto &N : I.Members) 459 emitRecord(N, ENUM_MEMBER); 460 } 461 462 void ClangDocBitcodeWriter::emitBlock(const RecordInfo &I) { 463 StreamSubBlockGuard Block(Stream, BI_RECORD_BLOCK_ID); 464 emitRecord(I.USR, RECORD_USR); 465 emitRecord(I.Name, RECORD_NAME); 466 for (const auto &N : I.Namespace) 467 emitBlock(N, FieldId::F_namespace); 468 for (const auto &CI : I.Description) 469 emitBlock(CI); 470 if (I.DefLoc) 471 emitRecord(I.DefLoc.getValue(), RECORD_DEFLOCATION); 472 for (const auto &L : I.Loc) 473 emitRecord(L, RECORD_LOCATION); 474 emitRecord(I.TagType, RECORD_TAG_TYPE); 475 emitRecord(I.IsTypeDef, RECORD_IS_TYPE_DEF); 476 for (const auto &N : I.Members) 477 emitBlock(N); 478 for (const auto &P : I.Parents) 479 emitBlock(P, FieldId::F_parent); 480 for (const auto &P : I.VirtualParents) 481 emitBlock(P, FieldId::F_vparent); 482 for (const auto &C : I.ChildRecords) 483 emitBlock(C, FieldId::F_child_record); 484 for (const auto &C : I.ChildFunctions) 485 emitBlock(C); 486 for (const auto &C : I.ChildEnums) 487 emitBlock(C); 488 } 489 490 void ClangDocBitcodeWriter::emitBlock(const FunctionInfo &I) { 491 StreamSubBlockGuard Block(Stream, BI_FUNCTION_BLOCK_ID); 492 emitRecord(I.USR, FUNCTION_USR); 493 emitRecord(I.Name, FUNCTION_NAME); 494 for (const auto &N : I.Namespace) 495 emitBlock(N, FieldId::F_namespace); 496 for (const auto &CI : I.Description) 497 emitBlock(CI); 498 emitRecord(I.IsMethod, FUNCTION_IS_METHOD); 499 if (I.DefLoc) 500 emitRecord(I.DefLoc.getValue(), FUNCTION_DEFLOCATION); 501 for (const auto &L : I.Loc) 502 emitRecord(L, FUNCTION_LOCATION); 503 emitBlock(I.Parent, FieldId::F_parent); 504 emitBlock(I.ReturnType); 505 for (const auto &N : I.Params) 506 emitBlock(N); 507 } 508 509 bool ClangDocBitcodeWriter::dispatchInfoForWrite(Info *I) { 510 switch (I->IT) { 511 case InfoType::IT_namespace: 512 emitBlock(*static_cast<clang::doc::NamespaceInfo *>(I)); 513 break; 514 case InfoType::IT_record: 515 emitBlock(*static_cast<clang::doc::RecordInfo *>(I)); 516 break; 517 case InfoType::IT_enum: 518 emitBlock(*static_cast<clang::doc::EnumInfo *>(I)); 519 break; 520 case InfoType::IT_function: 521 emitBlock(*static_cast<clang::doc::FunctionInfo *>(I)); 522 break; 523 default: 524 llvm::errs() << "Unexpected info, unable to write.\n"; 525 return true; 526 } 527 return false; 528 } 529 530 } // namespace doc 531 } // namespace clang 532