Deleted Added
sdiff udiff text old ( 198892 ) new ( 201360 )
full compact
BitcodeWriter.cpp (198892) BitcodeWriter.cpp (201360)
1//===--- Bitcode/Writer/BitcodeWriter.cpp - Bitcode Writer ----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//

--- 5 unchanged lines hidden (view full) ---

14#include "llvm/Bitcode/ReaderWriter.h"
15#include "llvm/Bitcode/BitstreamWriter.h"
16#include "llvm/Bitcode/LLVMBitCodes.h"
17#include "ValueEnumerator.h"
18#include "llvm/Constants.h"
19#include "llvm/DerivedTypes.h"
20#include "llvm/InlineAsm.h"
21#include "llvm/Instructions.h"
1//===--- Bitcode/Writer/BitcodeWriter.cpp - Bitcode Writer ----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//

--- 5 unchanged lines hidden (view full) ---

14#include "llvm/Bitcode/ReaderWriter.h"
15#include "llvm/Bitcode/BitstreamWriter.h"
16#include "llvm/Bitcode/LLVMBitCodes.h"
17#include "ValueEnumerator.h"
18#include "llvm/Constants.h"
19#include "llvm/DerivedTypes.h"
20#include "llvm/InlineAsm.h"
21#include "llvm/Instructions.h"
22#include "llvm/LLVMContext.h"
23#include "llvm/Metadata.h"
24#include "llvm/Module.h"
25#include "llvm/Operator.h"
26#include "llvm/TypeSymbolTable.h"
27#include "llvm/ValueSymbolTable.h"
28#include "llvm/Support/ErrorHandling.h"
29#include "llvm/Support/MathExtras.h"
30#include "llvm/Support/raw_ostream.h"
31#include "llvm/System/Program.h"

--- 440 unchanged lines hidden (view full) ---

472
473 return Flags;
474}
475
476static void WriteMDNode(const MDNode *N,
477 const ValueEnumerator &VE,
478 BitstreamWriter &Stream,
479 SmallVector<uint64_t, 64> &Record) {
22#include "llvm/Module.h"
23#include "llvm/Operator.h"
24#include "llvm/TypeSymbolTable.h"
25#include "llvm/ValueSymbolTable.h"
26#include "llvm/Support/ErrorHandling.h"
27#include "llvm/Support/MathExtras.h"
28#include "llvm/Support/raw_ostream.h"
29#include "llvm/System/Program.h"

--- 440 unchanged lines hidden (view full) ---

470
471 return Flags;
472}
473
474static void WriteMDNode(const MDNode *N,
475 const ValueEnumerator &VE,
476 BitstreamWriter &Stream,
477 SmallVector<uint64_t, 64> &Record) {
480 for (unsigned i = 0, e = N->getNumElements(); i != e; ++i) {
481 if (N->getElement(i)) {
482 Record.push_back(VE.getTypeID(N->getElement(i)->getType()));
483 Record.push_back(VE.getValueID(N->getElement(i)));
478 for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
479 if (N->getOperand(i)) {
480 Record.push_back(VE.getTypeID(N->getOperand(i)->getType()));
481 Record.push_back(VE.getValueID(N->getOperand(i)));
484 } else {
485 Record.push_back(VE.getTypeID(Type::getVoidTy(N->getContext())));
486 Record.push_back(0);
487 }
488 }
489 Stream.EmitRecord(bitc::METADATA_NODE, Record, 0);
490 Record.clear();
491}

--- 40 unchanged lines hidden (view full) ---

532 // Write name.
533 std::string Str = NMD->getNameStr();
534 const char *StrBegin = Str.c_str();
535 for (unsigned i = 0, e = Str.length(); i != e; ++i)
536 Record.push_back(StrBegin[i]);
537 Stream.EmitRecord(bitc::METADATA_NAME, Record, 0/*TODO*/);
538 Record.clear();
539
482 } else {
483 Record.push_back(VE.getTypeID(Type::getVoidTy(N->getContext())));
484 Record.push_back(0);
485 }
486 }
487 Stream.EmitRecord(bitc::METADATA_NODE, Record, 0);
488 Record.clear();
489}

--- 40 unchanged lines hidden (view full) ---

530 // Write name.
531 std::string Str = NMD->getNameStr();
532 const char *StrBegin = Str.c_str();
533 for (unsigned i = 0, e = Str.length(); i != e; ++i)
534 Record.push_back(StrBegin[i]);
535 Stream.EmitRecord(bitc::METADATA_NAME, Record, 0/*TODO*/);
536 Record.clear();
537
540 // Write named metadata elements.
541 for (unsigned i = 0, e = NMD->getNumElements(); i != e; ++i) {
542 if (NMD->getElement(i))
543 Record.push_back(VE.getValueID(NMD->getElement(i)));
538 // Write named metadata operands.
539 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
540 if (NMD->getOperand(i))
541 Record.push_back(VE.getValueID(NMD->getOperand(i)));
544 else
545 Record.push_back(0);
546 }
547 Stream.EmitRecord(bitc::METADATA_NAMED_NODE, Record, 0);
548 Record.clear();
549 }
550 }
551

--- 4 unchanged lines hidden (view full) ---

556static void WriteMetadataAttachment(const Function &F,
557 const ValueEnumerator &VE,
558 BitstreamWriter &Stream) {
559 bool StartedMetadataBlock = false;
560 SmallVector<uint64_t, 64> Record;
561
562 // Write metadata attachments
563 // METADATA_ATTACHMENT - [m x [value, [n x [id, mdnode]]]
542 else
543 Record.push_back(0);
544 }
545 Stream.EmitRecord(bitc::METADATA_NAMED_NODE, Record, 0);
546 Record.clear();
547 }
548 }
549

--- 4 unchanged lines hidden (view full) ---

554static void WriteMetadataAttachment(const Function &F,
555 const ValueEnumerator &VE,
556 BitstreamWriter &Stream) {
557 bool StartedMetadataBlock = false;
558 SmallVector<uint64_t, 64> Record;
559
560 // Write metadata attachments
561 // METADATA_ATTACHMENT - [m x [value, [n x [id, mdnode]]]
564 MetadataContext &TheMetadata = F.getContext().getMetadata();
565 typedef SmallVector<std::pair<unsigned, TrackingVH<MDNode> >, 2> MDMapTy;
566 MDMapTy MDs;
562 SmallVector<std::pair<unsigned, MDNode*>, 4> MDs;
563
567 for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
568 for (BasicBlock::const_iterator I = BB->begin(), E = BB->end();
569 I != E; ++I) {
570 MDs.clear();
564 for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
565 for (BasicBlock::const_iterator I = BB->begin(), E = BB->end();
566 I != E; ++I) {
567 MDs.clear();
571 TheMetadata.getMDs(I, MDs);
572 bool RecordedInstruction = false;
573 for (MDMapTy::const_iterator PI = MDs.begin(), PE = MDs.end();
574 PI != PE; ++PI) {
575 if (RecordedInstruction == false) {
576 Record.push_back(VE.getInstructionID(I));
577 RecordedInstruction = true;
578 }
579 Record.push_back(PI->first);
580 Record.push_back(VE.getValueID(PI->second));
568 I->getAllMetadata(MDs);
569
570 // If no metadata, ignore instruction.
571 if (MDs.empty()) continue;
572
573 Record.push_back(VE.getInstructionID(I));
574
575 for (unsigned i = 0, e = MDs.size(); i != e; ++i) {
576 Record.push_back(MDs[i].first);
577 Record.push_back(VE.getValueID(MDs[i].second));
581 }
578 }
582 if (!Record.empty()) {
583 if (!StartedMetadataBlock) {
584 Stream.EnterSubblock(bitc::METADATA_ATTACHMENT_ID, 3);
585 StartedMetadataBlock = true;
586 }
587 Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0);
588 Record.clear();
579 if (!StartedMetadataBlock) {
580 Stream.EnterSubblock(bitc::METADATA_ATTACHMENT_ID, 3);
581 StartedMetadataBlock = true;
589 }
582 }
583 Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0);
584 Record.clear();
590 }
591
592 if (StartedMetadataBlock)
593 Stream.ExitBlock();
594}
595
585 }
586
587 if (StartedMetadataBlock)
588 Stream.ExitBlock();
589}
590
596static void WriteModuleMetadataStore(const Module *M,
597 const ValueEnumerator &VE,
598 BitstreamWriter &Stream) {
599
600 bool StartedMetadataBlock = false;
591static void WriteModuleMetadataStore(const Module *M, BitstreamWriter &Stream) {
601 SmallVector<uint64_t, 64> Record;
602
603 // Write metadata kinds
604 // METADATA_KIND - [n x [id, name]]
592 SmallVector<uint64_t, 64> Record;
593
594 // Write metadata kinds
595 // METADATA_KIND - [n x [id, name]]
605 MetadataContext &TheMetadata = M->getContext().getMetadata();
606 SmallVector<std::pair<unsigned, StringRef>, 4> Names;
607 TheMetadata.getHandlerNames(Names);
608 for (SmallVector<std::pair<unsigned, StringRef>, 4>::iterator
609 I = Names.begin(),
610 E = Names.end(); I != E; ++I) {
611 Record.push_back(I->first);
612 StringRef KName = I->second;
613 for (unsigned i = 0, e = KName.size(); i != e; ++i)
614 Record.push_back(KName[i]);
615 if (!StartedMetadataBlock) {
616 Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
617 StartedMetadataBlock = true;
618 }
596 SmallVector<StringRef, 4> Names;
597 M->getMDKindNames(Names);
598
599 assert(Names[0] == "" && "MDKind #0 is invalid");
600 if (Names.size() == 1) return;
601
602 Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
603
604 for (unsigned MDKindID = 1, e = Names.size(); MDKindID != e; ++MDKindID) {
605 Record.push_back(MDKindID);
606 StringRef KName = Names[MDKindID];
607 Record.append(KName.begin(), KName.end());
608
619 Stream.EmitRecord(bitc::METADATA_KIND, Record, 0);
620 Record.clear();
621 }
622
609 Stream.EmitRecord(bitc::METADATA_KIND, Record, 0);
610 Record.clear();
611 }
612
623 if (StartedMetadataBlock)
624 Stream.ExitBlock();
613 Stream.ExitBlock();
625}
626
627static void WriteConstants(unsigned FirstVal, unsigned LastVal,
628 const ValueEnumerator &VE,
629 BitstreamWriter &Stream, bool isGlobal) {
630 if (FirstVal == LastVal) return;
631
632 Stream.EnterSubblock(bitc::CONSTANTS_BLOCK_ID, 4);

--- 575 unchanged lines hidden (view full) ---

1208 // Keep a running idea of what the instruction ID is.
1209 unsigned InstID = CstEnd;
1210
1211 // Finally, emit all the instructions, in order.
1212 for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
1213 for (BasicBlock::const_iterator I = BB->begin(), E = BB->end();
1214 I != E; ++I) {
1215 WriteInstruction(*I, InstID, VE, Stream, Vals);
614}
615
616static void WriteConstants(unsigned FirstVal, unsigned LastVal,
617 const ValueEnumerator &VE,
618 BitstreamWriter &Stream, bool isGlobal) {
619 if (FirstVal == LastVal) return;
620
621 Stream.EnterSubblock(bitc::CONSTANTS_BLOCK_ID, 4);

--- 575 unchanged lines hidden (view full) ---

1197 // Keep a running idea of what the instruction ID is.
1198 unsigned InstID = CstEnd;
1199
1200 // Finally, emit all the instructions, in order.
1201 for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
1202 for (BasicBlock::const_iterator I = BB->begin(), E = BB->end();
1203 I != E; ++I) {
1204 WriteInstruction(*I, InstID, VE, Stream, Vals);
1216 if (I->getType() != Type::getVoidTy(F.getContext()))
1205 if (!I->getType()->isVoidTy())
1217 ++InstID;
1218 }
1219
1220 // Emit names for all the instructions etc.
1221 WriteValueSymbolTable(F.getValueSymbolTable(), VE, Stream);
1222
1223 WriteMetadataAttachment(F, VE, Stream);
1224 VE.purgeFunction();

--- 236 unchanged lines hidden (view full) ---

1461 WriteModuleMetadata(VE, Stream);
1462
1463 // Emit function bodies.
1464 for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
1465 if (!I->isDeclaration())
1466 WriteFunction(*I, VE, Stream);
1467
1468 // Emit metadata.
1206 ++InstID;
1207 }
1208
1209 // Emit names for all the instructions etc.
1210 WriteValueSymbolTable(F.getValueSymbolTable(), VE, Stream);
1211
1212 WriteMetadataAttachment(F, VE, Stream);
1213 VE.purgeFunction();

--- 236 unchanged lines hidden (view full) ---

1450 WriteModuleMetadata(VE, Stream);
1451
1452 // Emit function bodies.
1453 for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
1454 if (!I->isDeclaration())
1455 WriteFunction(*I, VE, Stream);
1456
1457 // Emit metadata.
1469 WriteModuleMetadataStore(M, VE, Stream);
1458 WriteModuleMetadataStore(M, Stream);
1470
1471 // Emit the type symbol table information.
1472 WriteTypeSymbolTable(M->getTypeSymbolTable(), VE, Stream);
1473
1474 // Emit names for globals/functions etc.
1475 WriteValueSymbolTable(M->getValueSymbolTable(), VE, Stream);
1476
1477 Stream.ExitBlock();

--- 110 unchanged lines hidden --- 		1459
1460 // Emit the type symbol table information.
1461 WriteTypeSymbolTable(M->getTypeSymbolTable(), VE, Stream);
1462
1463 // Emit names for globals/functions etc.
1464 WriteValueSymbolTable(M->getValueSymbolTable(), VE, Stream);
1465
1466 Stream.ExitBlock();

--- 110 unchanged lines hidden ---