Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /sml/trunk/src/MLRISC/flowgraph/pseudo-ops-little.sml
ViewVC logotype

Annotation of /sml/trunk/src/MLRISC/flowgraph/pseudo-ops-little.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 991 - (view) (download)

1 : george 991 (* pseudo-ops-little.sml
2 :     *
3 :     * COPYRIGHT (c) 2001 Lucent Technologies, Bell Laboratories.
4 :     *
5 :     * Subset of pseudo-ops functions that are little endian sensitive
6 : george 984 *)
7 : george 991
8 : george 984 functor PseudoOpsLittle
9 :     ( structure T : MLTREE
10 :     structure MLTreeEval : MLTREE_EVAL
11 :     where T = T
12 :     val icache_alignment : int (* cache line size *)
13 :     val max_alignment : int option (* maximum alignment for internal labels *)
14 :     val nop: {sz:int, en:Word32.word} (* encoding for noop *)
15 : george 991 ) : PSEUDO_OPS_ENDIAN =
16 : george 984 struct
17 :     structure W = Word
18 :     structure T = T
19 :     structure PB = PseudoOpsBasisTyp
20 : george 991 type 'a pseudo_op = (T.labexp, 'a) PB.pseudo_op
21 : george 984
22 :     fun error msg = MLRiscErrorMsg.error ("PseudoOpsLittle.", msg)
23 :    
24 :     val >> = Word.>>
25 :     val ~>> = Word.~>>
26 :     val & = Word.andb
27 :     infix >> ~>> &
28 :    
29 :     (* return loc aligned at bndry *)
30 :     fun align(loc, bndry) = let
31 :     val mask = W.fromInt bndry - 0w1
32 :     in W.toIntX(W.andb(W.fromInt loc + mask, W.notb mask))
33 :     end
34 :    
35 :     (* bytes of padding required *)
36 :     fun padding(loc, bndry) = align(loc, bndry) - loc
37 :    
38 :     fun pow2(x, 0) = x
39 :     | pow2(x, n) = pow2(x * 2, n-1)
40 :    
41 :     fun bytesIn sz = Int.quot(sz, 8)
42 :    
43 :     fun sizeOf(pOp, loc) =
44 :     (case pOp
45 :     of PB.ALIGN_SZ n => padding(loc, pow2(1, n))
46 :     | PB.ALIGN_ENTRY => padding(loc, icache_alignment)
47 :     | PB.ALIGN_LABEL => let
48 :     val pad = padding(loc, icache_alignment)
49 :     in
50 :     case max_alignment
51 :     of NONE => pad
52 :     | SOME m => if pad <= m then pad else 0
53 :     end
54 :    
55 :     | PB.INT{sz, i} => length(i) * bytesIn sz
56 :    
57 :     | PB.ASCII s => String.size s
58 :     | PB.ASCIIZ s => String.size s + 1
59 :    
60 :     | PB.FLOAT{sz, f} => length(f) * bytesIn sz
61 :    
62 :     | PB.EXT _ => error "sizeOf: EXT"
63 :     | _ => 0
64 :     (*esac*))
65 :    
66 :    
67 :     fun emitValue{pOp, loc, emit} = let
68 :     val itow = W.fromInt
69 :     fun emitByte n = emit(Word8.fromLargeWord(W.toLargeWord n))
70 :     fun emitWord n = (emitByte(n & 0w255); emitByte((n >> 0w8) & 0w255))
71 :    
72 :     fun emitLongX n = let
73 :     val w = itow n
74 :     in emitWord(w & 0w65535); emitWord(w ~>> 0w16)
75 :     end
76 :    
77 :     local
78 :     val {sz, en} = nop
79 :     val toWord = W.fromLargeInt o Word32.toLargeIntX
80 :     in
81 :     fun emitNop () =
82 :     case sz
83 :     of 1 => emitByte (toWord en)
84 :     | 2 => emitWord (toWord en)
85 :     | 4 => (emitWord(toWord(Word32.andb(en, 0w65535)));
86 :     emitWord(toWord(Word32.>>(en, 0w16))))
87 :    
88 :     fun insertNops 0 = ()
89 :     | insertNops n =
90 :     if n >= sz then (emitNop(); insertNops(n-sz))
91 :     else error "insertNops"
92 :     end
93 :    
94 :     fun align(loc, bndry) = let
95 :     val bndry = Word.fromInt bndry
96 :     val mask = bndry - 0w1
97 :     in
98 :     case W.andb(itow(loc), mask)
99 :     of 0w0 => ()
100 :     | w => let
101 :     val padSz = (bndry - w)
102 :     in insertNops(Word.toInt padSz)
103 :     end
104 :     (*esac*)
105 :     end
106 :    
107 :     val {ccexp, rexp} =
108 :     MLTreeEval.eval
109 :     {const = IntInf.fromInt o T.Constant.valueOf,
110 :     label = Label.addrOf}
111 :     in
112 :     case pOp
113 :     of PB.ALIGN_SZ n => insertNops(sizeOf(pOp, loc))
114 :     | PB.ALIGN_ENTRY => insertNops(sizeOf(pOp, loc))
115 :     | PB.ALIGN_LABEL => insertNops(sizeOf(pOp, loc))
116 :    
117 :     | PB.INT{sz, i} => let
118 :     val ints = map (IntInf.toInt o rexp) i
119 :     in
120 :     case sz
121 :     of 8 => app (emitByte o itow) ints
122 :     | 16 => app (emitWord o itow) ints
123 :     | 32 => app emitLongX ints
124 :     | _ => error "emitValue: INT 64"
125 :     (*esac*)
126 :     end
127 :    
128 :     | PB.ASCII s => app (emit o Word8.fromInt o Char.ord) (String.explode s)
129 :     | PB.ASCIIZ s => (emitValue{pOp=PB.ASCII s, loc=loc, emit=emit}; emit 0w0)
130 :    
131 :     | PB.FLOAT{sz, f} => error "emitValue: FLOAT - not implemented"
132 :     | PB.EXT _ => error "emitValue: EXT"
133 :     | _ => ()
134 :     end
135 :     end

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0