Renamed inst_const_iterator -> const_inst_iterator
[oota-llvm.git] / lib / Bytecode / Writer / ConstantWriter.cpp
1 //===-- WriteConst.cpp - Functions for writing constants ---------*- C++ -*--=//
2 //
3 // This file implements the routines for encoding constants to a bytecode 
4 // stream.
5 //
6 // Note that the performance of this library is not terribly important, because
7 // it shouldn't be used by JIT type applications... so it is not a huge focus
8 // at least.  :)
9 //
10 //===----------------------------------------------------------------------===//
11
12 #include "WriterInternals.h"
13 #include "llvm/ConstantVals.h"
14 #include "llvm/SymbolTable.h"
15 #include "llvm/DerivedTypes.h"
16
17 void BytecodeWriter::outputType(const Type *T) {
18   output_vbr((unsigned)T->getPrimitiveID(), Out);
19   
20   // That's all there is to handling primitive types...
21   if (T->isPrimitiveType())
22     return;     // We might do this if we alias a prim type: %x = type int
23   
24   switch (T->getPrimitiveID()) {   // Handle derived types now.
25   case Type::MethodTyID: {
26     const MethodType *MT = cast<const MethodType>(T);
27     int Slot = Table.getValSlot(MT->getReturnType());
28     assert(Slot != -1 && "Type used but not available!!");
29     output_vbr((unsigned)Slot, Out);
30
31     // Output the number of arguments to method (+1 if varargs):
32     output_vbr(MT->getParamTypes().size()+MT->isVarArg(), Out);
33
34     // Output all of the arguments...
35     MethodType::ParamTypes::const_iterator I = MT->getParamTypes().begin();
36     for (; I != MT->getParamTypes().end(); ++I) {
37       Slot = Table.getValSlot(*I);
38       assert(Slot != -1 && "Type used but not available!!");
39       output_vbr((unsigned)Slot, Out);
40     }
41
42     // Terminate list with VoidTy if we are a varargs function...
43     if (MT->isVarArg())
44       output_vbr((unsigned)Type::VoidTy->getPrimitiveID(), Out);
45     break;
46   }
47
48   case Type::ArrayTyID: {
49     const ArrayType *AT = cast<const ArrayType>(T);
50     int Slot = Table.getValSlot(AT->getElementType());
51     assert(Slot != -1 && "Type used but not available!!");
52     output_vbr((unsigned)Slot, Out);
53     //cerr << "Type slot = " << Slot << " Type = " << T->getName() << endl;
54
55     output_vbr(AT->getNumElements(), Out);
56     break;
57   }
58
59   case Type::StructTyID: {
60     const StructType *ST = cast<const StructType>(T);
61
62     // Output all of the element types...
63     StructType::ElementTypes::const_iterator I = ST->getElementTypes().begin();
64     for (; I != ST->getElementTypes().end(); ++I) {
65       int Slot = Table.getValSlot(*I);
66       assert(Slot != -1 && "Type used but not available!!");
67       output_vbr((unsigned)Slot, Out);
68     }
69
70     // Terminate list with VoidTy
71     output_vbr((unsigned)Type::VoidTy->getPrimitiveID(), Out);
72     break;
73   }
74
75   case Type::PointerTyID: {
76     const PointerType *PT = cast<const PointerType>(T);
77     int Slot = Table.getValSlot(PT->getElementType());
78     assert(Slot != -1 && "Type used but not available!!");
79     output_vbr((unsigned)Slot, Out);
80     break;
81   }
82
83   case Type::OpaqueTyID: {
84     // No need to emit anything, just the count of opaque types is enough.
85     break;
86   }
87
88   //case Type::PackedTyID:
89   default:
90     cerr << __FILE__ << ":" << __LINE__ << ": Don't know how to serialize"
91          << " Type '" << T->getDescription() << "'\n";
92     break;
93   }
94 }
95
96 bool BytecodeWriter::outputConstant(const Constant *CPV) {
97   switch (CPV->getType()->getPrimitiveID()) {
98   case Type::BoolTyID:    // Boolean Types
99     if (cast<const ConstantBool>(CPV)->getValue())
100       output_vbr((unsigned)1, Out);
101     else
102       output_vbr((unsigned)0, Out);
103     break;
104
105   case Type::UByteTyID:   // Unsigned integer types...
106   case Type::UShortTyID:
107   case Type::UIntTyID:
108   case Type::ULongTyID:
109     output_vbr(cast<const ConstantUInt>(CPV)->getValue(), Out);
110     break;
111
112   case Type::SByteTyID:   // Signed integer types...
113   case Type::ShortTyID:
114   case Type::IntTyID:
115   case Type::LongTyID:
116     output_vbr(cast<const ConstantSInt>(CPV)->getValue(), Out);
117     break;
118
119   case Type::TypeTyID:     // Serialize type type
120     assert(0 && "Types should not be in the Constant!");
121     break;
122
123   case Type::ArrayTyID: {
124     const ConstantArray *CPA = cast<const ConstantArray>(CPV);
125     unsigned size = CPA->getValues().size();
126     if (!((const ArrayType *)CPA->getType())->isSized())
127       output_vbr(size, Out);            // Not for sized arrays!!!
128
129     for (unsigned i = 0; i < size; i++) {
130       int Slot = Table.getValSlot(CPA->getOperand(i));
131       assert(Slot != -1 && "Constant used but not available!!");
132       output_vbr((unsigned)Slot, Out);
133     }
134     break;
135   }
136
137   case Type::StructTyID: {
138     const ConstantStruct *CPS = cast<const ConstantStruct>(CPV);
139     const vector<Use> &Vals = CPS->getValues();
140
141     for (unsigned i = 0; i < Vals.size(); ++i) {
142       int Slot = Table.getValSlot(Vals[i]);
143       assert(Slot != -1 && "Constant used but not available!!");
144       output_vbr((unsigned)Slot, Out);
145     }      
146     break;
147   }
148
149   case Type::PointerTyID: {
150     const ConstantPointer *CPP = cast<const ConstantPointer>(CPV);
151     if (isa<ConstantPointerNull>(CPP)) {
152       output_vbr((unsigned)0, Out);
153     } else if (const ConstantPointerRef *CPR = 
154                         dyn_cast<ConstantPointerRef>(CPP)) {
155       output_vbr((unsigned)1, Out);
156       int Slot = Table.getValSlot((Value*)CPR->getValue());
157       assert(Slot != -1 && "Global used but not available!!");
158       output_vbr((unsigned)Slot, Out);
159     } else {
160       assert(0 && "Unknown ConstantPointer Subclass!");
161     }
162     break;
163   }
164
165   case Type::FloatTyID: {   // Floating point types...
166     float Tmp = (float)cast<ConstantFP>(CPV)->getValue();
167     output_data(&Tmp, &Tmp+1, Out);
168     break;
169   }
170   case Type::DoubleTyID: {
171     double Tmp = cast<ConstantFP>(CPV)->getValue();
172     output_data(&Tmp, &Tmp+1, Out);
173     break;
174   }
175
176   case Type::VoidTyID: 
177   case Type::LabelTyID:
178   default:
179     cerr << __FILE__ << ":" << __LINE__ << ": Don't know how to serialize"
180          << " type '" << CPV->getType()->getName() << "'\n";
181     break;
182   }
183   return false;
184 }