?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2010-04-06 Jb Evain <jbevain@novell.com>
[mcs.git] / class / PEAPI / Code.cs
blob60f09b4e92d2d185568506f47987d2632a797b1b
1 using System.IO;
2 using System.Collections;
3
4 namespace PEAPI {
5
6 /**************************************************************************/
7 /// <summary>
8 /// Descriptor for an IL instruction
9 /// </summary>
10 internal abstract class CILInstruction {
11 protected static readonly sbyte maxByteVal = 127;
12 protected static readonly sbyte minByteVal = -128;
13 protected static readonly byte leadByte = 0xFE;
14 protected static readonly uint USHeapIndex = 0x70000000;
15 protected static readonly int longInstrStart = (int)Op.arglist;
16 public bool twoByteInstr = false;
17 public uint size = 0;
18 public uint offset;
19
20 internal virtual bool Check(MetaData md)
21 {
22 return false;
23 }
24
25 internal virtual void Write(FileImage output) { }
26
27 }
28
29 internal class CILByte : CILInstruction {
30 byte byteVal;
31
32 internal CILByte(byte bVal)
33 {
34 byteVal = bVal;
35 size = 1;
36 }
37
38 internal override void Write(FileImage output)
39 {
40 output.Write(byteVal);
41 }
42
43 }
44
45 internal class Instr : CILInstruction {
46 protected int instr;
47
48 internal Instr(int inst)
49 {
50 if (inst >= longInstrStart) {
51 instr = inst - longInstrStart;
52 twoByteInstr = true;
53 size = 2;
54 } else {
55 instr = inst;
56 size = 1;
57 }
58 }
59
60 internal override void Write(FileImage output)
61 {
62 //Console.WriteLine("Writing instruction " + instr + " with size " + size);
63 if (twoByteInstr) output.Write(leadByte);
64 output.Write((byte)instr);
65 }
66
67 }
68
69 internal class IntInstr : Instr {
70 int val;
71 bool byteNum;
72
73 internal IntInstr(int inst, int num, bool byteSize) : base(inst)
74 {
75 val = num;
76 byteNum = byteSize;
77 if (byteNum) size++;
78 else size += 4;
79 }
80
81 internal sealed override void Write(FileImage output)
82 {
83 base.Write(output);
84 if (byteNum)
85 output.Write((sbyte)val);
86 else
87 output.Write(val);
88 }
89
90 }
91
92 internal class UIntInstr : Instr {
93 int val;
94 bool byteNum;
95
96 internal UIntInstr(int inst, int num, bool byteSize) : base(inst)
97 {
98 val = num;
99 byteNum = byteSize;
100 if (byteNum) size++;
101 else size += 2;
102 }
103
104 internal sealed override void Write(FileImage output)
105 {
106 base.Write(output);
107 if (byteNum)
108 output.Write((byte)val);
109 else
110 output.Write((ushort)val);
111 }
112
113 }
114
115 internal class LongInstr : Instr {
116 long val;
117
118 internal LongInstr(int inst, long l) : base(inst)
119 {
120 val = l;
121 size += 8;
122 }
123
124 internal sealed override void Write(FileImage output)
125 {
126 base.Write(output);
127 output.Write(val);
128 }
129
130 }
131
132 internal class FloatInstr : Instr {
133 float fVal;
134
135 internal FloatInstr(int inst, float f) : base(inst)
136 {
137 fVal = f;
138 size += 4;
139 }
140
141 internal sealed override void Write(FileImage output)
142 {
143 base.Write(output);
144 output.Write(fVal);
145 }
146
147 }
148
149 internal class DoubleInstr : Instr {
150 double val;
151
152 internal DoubleInstr(int inst, double d) : base(inst)
153 {
154 val = d;
155 size += 8;
156 }
157
158 internal sealed override void Write(FileImage output)
159 {
160 base.Write(output);
161 output.Write(val);
162 }
163
164 }
165
166 internal class StringInstr : Instr {
167 string val;
168 byte[] bval;
169 uint strIndex;
170
171 internal StringInstr(int inst, string str) : base(inst)
172 {
173 val = str;
174 size += 4;
175 }
176
177 internal StringInstr (int inst, byte[] str) : base (inst)
178 {
179 bval = str;
180 size += 4;
181 }
182
183 internal sealed override bool Check(MetaData md)
184 {
185 if (val != null)
186 strIndex = md.AddToUSHeap(val);
187 else
188 strIndex = md.AddToUSHeap (bval);
189 return false;
190 }
191
192 internal sealed override void Write(FileImage output)
193 {
194 base.Write(output);
195 output.Write(USHeapIndex | strIndex);
196 }
197
198 }
199
200 internal class LabelInstr : CILInstruction {
201 CILLabel label;
202
203 internal LabelInstr(CILLabel lab)
204 {
205 label = lab;
206 label.AddLabelInstr(this);
207 }
208 }
209
210 internal class FieldInstr : Instr {
211 Field field;
212
213 internal FieldInstr(int inst, Field f) : base(inst)
214 {
215 field = f;
216 size += 4;
217 }
218
219 internal sealed override void Write(FileImage output)
220 {
221 base.Write(output);
222 output.Write(field.Token());
223 }
224
225 }
226
227 internal class MethInstr : Instr {
228 Method meth;
229
230 internal MethInstr(int inst, Method m) : base(inst)
231 {
232 meth = m;
233 size += 4;
234 }
235
236 internal sealed override void Write(FileImage output)
237 {
238 base.Write(output);
239 output.Write(meth.Token());
240 }
241
242 }
243
244 internal class SigInstr : Instr {
245 CalliSig signature;
246
247 internal SigInstr(int inst, CalliSig sig) : base(inst)
248 {
249 signature = sig;
250 size += 4;
251 }
252
253 internal sealed override bool Check(MetaData md)
254 {
255 md.AddToTable(MDTable.StandAloneSig,signature);
256 signature.BuildTables(md);
257 return false;
258 }
259
260 internal sealed override void Write(FileImage output)
261 {
262 base.Write(output);
263 output.Write(signature.Token());
264 }
265 }
266
267 internal class TypeInstr : Instr {
268 MetaDataElement theType;
269
270 internal TypeInstr(int inst, Type aType, MetaData md) : base(inst)
271 {
272 theType = aType.GetTypeSpec(md);
273 size += 4;
274 }
275
276 internal sealed override void Write(FileImage output)
277 {
278 base.Write(output);
279 output.Write(theType.Token());
280 }
281
282 }
283
284 internal class BranchInstr : Instr {
285 CILLabel dest;
286 private bool shortVer = true;
287 private static readonly byte longInstrOffset = 13;
288 private int target = 0;
289
290 internal BranchInstr(int inst, CILLabel dst) : base(inst)
291 {
292 dest = dst;
293 dest.AddBranch(this);
294 size++;
295
296 if (inst >= (int) BranchOp.br && inst != (int) BranchOp.leave_s) {
297 shortVer = false;
298 size += 3;
299 }
300 }
301
302 internal sealed override bool Check(MetaData md)
303 {
304 target = (int)dest.GetLabelOffset() - (int)(offset + size);
305 return false;
306 }
307
308 internal sealed override void Write(FileImage output)
309 {
310 base.Write(output);
311 if (shortVer)
312 output.Write((sbyte)target);
313 else
314 output.Write(target);
315 }
316
317 }
318
319 internal class SwitchInstr : Instr {
320 CILLabel[] cases;
321 uint numCases = 0;
322
323 internal SwitchInstr(int inst, CILLabel[] dsts) : base(inst)
324 {
325 cases = dsts;
326 if (cases != null) numCases = (uint)cases.Length;
327 size += 4 + (numCases * 4);
328 for (int i=0; i < numCases; i++) {
329 cases[i].AddBranch(this);
330 }
331 }
332
333 internal sealed override void Write(FileImage output)
334 {
335 base.Write(output);
336 output.Write(numCases);
337 for (int i=0; i < numCases; i++) {
338 int target = (int)cases[i].GetLabelOffset() - (int)(offset + size);
339 output.Write(target);
340 }
341 }
342
343 }
344
345 /**************************************************************************/
346 /// <summary>
347 /// The IL instructions for a method
348 /// </summary>
349 public class CILInstructions {
350 private static readonly uint ExHeaderSize = 4;
351 private static readonly uint FatExClauseSize = 24;
352 private static readonly uint SmlExClauseSize = 12;
353 private static readonly sbyte maxByteVal = 127;
354 private static readonly sbyte minByteVal = -128;
355 private static readonly byte maxUByteVal = 255;
356 private static readonly int smallSize = 64;
357 private static readonly ushort TinyFormat = 0x2;
358 private static readonly ushort FatFormat = 0x3003;
359 private static readonly ushort MoreSects = 0x8;
360 private static readonly ushort InitLocals = 0x10;
361 private static readonly uint FatSize = 12;
362 private static readonly uint FatWords = FatSize/4;
363 private static readonly byte FatExceptTable = 0x41;
364 private static readonly byte SmlExceptTable = 0x01;
365
366 private MetaData metaData;
367 private ArrayList exceptions, blockStack;
368 //private bool codeChecked = false;
369 private static readonly int INITSIZE = 5;
370 private CILInstruction[] buffer = new CILInstruction[INITSIZE];
371 private int tide = 0;
372 private uint offset = 0;
373 private ushort headerFlags = 0;
374 private short maxStack;
375 private uint paddingNeeded = 0;
376 private byte exceptHeader = 0;
377 uint localSigIx = 0;
378 uint codeSize = 0, exceptSize = 0;
379 bool tinyFormat, fatExceptionFormat = false;
380
381 public uint Offset {
382 get { return offset; }
383 }
384
385 internal CILInstructions(MetaData md)
386 {
387 metaData = md;
388 }
389
390 private void AddToBuffer(CILInstruction inst)
391 {
392 if (tide >= buffer.Length) {
393 CILInstruction[] tmp = buffer;
394 buffer = new CILInstruction[tmp.Length * 2];
395 for (int i=0; i < tide; i++) {
396 buffer[i] = tmp[i];
397 }
398 }
399 //Console.WriteLine("Adding instruction at offset " + offset + " with size " + inst.size);
400 inst.offset = offset;
401 offset += inst.size;
402 buffer[tide++] = inst;
403 }
404
405 /// <summary>
406 /// Add a simple IL instruction
407 /// </summary>
408 /// <param name="inst">the IL instruction</param>
409 public void Inst(Op inst)
410 {
411 AddToBuffer(new Instr((int)inst));
412 }
413
414 /// <summary>
415 /// Add an IL instruction with an integer parameter
416 /// </summary>
417 /// <param name="inst">the IL instruction</param>
418 /// <param name="val">the integer parameter value</param>
419 public void IntInst(IntOp inst, int val)
420 {
421 int instr = (int)inst;
422 if ((inst == IntOp.ldc_i4_s) || (inst == IntOp.ldc_i4))
423 AddToBuffer(new IntInstr(instr,val,(inst == IntOp.ldc_i4_s)));
424 else
425 AddToBuffer(new UIntInstr(instr,val,((inst < IntOp.ldc_i4_s) ||
426 (inst == IntOp.unaligned))));
427 }
428
429 /// <summary>
430 /// Add the load long instruction
431 /// </summary>
432 /// <param name="cVal">the long value</param>
433 public void ldc_i8(long cVal)
434 {
435 AddToBuffer(new LongInstr(0x21,cVal));
436 }
437
438 /// <summary>
439 /// Add the load float32 instruction
440 /// </summary>
441 /// <param name="cVal">the float value</param>
442 public void ldc_r4(float cVal)
443 {
444 AddToBuffer(new FloatInstr(0x22,cVal));
445 }
446
447 /// <summary>
448 /// Add the load float64 instruction
449 /// </summary>
450 /// <param name="cVal">the float value</param>
451 public void ldc_r8(double cVal)
452 {
453 AddToBuffer(new DoubleInstr(0x23,cVal));
454 }
455
456 /// <summary>
457 /// Add the load string instruction
458 /// </summary>
459 /// <param name="str">the string value</param>
460 public void ldstr(string str)
461 {
462 AddToBuffer(new StringInstr(0x72,str));
463 }
464
465 /// <summary>
466 /// Add the load string instruction
467 /// </summary>
468 public void ldstr (byte[] str)
469 {
470 AddToBuffer (new StringInstr (0x72, str));
471 }
472
473 /// <summary>
474 /// Add the calli instruction
475 /// </summary>
476 /// <param name="sig">the signature for the calli</param>
477 public void calli(CalliSig sig)
478 {
479 AddToBuffer(new SigInstr(0x29,sig));
480 }
481
482 /// <summary>
483 /// Add a label to the CIL instructions
484 /// </summary>
485 /// <param name="lab">the label to be added</param>
486 public void CodeLabel(CILLabel lab)
487 {
488 AddToBuffer(new LabelInstr(lab));
489 }
490
491 /// <summary>
492 /// Add an instruction with a field parameter
493 /// </summary>
494 /// <param name="inst">the CIL instruction</param>
495 /// <param name="f">the field parameter</param>
496 public void FieldInst(FieldOp inst, Field f)
497 {
498 AddToBuffer(new FieldInstr((int)inst,f));
499 }
500
501 /// <summary>
502 /// Add an instruction with a method parameter
503 /// </summary>
504 /// <param name="inst">the CIL instruction</param>
505 /// <param name="m">the method parameter</param>
506 public void MethInst(MethodOp inst, Method m)
507 {
508 AddToBuffer(new MethInstr((int)inst,m));
509 }
510
511 /// <summary>
512 /// Add an instruction with a type parameter
513 /// </summary>
514 /// <param name="inst">the CIL instruction</param>
515 /// <param name="t">the type argument for the CIL instruction</param>
516 public void TypeInst(TypeOp inst, Type aType)
517 {
518 AddToBuffer(new TypeInstr((int)inst,aType,metaData));
519 }
520
521 /// <summary>
522 /// Add a branch instruction
523 /// </summary>
524 /// <param name="inst">the branch instruction</param>
525 /// <param name="lab">the label that is the target of the branch</param>
526 public void Branch(BranchOp inst, CILLabel lab)
527 {
528 AddToBuffer(new BranchInstr((int)inst,lab));
529 }
530
531 /// <summary>
532 /// Add a switch instruction
533 /// </summary>
534 /// <param name="labs">the target labels for the switch</param>
535 public void Switch(CILLabel[] labs)
536 {
537 AddToBuffer(new SwitchInstr(0x45,labs));
538 }
539
540 /// <summary>
541 /// Add a byte to the CIL instructions (.emitbyte)
542 /// </summary>
543 /// <param name="bVal"></param>
544 public void emitbyte(byte bVal)
545 {
546 AddToBuffer(new CILByte(bVal));
547 }
548
549 /// <summary>
550 /// Add an instruction which puts an integer on TOS. This method
551 /// selects the correct instruction based on the value of the integer.
552 /// </summary>
553 /// <param name="i">the integer value</param>
554 public void PushInt(int i)
555 {
556 if (i == -1) {
557 AddToBuffer(new Instr((int)Op.ldc_i4_m1));
558 } else if ((i >= 0) && (i <= 8)) {
559 Op op = (Op)(Op.ldc_i4_0 + i);
560 AddToBuffer(new Instr((int)op));
561 } else if ((i >= minByteVal) && (i <= maxByteVal)) {
562 AddToBuffer(new IntInstr((int)IntOp.ldc_i4_s,i,true));
563 } else {
564 AddToBuffer(new IntInstr((int)IntOp.ldc_i4,i,false));
565 }
566 }
567
568 /// <summary>
569 /// Add the instruction to load a long on TOS
570 /// </summary>
571 /// <param name="l">the long value</param>
572 public void PushLong(long l)
573 {
574 AddToBuffer(new LongInstr(0x21,l));
575 }
576
577 /// <summary>
578 /// Add an instruction to push the boolean value true on TOS
579 /// </summary>
580 public void PushTrue()
581 {
582 AddToBuffer(new Instr((int)Op.ldc_i4_1));
583 }
584
585 /// <summary>
586 /// Add an instruction to push the boolean value false on TOS
587 /// </summary>
588 public void PushFalse()
589 {
590 AddToBuffer(new Instr((int)Op.ldc_i4_0));
591 }
592
593 /// <summary>
594 /// Add the instruction to load an argument on TOS. This method
595 /// selects the correct instruction based on the value of argNo
596 /// </summary>
597 /// <param name="argNo">the number of the argument</param>
598 public void LoadArg(int argNo)
599 {
600 if (argNo < 4) {
601 int op = (int)Op.ldarg_0 + argNo;
602 AddToBuffer(new Instr(op));
603 } else if (argNo <= maxUByteVal) {
604 AddToBuffer(new UIntInstr((int)IntOp.ldarg,argNo,true));
605 } else {
606 AddToBuffer(new UIntInstr(0x09,argNo,false));
607 }
608 }
609
610 /// <summary>
611 /// Add the instruction to load the address of an argument on TOS.
612 /// This method selects the correct instruction based on the value
613 /// of argNo.
614 /// </summary>
615 /// <param name="argNo">the number of the argument</param>
616 public void LoadArgAdr(int argNo)
617 {
618 if (argNo <= maxUByteVal) {
619 AddToBuffer(new UIntInstr((int)IntOp.ldarga,argNo,true));
620 } else {
621 AddToBuffer(new UIntInstr(0x0A,argNo,false));
622 }
623 }
624
625 /// <summary>
626 /// Add the instruction to load a local on TOS. This method selects
627 /// the correct instruction based on the value of locNo.
628 /// </summary>
629 /// <param name="locNo">the number of the local to load</param>
630 public void LoadLocal(int locNo)
631 {
632 if (locNo < 4) {
633 int op = (int)Op.ldloc_0 + locNo;
634 AddToBuffer(new Instr(op));
635 } else if (locNo <= maxUByteVal) {
636 AddToBuffer(new UIntInstr((int)IntOp.ldloc,locNo,true));
637 } else {
638 AddToBuffer(new UIntInstr(0x0C,locNo,false));
639 }
640 }
641
642 /// <summary>
643 /// Add the instruction to load the address of a local on TOS.
644 /// This method selects the correct instruction based on the
645 /// value of locNo.
646 /// </summary>
647 /// <param name="locNo">the number of the local</param>
648 public void LoadLocalAdr(int locNo)
649 {
650 if (locNo <= maxUByteVal) {
651 AddToBuffer(new UIntInstr((int)IntOp.ldloca,locNo,true));
652 } else {
653 AddToBuffer(new UIntInstr(0x0D,locNo,false));
654 }
655 }
656
657 /// <summary>
658 /// Add the instruction to store to an argument. This method
659 /// selects the correct instruction based on the value of argNo.
660 /// </summary>
661 /// <param name="argNo">the argument to be stored to</param>
662 public void StoreArg(int argNo)
663 {
664 if (argNo <= maxUByteVal) {
665 AddToBuffer(new UIntInstr((int)IntOp.starg,argNo,true));
666 } else {
667 AddToBuffer(new UIntInstr(0x0B,argNo,false));
668 }
669 }
670
671 /// <summary>
672 /// Add the instruction to store to a local. This method selects
673 /// the correct instruction based on the value of locNo.
674 /// </summary>
675 /// <param name="locNo">the local to be stored to</param>
676 public void StoreLocal(int locNo)
677 {
678 if (locNo < 4) {
679 int op = (int)Op.stloc_0 + locNo;
680 AddToBuffer(new Instr(op));
681 } else if (locNo <= maxUByteVal) {
682 AddToBuffer(new UIntInstr((int)IntOp.stloc,locNo,true));
683 } else {
684 AddToBuffer(new UIntInstr(0x0E,locNo,false));
685 }
686 }
687
688 /// <summary>
689 /// Create a new CIL label. To place the label in the CIL instruction
690 /// stream use CodeLabel.
691 /// </summary>
692 /// <returns>a new CIL label</returns>
693 public CILLabel NewLabel()
694 {
695 return new CILLabel();
696 }
697
698 public void AddTryBlock(TryBlock tryBlock)
699 {
700 if (exceptions == null)
701 exceptions = new ArrayList();
702 else if (exceptions.Contains(tryBlock)) return;
703 exceptions.Add(tryBlock);
704 tryBlock.ResolveCatchBlocks (metaData);
705 }
706
707 /// <summary>
708 /// Create a new label at this position in the code buffer
709 /// </summary>
710 /// <returns>the label at the current position</returns>
711 public CILLabel NewCodedLabel()
712 {
713 CILLabel lab = new CILLabel();
714 AddToBuffer(new LabelInstr(lab));
715 return lab;
716 }
717
718 /// <summary>
719 /// Mark this position as the start of a new block
720 /// (try, catch, filter, finally or fault)
721 /// </summary>
722 public void StartBlock()
723 {
724 if (blockStack == null) blockStack = new ArrayList();
725 blockStack.Insert(0,NewCodedLabel());
726 }
727
728 /// <summary>
729 /// Mark this position as the end of the last started block and
730 /// make it a try block. This try block is added to the current
731 /// instructions (ie do not need to call AddTryBlock)
732 /// </summary>
733 /// <returns>The try block just ended</returns>
734 public TryBlock EndTryBlock()
735 {
736 TryBlock tBlock = new TryBlock((CILLabel)blockStack[0],NewCodedLabel());
737 blockStack.RemoveAt(0);
738 AddTryBlock(tBlock);
739 return tBlock;
740 }
741
742 /// <summary>
743 /// Mark this position as the end of the last started block and
744 /// make it a catch block. This catch block is associated with the
745 /// specified try block.
746 /// </summary>
747 /// <param name="exceptType">the exception type to be caught</param>
748 /// <param name="tryBlock">the try block associated with this catch block</param>
749 public void EndCatchBlock(Class exceptType, TryBlock tryBlock)
750 {
751 Catch catchBlock = new Catch(exceptType,(CILLabel)blockStack[0],
752 NewCodedLabel());
753 tryBlock.AddHandler(catchBlock);
754 }
755
756 /// <summary>
757 /// Mark this position as the end of the last started block and
758 /// make it a filter block. This filter block is associated with the
759 /// specified try block.
760 /// </summary>
761 /// <param name="filterLab">the label where the filter code is</param>
762 /// <param name="tryBlock">the try block associated with this filter block</param>
763 public void EndFilterBlock(CILLabel filterLab, TryBlock tryBlock)
764 {
765 Filter filBlock = new Filter(filterLab,(CILLabel)blockStack[0],NewCodedLabel());
766 tryBlock.AddHandler(filBlock);
767 }
768
769 /// <summary>
770 /// Mark this position as the end of the last started block and
771 /// make it a finally block. This finally block is associated with the
772 /// specified try block.
773 /// </summary>
774 /// <param name="tryBlock">the try block associated with this finally block</param>
775 public void EndFinallyBlock(TryBlock tryBlock)
776 {
777 Finally finBlock= new Finally((CILLabel)blockStack[0],NewCodedLabel());
778 tryBlock.AddHandler(finBlock);
779 }
780
781 /// <summary>
782 /// Mark this position as the end of the last started block and
783 /// make it a fault block. This fault block is associated with the
784 /// specified try block.
785 /// </summary>
786 /// <param name="tryBlock">the try block associated with this fault block</param>
787 public void EndFaultBlock(TryBlock tryBlock)
788 {
789 Fault fBlock= new Fault((CILLabel)blockStack[0],NewCodedLabel());
790 tryBlock.AddHandler(fBlock);
791 }
792
793 internal uint GetCodeSize()
794 {
795 return codeSize + paddingNeeded + exceptSize;
796 }
797
798 internal void CheckCode(uint locSigIx, bool initLocals, int maxStack)
799 {
800 if (tide == 0) return;
801 bool changed = true;
802 while (changed) {
803 changed = false;
804 for (int i=0; i < tide; i++) {
805 changed = buffer[i].Check(metaData) || changed;
806 }
807 if (changed) {
808 for (int i=1; i < tide; i++) {
809 buffer[i].offset = buffer[i-1].offset + buffer[i-1].size;
810 }
811 offset = buffer[tide-1].offset + buffer[tide-1].size;
812 }
813 }
814 codeSize = offset;
815 // Console.WriteLine("codeSize before header added = " + codeSize);
816 if ((offset < smallSize) && (maxStack <= 8) && (locSigIx == 0) && (exceptions == null)) {
817 // can use tiny header
818 //Console.WriteLine("Tiny Header");
819 tinyFormat = true;
820 headerFlags = (ushort)(TinyFormat | ((ushort)codeSize << 2));
821 codeSize++;
822 if ((codeSize % 4) != 0) { paddingNeeded = 4 - (codeSize % 4); }
823 } else {
824 //Console.WriteLine("Fat Header");
825 tinyFormat = false;
826 localSigIx = locSigIx;
827 this.maxStack = (short)maxStack;
828 headerFlags = FatFormat;
829 if (exceptions != null) {
830 // Console.WriteLine("Got exceptions");
831 headerFlags |= MoreSects;
832 uint numExceptClauses = 0;
833 for (int i=0; i < exceptions.Count; i++) {
834 TryBlock tryBlock = (TryBlock)exceptions[i];
835 tryBlock.SetSize();
836 numExceptClauses += (uint)tryBlock.NumHandlers();
837 if (tryBlock.isFat()) fatExceptionFormat = true;
838 }
839
840 uint data_size = ExHeaderSize + numExceptClauses *
841 (fatExceptionFormat ? FatExClauseSize : SmlExClauseSize);
842
843 if (data_size > 255)
844 fatExceptionFormat = true;
845
846 // Console.WriteLine("numexceptclauses = " + numExceptClauses);
847 if (fatExceptionFormat) {
848 // Console.WriteLine("Fat exception format");
849 exceptHeader = FatExceptTable;
850 exceptSize = ExHeaderSize + numExceptClauses * FatExClauseSize;
851 } else {
852 // Console.WriteLine("Tiny exception format");
853 exceptHeader = SmlExceptTable;
854 exceptSize = ExHeaderSize + numExceptClauses * SmlExClauseSize;
855 }
856 // Console.WriteLine("exceptSize = " + exceptSize);
857 }
858 if (initLocals) headerFlags |= InitLocals;
859 if ((offset % 4) != 0) { paddingNeeded = 4 - (offset % 4); }
860 codeSize += FatSize;
861 }
862 // Console.WriteLine("codeSize = " + codeSize + " headerFlags = " +
863 // Hex.Short(headerFlags));
864 }
865
866 internal void Write(FileImage output)
867 {
868 // Console.WriteLine("Writing header flags = " + Hex.Short(headerFlags));
869 if (tinyFormat) {
870 // Console.WriteLine("Writing tiny code");
871 output.Write((byte)headerFlags);
872 } else {
873 // Console.WriteLine("Writing fat code");
874 output.Write(headerFlags);
875 output.Write((ushort)maxStack);
876 output.Write(offset);
877 output.Write(localSigIx);
878 }
879 // Console.WriteLine(Hex.Int(tide) + " CIL instructions");
880 // Console.WriteLine("starting instructions at " + output.Seek(0,SeekOrigin.Current));
881 for (int i=0; i < tide; i++) {
882 buffer[i].Write(output);
883 }
884 // Console.WriteLine("ending instructions at " + output.Seek(0,SeekOrigin.Current));
885 for (int i=0; i < paddingNeeded; i++) { output.Write((byte)0); }
886 if (exceptions != null) {
887 // Console.WriteLine("Writing exceptions");
888 // Console.WriteLine("header = " + Hex.Short(exceptHeader) + " exceptSize = " + Hex.Int(exceptSize));
889 output.Write(exceptHeader);
890 output.Write3Bytes((uint)exceptSize);
891 for (int i=0; i < exceptions.Count; i++) {
892 TryBlock tryBlock = (TryBlock)exceptions[i];
893 tryBlock.Write(output,fatExceptionFormat);
894 }
895 }
896 }
897
898 }
899
900 /**************************************************************************/
901 public abstract class CodeBlock {
902
903 private static readonly int maxCodeSize = 255;
904 protected CILLabel start, end;
905 protected bool small = true;
906
907 public CodeBlock(CILLabel start, CILLabel end)
908 {
909 this.start = start;
910 this.end = end;
911 }
912
913 internal virtual bool isFat()
914 {
915 // Console.WriteLine("block start = " + start.GetLabelOffset() +
916 // " block end = " + end.GetLabelOffset());
917 return (end.GetLabelOffset() - start.GetLabelOffset()) > maxCodeSize;
918 }
919
920 internal virtual void Write(FileImage output, bool fatFormat)
921 {
922 if (fatFormat) output.Write(start.GetLabelOffset());
923 else output.Write((short)start.GetLabelOffset());
924 uint len = end.GetLabelOffset() - start.GetLabelOffset();
925 if (fatFormat) output.Write(len);
926 else output.Write((byte)len);
927 }
928
929 }
930
931 /// <summary>
932 /// The descriptor for a guarded block (.try)
933 /// </summary>
934 public class TryBlock : CodeBlock {
935 protected bool fatFormat = false;
936 protected int flags = 0;
937 ArrayList handlers = new ArrayList();
938
939 /// <summary>
940 /// Create a new try block
941 /// </summary>
942 /// <param name="start">start label for the try block</param>
943 /// <param name="end">end label for the try block</param>
944 public TryBlock(CILLabel start, CILLabel end) : base(start,end) { }
945
946 /// <summary>
947 /// Add a handler to this try block
948 /// </summary>
949 /// <param name="handler">a handler to be added to the try block</param>
950 public void AddHandler(HandlerBlock handler)
951 {
952 flags = handler.GetFlag();
953 handlers.Add(handler);
954 }
955
956 internal void SetSize()
957 {
958 fatFormat = base.isFat();
959 if (fatFormat) return;
960 for (int i=0; i < handlers.Count; i++) {
961 HandlerBlock handler = (HandlerBlock)handlers[i];
962 if (handler.isFat()) {
963 fatFormat = true;
964 return;
965 }
966 }
967 }
968
969 internal int NumHandlers()
970 {
971 return handlers.Count;
972 }
973
974 internal override bool isFat()
975 {
976 return fatFormat;
977 }
978
979 //Hackish
980 internal void ResolveCatchBlocks (MetaData md)
981 {
982 for (int i=0; i < handlers.Count; i++) {
983 Catch c = handlers [i] as Catch;
984 if (c != null)
985 c.ResolveType (md);
986 }
987 }
988
989 internal override void Write(FileImage output, bool fatFormat)
990 {
991 // Console.WriteLine("writing exception details");
992 for (int i=0; i < handlers.Count; i++) {
993 // Console.WriteLine("Except block " + i);
994 HandlerBlock handler = (HandlerBlock)handlers[i];
995 if (fatFormat) output.Write(flags);
996 else output.Write((short)flags);
997 // Console.WriteLine("flags = " + Hex.Short(flags));
998 base.Write(output,fatFormat);
999 handler.Write(output,fatFormat);
1000 }
1001 }
1002 }
1003
1004 public abstract class HandlerBlock : CodeBlock {
1005
1006 protected static readonly short ExceptionFlag = 0;
1007 protected static readonly short FilterFlag = 0x01;
1008 protected static readonly short FinallyFlag = 0x02;
1009 protected static readonly short FaultFlag = 0x04;
1010
1011 public HandlerBlock(CILLabel start, CILLabel end) : base(start,end) { }
1012
1013 internal virtual short GetFlag() { return ExceptionFlag; }
1014
1015 internal override void Write(FileImage output, bool fatFormat)
1016 {
1017 base.Write(output,fatFormat);
1018 }
1019
1020 }
1021
1022 /// <summary>
1023 /// The descriptor for a catch clause (.catch)
1024 /// </summary>
1025 public class Catch : HandlerBlock {
1026
1027 MetaDataElement exceptType;
1028
1029 /// <summary>
1030 /// Create a new catch clause
1031 /// </summary>
1032 /// <param name="except">the exception to be caught</param>
1033 /// <param name="handlerStart">start of the handler code</param>
1034 /// <param name="handlerEnd">end of the handler code</param>
1035 public Catch(Class except, CILLabel handlerStart, CILLabel handlerEnd)
1036 : base(handlerStart, handlerEnd)
1037 {
1038 exceptType = except;
1039 }
1040
1041 public Catch(Type except, CILLabel handlerStart, CILLabel handlerEnd)
1042 : base(handlerStart,handlerEnd)
1043 {
1044 exceptType = except;
1045 }
1046
1047 internal void ResolveType (MetaData md)
1048 {
1049 exceptType = ((Type) exceptType).GetTypeSpec (md);
1050 }
1051
1052 internal override void Write(FileImage output, bool fatFormat)
1053 {
1054 base.Write(output,fatFormat);
1055 output.Write(exceptType.Token());
1056 }
1057 }
1058
1059 /// <summary>
1060 /// The descriptor for a filter clause (.filter)
1061 /// </summary>
1062 public class Filter : HandlerBlock {
1063
1064 CILLabel filterLabel;
1065
1066 /// <summary>
1067 /// Create a new filter clause
1068 /// </summary>
1069 /// <param name="filterLabel">the label where the filter code starts</param>
1070 /// <param name="handlerStart">the start of the handler code</param>
1071 /// <param name="handlerEnd">the end of the handler code</param>
1072 public Filter(CILLabel filterLabel, CILLabel handlerStart,
1073 CILLabel handlerEnd) : base(handlerStart,handlerEnd)
1074 {
1075 this.filterLabel = filterLabel;
1076 }
1077
1078 internal override short GetFlag()
1079 {
1080 return FilterFlag;
1081 }
1082
1083 internal override void Write(FileImage output, bool fatFormat)
1084 {
1085 base.Write(output,fatFormat);
1086 output.Write(filterLabel.GetLabelOffset());
1087 }
1088
1089 }
1090
1091 /// <summary>
1092 /// Descriptor for a finally block (.finally)
1093 /// </summary>
1094 public class Finally : HandlerBlock {
1095
1096 /// <summary>
1097 /// Create a new finally clause
1098 /// </summary>
1099 /// <param name="finallyStart">start of finally code</param>
1100 /// <param name="finallyEnd">end of finally code</param>
1101 public Finally(CILLabel finallyStart, CILLabel finallyEnd)
1102 : base(finallyStart,finallyEnd) { }
1103
1104 internal override short GetFlag()
1105 {
1106 return FinallyFlag;
1107 }
1108
1109 internal override void Write(FileImage output, bool fatFormat)
1110 {
1111 base.Write(output,fatFormat);
1112 output.Write((int)0);
1113 }
1114
1115 }
1116
1117 /// <summary>
1118 /// Descriptor for a fault block (.fault)
1119 /// </summary>
1120 public class Fault : HandlerBlock {
1121
1122 /// <summary>
1123 /// Create a new fault clause
1124 /// </summary>
1125 /// <param name="faultStart">start of the fault code</param>
1126 /// <param name="faultEnd">end of the fault code</param>
1127 public Fault(CILLabel faultStart, CILLabel faultEnd)
1128 : base(faultStart,faultEnd) { }
1129
1130 internal override short GetFlag()
1131 {
1132 return FaultFlag;
1133 }
1134
1135 internal override void Write(FileImage output, bool fatFormat)
1136 {
1137 base.Write(output,fatFormat);
1138 output.Write((int)0);
1139
1140 }
1141 }
1142
1143 /**************************************************************************/
1144 /// <summary>
1145 /// Descriptor for the locals for a method
1146 /// </summary>
1147 public class LocalSig : Signature {
1148
1149 private static readonly byte LocalSigByte = 0x7;
1150 Local[] locals;
1151
1152 public LocalSig(Local[] locals)
1153 {
1154 this.locals = locals;
1155 tabIx = MDTable.StandAloneSig;
1156 }
1157
1158 internal sealed override void BuildTables(MetaData md)
1159 {
1160 if (done) return;
1161 MemoryStream sig = new MemoryStream();
1162 sig.WriteByte(LocalSigByte);
1163 MetaData.CompressNum((uint)locals.Length,sig);
1164 for (int i=0; i < locals.Length; i++) {
1165 ((Local)locals[i]).TypeSig(sig);
1166 }
1167 sigIx = md.AddToBlobHeap(sig.ToArray());
1168 done = true;
1169 }
1170
1171 }
1172
1173 /**************************************************************************/
1174 /// <summary>
1175 /// Signature for calli instruction
1176 /// </summary>
1177 public class CalliSig : Signature {
1178
1179 private static readonly byte Sentinel = 0x41;
1180 CallConv callConv;
1181 Type returnType;
1182 Type[] parameters, optParams;
1183 uint numPars = 0, numOptPars = 0;
1184
1185 /// <summary>
1186 /// Create a signature for a calli instruction
1187 /// </summary>
1188 /// <param name="cconv">calling conventions</param>
1189 /// <param name="retType">return type</param>
1190 /// <param name="pars">parameter types</param>
1191 public CalliSig(CallConv cconv, Type retType, Type[] pars)
1192 {
1193 tabIx = MDTable.StandAloneSig;
1194 callConv = cconv;
1195 returnType = retType;
1196 parameters = pars;
1197 if (pars != null) numPars = (uint)pars.Length;
1198 }
1199
1200 /// <summary>
1201 /// Add the optional parameters to a vararg method
1202 /// This method sets the vararg calling convention
1203 /// </summary>
1204 /// <param name="optPars">the optional pars for the vararg call</param>
1205 public void AddVarArgs(Type[] optPars)
1206 {
1207 optParams = optPars;
1208 if (optPars != null) numOptPars = (uint)optPars.Length;
1209 callConv |= CallConv.Vararg;
1210 }
1211
1212 /// <summary>
1213 /// Add extra calling conventions to this callsite signature
1214 /// </summary>
1215 /// <param name="cconv"></param>
1216 public void AddCallingConv(CallConv cconv)
1217 {
1218 callConv |= cconv;
1219 }
1220
1221 internal sealed override void BuildTables(MetaData md)
1222 {
1223 if (done) return;
1224 MemoryStream sig = new MemoryStream();
1225 sig.WriteByte((byte)callConv);
1226 MetaData.CompressNum(numPars+numOptPars,sig);
1227 returnType.TypeSig(sig);
1228 for (int i=0; i < numPars; i++) {
1229 parameters[i].TypeSig(sig);
1230 }
1231 sigIx = md.AddToBlobHeap(sig.ToArray());
1232 if (numOptPars > 0) {
1233 sig.WriteByte(Sentinel);
1234 for (int i=0; i < numOptPars; i++) {
1235 optParams[i].TypeSig(sig);
1236 }
1237 }
1238 done = true;
1239 }
1240
1241 }
1242
1243 /**************************************************************************/
1244 /// <summary>
1245 /// Descriptor for a local of a method
1246 /// </summary>
1247 public class Local {
1248
1249 private static readonly byte Pinned = 0x45;
1250 string name;
1251 Type type;
1252 bool pinned = false, byref = false;
1253
1254 /// <summary>
1255 /// Create a new local variable
1256 /// </summary>
1257 /// <param name="lName">name of the local variable</param>
1258 /// <param name="lType">type of the local variable</param>
1259 public Local(string lName, Type lType)
1260 {
1261 name = lName;
1262 type = lType;
1263 }
1264
1265 /// <summary>
1266 /// Create a new local variable that is byref and/or pinned
1267 /// </summary>
1268 /// <param name="lName">local name</param>
1269 /// <param name="lType">local type</param>
1270 /// <param name="byRef">is byref</param>
1271 /// <param name="isPinned">has pinned attribute</param>
1272 public Local(string lName, Type lType, bool byRef, bool isPinned)
1273 {
1274 name = lName;
1275 type = lType;
1276 byref = byRef;
1277 pinned = isPinned;
1278 }
1279
1280 internal void TypeSig(MemoryStream str)
1281 {
1282 if (pinned) str.WriteByte(Pinned);
1283 type.TypeSig(str);
1284 }
1285
1286 }
1287
1288 /**************************************************************************/
1289 /// <summary>
1290 /// A label in the IL
1291 /// </summary>
1292 public class CILLabel {
1293
1294 CILInstruction branch;
1295 CILInstruction[] multipleBranches;
1296 int tide = 0;
1297 CILInstruction labInstr;
1298 uint offset = 0;
1299 bool absolute;
1300
1301
1302 public CILLabel (uint offset, bool absolute)
1303 {
1304 this.offset = offset;
1305 this.absolute = absolute;
1306 }
1307
1308 public CILLabel (uint offset) : this (offset, false)
1309 {
1310 }
1311
1312
1313 internal CILLabel()
1314 {
1315 }
1316
1317 internal void AddBranch(CILInstruction instr)
1318 {
1319 if (branch == null) {
1320 branch = instr;
1321 return;
1322 }
1323 if (multipleBranches == null) {
1324 multipleBranches = new CILInstruction[2];
1325 } else if (tide >= multipleBranches.Length) {
1326 CILInstruction[] tmp = multipleBranches;
1327 multipleBranches = new CILInstruction[tmp.Length*2];
1328 for (int i=0; i < tide; i++) {
1329 multipleBranches[i] = tmp[i];
1330 }
1331 }
1332 multipleBranches[tide++] = instr;
1333 }
1334
1335 internal void AddLabelInstr(LabelInstr lInstr)
1336 {
1337 labInstr = lInstr;
1338 }
1339
1340 internal uint GetLabelOffset()
1341 {
1342 if (absolute) return offset;
1343 if (labInstr == null) return 0;
1344 return labInstr.offset + offset;
1345 }
1346
1347 }
1348
1349
1350 }
1351
1352
git-svn mirror of mcs