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/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) {
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)));
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
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)));
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]]]
562 SmallVector<std::pair<unsigned, MDNode*>, 4> MDs;
563
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();
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));
578 }
579 if (!StartedMetadataBlock) {
580 Stream.EnterSubblock(bitc::METADATA_ATTACHMENT_ID, 3);
581 StartedMetadataBlock = true;
582 }
583 Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0);
584 Record.clear();
585 }
586
587 if (StartedMetadataBlock)
588 Stream.ExitBlock();
589}
590
591static void WriteModuleMetadataStore(const Module *M, BitstreamWriter &Stream) {
592 SmallVector<uint64_t, 64> Record;
593
594 // Write metadata kinds
595 // METADATA_KIND - [n x [id, name]]
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
609 Stream.EmitRecord(bitc::METADATA_KIND, Record, 0);
610 Record.clear();
611 }
612
613 Stream.ExitBlock();
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);
1205 if (!I->getType()->isVoidTy())
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.
1458 WriteModuleMetadataStore(M, Stream);
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 ---