← Back to branch summary

~statik/ubuntu/maverick/erlang/erlang-merge-testing

« back to all changes in this revision

Viewing changes to lib/hipe/sparc/0OLD/hipe_sparc_op.erl

  • Committer: Bazaar Package Importer
  • Author(s): Sergei Golovan
  • Date: 2009-05-01 10:14:38 UTC
  • mfrom: (3.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20090501101438-6qlr6rsdxgyzrg2z
Tags: 1:13.b-dfsg-2
* Cleaned up patches: removed unneeded patch which helped to support
  different SCTP library versions, made sure that changes for m68k
  architecture applied only when building on this architecture.
* Removed duplicated information from binary packages descriptions.
* Don't require libsctp-dev build-dependency on solaris-i386 architecture
  which allows to build Erlang on Nexenta (thanks to Tim Spriggs for
  the suggestion).

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/hipe/sparc/0OLD/hipe_sparc_op.erl
1
 
%% ====================================================================
2
 
%%  Filename :  hipe_sparc_op.erl
3
 
%%  Module   :  hipe_sparc_op
4
 
%%  Purpose  :  
5
 
%%  Notes    : 
6
 
%%  History  :  * 1997-04-14 Erik Johansson (happi@csd.uu.se): Created.
7
 
%% CVS:
8
 
%%    $Author: mikpe $
9
 
%%    $Date: 2007/12/18 09:18:22 $
10
 
%%    $Revision: 1.1 $
11
 
%% ====================================================================
12
 
%% Exported functions (short description):
13
 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14
 
 
15
 
-module(hipe_sparc_op).
16
 
-export([annul_bit/1, predicate_bit/1,
17
 
         %% bits_10/1, bits_high/1, bits_low/1, high22/1,
18
 
         %% sti/3, st/3,
19
 
         ldi/3, ld/3, call/1, jumpli/3, nop/0, sethi/2,
20
 
         rdy/1,
21
 
         %% savei/3, restorei/3,
22
 
 
23
 
         stb/3, sth/3, stw/3, stx/3, stbi/3, sthi/3, stwi/3, stxi/3,
24
 
 
25
 
         ldsb/3, ldsh/3, ldsw/3, ldub/3, lduh/3, %% lduw/3,
26
 
         ldx/3,
27
 
         ldsbi/3, ldshi/3, ldswi/3, ldubi/3, lduhi/3, %% lduwi/3,
28
 
         ldxi/3,
29
 
 
30
 
         cc_bits/1, % rcc_bits/1, fcc_bits/1,
31
 
 
32
 
         %% bicc/3,
33
 
         bpcc/4, % bpr/5, 
34
 
         %% fbfcc/3, %% Obsolete in V9
35
 
         %% fbpfcc/5,
36
 
         %% fbpfcc0/4, fbpfcc1/4, fbpfcc2/4, fbpfcc3/4,
37
 
 
38
 
         sll/3,slli/3,srl/3,srli/3,sra/3,srai/3,
39
 
         sllx/3,sllix/3,srlx/3,srlix/3,srax/3,sraix/3,
40
 
         add/3,addi/3,addcc/3,addicc/3,
41
 
         addc/3, addci/3, %% addccc/3, addcicc/3,
42
 
 
43
 
         sub/3, subi/3, subcc/3, subicc/3,
44
 
         subc/3, subci/3, %% subccc/3, subcicc/3,
45
 
         
46
 
         and_op/3, andi/3, andcc/3, andicc/3, andn/3,
47
 
         andni/3, andncc/3, andnicc/3, or_op/3, ori/3, orcc/3, oricc/3,
48
 
         xor_op/3, xori/3,
49
 
         xnor_op/3, xnori/3,
50
 
         xorcc/3, xoricc/3,
51
 
         %% taddcc/3, taddcci/3, tsubcc/3, tsubcci/3,
52
 
 
53
 
         smul/3, smuli/3, % smulcc/3, smulicc/3,
54
 
 
55
 
         %% fxtos/2, fxtod/2, fxtoq/2,
56
 
         fitos/2, fitod/2, fitoq/2,
57
 
         %% fstox/2, fdtox/2, fqtox/2,
58
 
         %% fstoi/2, fdtoi/2, fqtoi/2,
59
 
         %% fstod/2, fstoq/2, fdtos/2, fdtoq/2, fqtos/2, fqtod/2,
60
 
         fmovs/2, fnegs/2, fabss/2,
61
 
         fmovd/2, fnegd/2, fabsd/2,
62
 
         fmovq/2, fnegq/2, fabsq/2,
63
 
         %% fsqrts/2, fsqrtd/2, fsqrtq/2,
64
 
         fadds/3, faddd/3, faddq/3,      
65
 
         fsubs/3, fsubd/3, fsubq/3, 
66
 
 
67
 
         fmuls/3, fmuld/3, fmulq/3, 
68
 
         %% fsmuld/3, fdmulq/3, 
69
 
         fdivs/3, fdivd/3, fdivq/3, 
70
 
         %% fcmps/2, fcmpd/2, fcmpq/2, fcmpes/2, fcmped/2, fcmpeq/2,
71
 
         %% fcmps/3, fcmpd/3, fcmpq/3, fcmpes/3, fcmped/3, fcmpeq/3,
72
 
 
73
 
         stf/3, stfi/3, stdf/3, stdfi/3, %% stfsr/3, stfsri/3, 
74
 
         stqf/3, stqfi/3,
75
 
         ldf/3, ldfi/3, lddf/3, lddfi/3, ldqf/3, ldqfi/3
76
 
         %% ldxfsr/2, ldxfsri/2,
77
 
         %% make_bitlist/2
78
 
        ]).
79
 
 
80
 
annul_bit(a) -> 1;
81
 
annul_bit(na) -> 0.
82
 
 
83
 
predicate_bit(true) -> 1;
84
 
predicate_bit(false) -> 0.
85
 
 
86
 
%% bits_10(X) -> X band      16#3ff.
87
 
bits_13(X) -> X band     16#1fff.
88
 
%% bits_14(X) -> X band     16#3fff.
89
 
%% bits_16(X) -> X band     16#ffff.
90
 
bits_19(X) -> X band    16#7ffff.
91
 
bits_22(X) -> X band   16#3fffff.
92
 
%% bits_30(X) -> X band 16#3fffffff.
93
 
bits_32(X) -> X band 16#ffffffff.
94
 
 
95
 
%% %% Splits a 16 bits displacement for format22d into low (bit 0-13)
96
 
%% %% and high (bit 14-15 into bit 20-21)
97
 
%% bits_16_high(X) -> (X band 16#c000) bsl 6.
98
 
%% bits_16_low(X) -> bits_14(X).
99
 
 
100
 
%% bits_low(X) -> X band 16#ffff.
101
 
%% bits_high(X) -> (X bsr 16) band 16#ffff.
102
 
 
103
 
%% high22(X) -> X bsr 10.
104
 
 
105
 
 
106
 
format1(Disp30) ->
107
 
  ((1 bsl 30) bor (bits_32(Disp30) bsr 2)).
108
 
 
109
 
format2a(Rd, Op2, Imm22)  ->
110
 
  ((Rd bsl 25) bor (Op2 bsl 22) bor bits_22(Imm22)).
111
 
 
112
 
%% format2b(A, Cond, Op2, Disp22)  ->
113
 
%%   ((A bsl 29) bor (Cond bsl 25) bor (Op2 bsl 22) bor
114
 
%%    bits_22(Disp22)).
115
 
 
116
 
format2c(A,Cond,Op2,CC1,CC0,P,Disp19) ->
117
 
  ((A bsl 29) bor (Cond bsl 25) bor (Op2 bsl 22) bor
118
 
   (CC1 bsl 21) bor (CC0 bsl 20) bor (P bsl 19) 
119
 
   bor bits_19(Disp19)).
120
 
 
121
 
%% format2d(A,RCond,Op2,Disp16,P,Rs1) ->
122
 
%%   ((A bsl 29) bor (RCond bsl 25) bor (Op2 bsl 22) bor
123
 
%%    bits_16_high(Disp16) bor (P bsl 19) bor (Rs1 bsl 14) 
124
 
%%    bor bits_16_low(Disp16)).
125
 
 
126
 
 
127
 
 
128
 
 
129
 
format3h(Op, Rd, Op3, Rs1)  ->
130
 
  ((Op bsl 30) bor (Rd bsl 25) bor (Op3 bsl 19) bor (Rs1 bsl
131
 
  14)).
132
 
 
133
 
 
134
 
format3a(Op, Rd, Op3, Rs1, Asi, Rs2)  ->
135
 
  (format3h(Op, Rd, Op3, Rs1) bor (Asi bsl 5) bor (Rs2)).
136
 
 
137
 
format3ax(Op, Rd, Op3, Rs1, Asi, Rs2)  ->
138
 
  (format3h(Op, Rd, Op3, Rs1) bor (Asi bsl 5) bor (1 bsl 12) bor (Rs2)).
139
 
 
140
 
 
141
 
format3b(Op, Rd, Op3, Rs1, Simm13)  ->
142
 
  (format3h(Op, Rd, Op3, Rs1) bor (1 bsl 13) bor bits_13(Simm13)).
143
 
 
144
 
format3bx(Op, Rd, Op3, Rs1, Simm13)  ->
145
 
  (format3h(Op, Rd, Op3, Rs1) bor (1 bsl 13) bor (1 bsl 12) bor bits_13(Simm13)).
146
 
 
147
 
%% format3c(Op, Rd, Op3, Rs1, Opf, Rs2)  ->
148
 
%%   (format3h(Op, Rd, Op3, Rs1) bor (Opf bsl 5) bor (Rs2)).
149
 
 
150
 
%% format3d(Op, Rd, Op3, Rs1, I, Rs2)  ->
151
 
%%  (format3h(Op, Rd, Op3, Rs1) bor (I bsl 13) bor (Rs2)).
152
 
 
153
 
 
154
 
 
155
 
 
156
 
 
157
 
%% sti(Data, Addr, Offs) ->  format3b(3, Data, 16#04, Addr, Offs).
158
 
%% st(Data, Addr, Offs) ->   format3a(3, Data, 16#04, Addr, 0, Offs).
159
 
stb(Data, Addr, Offs) ->   format3a(3, Data, 2#000101, Addr, 0, Offs).
160
 
sth(Data, Addr, Offs) ->   format3a(3, Data, 2#000110, Addr, 0, Offs).
161
 
stw(Data, Addr, Offs) ->   format3a(3, Data, 2#000100, Addr, 0, Offs).
162
 
stx(Data, Addr, Offs) ->   format3a(3, Data, 2#001110, Addr, 0, Offs).
163
 
stbi(Data, Addr, Offs) ->   format3b(3, Data, 2#000101, Addr, Offs).
164
 
sthi(Data, Addr, Offs) ->   format3b(3, Data, 2#000110, Addr, Offs).
165
 
stwi(Data, Addr, Offs) ->   format3b(3, Data, 2#000100, Addr, Offs).
166
 
stxi(Data, Addr, Offs) ->   format3b(3, Data, 2#001110, Addr, Offs).
167
 
 
168
 
ldi(Addr, Offs, Res) ->   format3b(3, Res, 16#00, Addr, Offs).
169
 
ld(Addr, Offs, Res)  ->   format3a(3, Res, 16#00, Addr, 0, Offs).
170
 
ldsb(Addr, Offs, Res)  ->   format3a(3, Res, 2#001001, Addr, 0, Offs).
171
 
ldsh(Addr, Offs, Res)  ->   format3a(3, Res, 2#001010, Addr, 0, Offs).
172
 
ldsw(Addr, Offs, Res)  ->   format3a(3, Res, 2#001000, Addr, 0, Offs).
173
 
ldub(Addr, Offs, Res)  ->   format3a(3, Res, 2#000001, Addr, 0, Offs).
174
 
lduh(Addr, Offs, Res)  ->   format3a(3, Res, 2#000010, Addr, 0, Offs).
175
 
%% lduw(Addr, Offs, Res)  ->   format3a(3, Res, 2#000000, Addr, 0, Offs).
176
 
ldx(Addr, Offs, Res)  ->   format3a(3, Res, 2#001011, Addr, 0, Offs).
177
 
ldsbi(Addr, Offs, Res)  ->   format3b(3, Res, 2#001001, Addr, Offs).
178
 
ldshi(Addr, Offs, Res)  ->   format3b(3, Res, 2#001010, Addr, Offs).
179
 
ldswi(Addr, Offs, Res)  ->   format3b(3, Res, 2#001000, Addr, Offs).
180
 
ldubi(Addr, Offs, Res)  ->   format3b(3, Res, 2#000001, Addr, Offs).
181
 
lduhi(Addr, Offs, Res)  ->   format3b(3, Res, 2#000010, Addr, Offs).
182
 
%% lduwi(Addr, Offs, Res)  ->   format3b(3, Res, 2#000000, Addr, Offs).
183
 
ldxi(Addr, Offs, Res)  ->   format3b(3, Res, 2#001011, Addr, Offs).
184
 
 
185
 
 
186
 
call(Addr)  ->            format1(Addr).
187
 
jumpli(To, Offs, Rd) ->   format3b(2, Rd, 16#38, To, Offs).
188
 
nop()   ->                format2a(0, 16#4, 0).
189
 
sethi(High22, Reg) ->     format2a(Reg, 16#4, High22).
190
 
rdy(Rd) ->                format3a(2, Rd, 2#101000, 0, 0, 0).
191
 
%% savei(Rs1, Imm, Rd) ->    format3b(2, Rd, 16#3c, Rs1, Imm).
192
 
%% restorei(Rs1, Imm, Rd)->  format3b(2, Rd, 16#3d, Rs1, Imm).
193
 
 
194
 
cc_bits(Cond) ->
195
 
    case Cond of
196
 
        'a'     -> 2#1000;
197
 
        'n'     -> 2#0000;
198
 
        'ne'    -> 2#1001;
199
 
        'e'     -> 2#0001;
200
 
        'g'     -> 2#1010;
201
 
        'le'    -> 2#0010;
202
 
        'ge'    -> 2#1011;
203
 
        'l'     -> 2#0011;
204
 
        'gu'    -> 2#1100;
205
 
        'leu'   -> 2#0100;
206
 
        'geu'   -> 2#1101;      % a.k.a. 'cc'
207
 
        'lu'    -> 2#0101;      % a.k.a. 'cs'
208
 
        'pos'   -> 2#1110;
209
 
        'neg'   -> 2#0110;
210
 
        'vc'    -> 2#1111;
211
 
        'vs'    -> 2#0111;
212
 
        _       -> exit({cond_not_handled,Cond})
213
 
    end.
214
 
 
215
 
%% fcc_bits(Cond) ->
216
 
%%   case Cond of
217
 
%%     'a'      ->  2#1000;
218
 
%%     'n'      ->  2#0000;
219
 
%%     'u' ->  2#0111;
220
 
%%     'g'      ->  2#0110;
221
 
%%     'ug' -> 2#0101;
222
 
%%     'l'      ->  2#0100;
223
 
%%     'ul' -> 2#0011;
224
 
%%     'lg' -> 2#0010;
225
 
%%     'ne' -> 2#0001;
226
 
%%     'e'      ->  2#1001;
227
 
%%     'ue' -> 2#1010;
228
 
%%     'ge' -> 2#1011;
229
 
%%     'uge'-> 2#1100;  
230
 
%%     'le' -> 2#1101;
231
 
%%     'ule'-> 2#1110;
232
 
%%     'o'      ->  2#1111;
233
 
%%     _        -> exit({fcc_cond_not_handled,Cond})
234
 
%%   end.
235
 
 
236
 
 
237
 
%% rcc_bits(RCond) ->           % for BPr and CMOVr insns
238
 
%%     case RCond of
239
 
%%      'z'     -> 2#001;
240
 
%%      'lez'   -> 2#010;
241
 
%%      'lz'    -> 2#011;
242
 
%%      'nz'    -> 2#101;
243
 
%%      'gz'    -> 2#110;
244
 
%%      'gez'   -> 2#111;
245
 
%%      _       -> exit({rcond_not_handled,RCond})
246
 
%%     end.
247
 
 
248
 
%% for SPARC V7/V8 compatibility
249
 
%% bicc(Cond, Annul, Disp) ->           % b<cond><,annul> <disp>
250
 
%%   format2b(Annul, Cond, 2#010, Disp).
251
 
 
252
 
%% only for SPARC V9
253
 
bpcc(Cond, Annul, Pred, Disp) ->        % bp<cond><,annul><,pred> <disp>
254
 
  format2c(Annul, Cond, 2#001, 0, 0, Pred, Disp).
255
 
 
256
 
%% for SPARC V7/V8 compatibility
257
 
%% fbfcc(Cond, Annul, Disp) ->          % fb<cond><,annul><,pred> <disp>
258
 
%%  format2b(Annul, Cond, 2#110, Disp).
259
 
 
260
 
%% %% only for SPARC V9
261
 
%% fbpfcc(N, Cond, Annul, Pred, Disp) ->        
262
 
%%   case N of 
263
 
%%     0 -> fbpfcc0(Cond, Annul, Pred, Disp);
264
 
%%     1 -> fbpfcc1(Cond, Annul, Pred, Disp);
265
 
%%     2 -> fbpfcc2(Cond, Annul, Pred, Disp);
266
 
%%     3 -> fbpfcc3(Cond, Annul, Pred, Disp)
267
 
%%   end.
268
 
      
269
 
%% fbpfcc0(Cond, Annul, Pred, Disp) ->
270
 
%%     format2c(Annul, Cond, 2#101, 0, 0, Pred, Disp).
271
 
%% fbpfcc1(Cond, Annul, Pred, Disp) ->
272
 
%%     format2c(Annul, Cond, 2#101, 0, 1, Pred, Disp).
273
 
%% fbpfcc2(Cond, Annul, Pred, Disp) ->
274
 
%%     format2c(Annul, Cond, 2#101, 1, 0, Pred, Disp).
275
 
%% fbpfcc3(Cond, Annul, Pred, Disp) ->
276
 
%%     format2c(Annul, Cond, 2#101, 1, 1, Pred, Disp).
277
 
 
278
 
 
279
 
 
280
 
%% % only for SPARC V9
281
 
%% bpr(RCond, Annul, Pred, Reg, Disp) ->        % bpr<cond><,annul><,pred> <reg>,<disp>
282
 
%%     format2d(Annul, RCond, 2#011, Disp, Pred, Reg).
283
 
 
284
 
sll(Val, Shreg, Res) ->   format3a(2, Res, 16#25, Val, 0, Shreg).
285
 
sllx(Val, Shreg, Res) ->  format3ax(2, Res, 16#25, Val, 0, Shreg).
286
 
slli(Val, Shcnt, Res) ->  format3b(2, Res, 16#25, Val, Shcnt).
287
 
sllix(Val, Shcnt, Res) -> format3bx(2, Res, 16#25, Val, Shcnt).
288
 
srl(Val, Shreg, Res) ->   format3a(2, Res, 16#26, Val, 0, Shreg).
289
 
srli(Val, Shcnt, Res) ->  format3b(2, Res, 16#26, Val, Shcnt).
290
 
sra(Val, Shreg, Res) ->   format3a(2, Res, 16#27, Val, 0, Shreg).
291
 
srai(Val, Shcnt, Res) ->  format3b(2, Res, 16#27, Val, Shcnt).
292
 
srlx(Val, Shreg, Res) ->   format3ax(2, Res, 16#26, Val, 0, Shreg).
293
 
srlix(Val, Shcnt, Res) ->  format3bx(2, Res, 16#26, Val, Shcnt).
294
 
srax(Val, Shreg, Res) ->   format3ax(2, Res, 16#27, Val, 0, Shreg).
295
 
sraix(Val, Shcnt, Res) ->  format3bx(2, Res, 16#27, Val, Shcnt).
296
 
 
297
 
add(Op1, Op2, Res) ->     format3a(2, Res, 16#00, Op1, 0, Op2).
298
 
addi(Op1, Imm, Res) ->    format3b(2, Res, 16#00, Op1, Imm).
299
 
addcc(Op1, Op2, Res) ->   format3a(2, Res, 16#10, Op1, 0, Op2).
300
 
addicc(Op1, Imm, Res) ->  format3b(2, Res, 16#10, Op1, Imm).
301
 
addc(Op1, Op2, Res) ->    format3a(2, Res, 2#001000, Op1, 0, Op2).
302
 
addci(Op1, Imm, Res) ->   format3b(2, Res, 2#001000, Op1, Imm).
303
 
%% addccc(Op1, Op2, Res) ->  format3a(2, Res, 2#011000, Op1, 0, Op2).
304
 
%% addcicc(Op1, Imm, Res) -> format3b(2, Res, 2#011000, Op1, Imm).
305
 
 
306
 
sub(Op1, Op2, Res) ->     format3a(2, Res, 16#04, Op1, 0, Op2).
307
 
subi(Op1, Imm, Res) ->    format3b(2, Res, 16#04, Op1, Imm).
308
 
subcc(Op1, Op2, Res) ->   format3a(2, Res, 16#14, Op1, 0, Op2).
309
 
subicc(Op1, Imm, Res) ->  format3b(2, Res, 16#14, Op1, Imm).
310
 
subc(Op1, Op2, Res) ->    format3a(2, Res, 16#12, Op1, 0, Op2).
311
 
subci(Op1, Imm, Res) ->   format3b(2, Res, 16#12, Op1, Imm).
312
 
%% subccc(Op1, Op2, Res) ->  format3a(2, Res, 16#28, Op1, 0, Op2).
313
 
%% subcicc(Op1, Imm, Res) -> format3b(2, Res, 16#28, Op1, Imm).
314
 
 
315
 
and_op(Op1, Op2, Res) ->     format3a(2, Res, 16#01, Op1, 0, Op2).
316
 
andi(Op1, Imm, Res) ->    format3b(2, Res, 16#01, Op1, Imm).
317
 
andcc(Op1, Op2, Res) ->   format3a(2, Res, 16#11, Op1, 0, Op2).
318
 
andicc(Op1, Imm, Res) ->  format3b(2, Res, 16#11, Op1, Imm).
319
 
 
320
 
andn(Op1, Op2, Res) ->     format3a(2, Res, 16#05, Op1, 0, Op2).
321
 
andni(Op1, Imm, Res) ->    format3b(2, Res, 16#05, Op1, Imm).
322
 
andncc(Op1, Op2, Res) ->   format3a(2, Res, 16#15, Op1, 0, Op2).
323
 
andnicc(Op1, Imm, Res) ->  format3b(2, Res, 16#15, Op1, Imm).
324
 
 
325
 
or_op(Op1, Op2, Res) ->      format3a(2, Res, 16#02, Op1, 0, Op2).
326
 
ori(Op1, Imm, Res) ->     format3b(2, Res, 16#02, Op1, Imm).
327
 
orcc(Op1, Op2, Res) ->    format3a(2, Res, 16#12, Op1, 0, Op2).
328
 
oricc(Op1, Imm, Res) ->   format3b(2, Res, 16#12, Op1, Imm).
329
 
 
330
 
xor_op(Op1, Op2, Res) ->     format3a(2, Res, 16#03, Op1, 0, Op2).
331
 
xori(Op1, Imm, Res) ->    format3b(2, Res, 16#03, Op1, Imm).
332
 
xnor_op(Op1, Op2, Res) ->  format3a(2, Res, 16#07, Op1, 0, Op2).
333
 
xnori(Op1, Imm, Res) ->    format3b(2, Res, 16#07, Op1, Imm).
334
 
xorcc(Op1, Op2, Res) ->   format3a(2, Res, 16#13, Op1, 0, Op2).
335
 
xoricc(Op1, Imm, Res) ->  format3b(2, Res, 16#13, Op1, Imm).
336
 
 
337
 
%% taddcc(Rs1, Rs2, Rd) ->              format3a(2, Rd, 16#20, Rs1, 0, Rs2).
338
 
%% taddcci(Rs1, Simm13, Rd) ->  format3b(2, Rd, 16#20, Rs1, Simm13).
339
 
%% tsubcc(Rs1, Rs2, Rd) ->              format3a(2, Rd, 16#21, Rs1, 0, Rs2).
340
 
%% tsubcci(Rs1, Simm13, Rd) ->  format3b(2, Rd, 16#21, Rs1, Simm13).
341
 
 
342
 
smul(Rs1, Rs2, Rd) -> format3a(2, Rd, 2#001011, Rs1, 0, Rs2).
343
 
smuli(Rs1, Simm13, Rd) -> format3b(2, Rd, 2#001011, Rs1, Simm13).
344
 
%% smulcc(Rs1, Rs2, Rd) -> format3a(2, Rd, 2#011011, Rs1, 0, Rs2).
345
 
%% smulicc(Rs1, Simm13, Rd) -> format3b(2, Rd, 2#011011, Rs1, Simm13).
346
 
 
347
 
fpop1(Rs1,Opf,Rs2,Rd) ->        format3a(2#10, Rd, 2#110100, Rs1, Opf, Rs2).
348
 
%% fpop2(Rs1,Opf,Rs2,Rd) ->        format3a(2#10, Rd, 2#110101, Rs1, Opf, Rs2).
349
 
 
350
 
%% fxtos(Rs2, Rd) ->               fpop1(0,2#010000100,Rs2,Rd).
351
 
%% fxtod(Rs2, Rd) ->               fpop1(0,2#010001000,Rs2,Rd).
352
 
%% fxtoq(Rs2, Rd) ->               fpop1(0,2#010001100,Rs2,Rd).
353
 
fitos(Rs2, Rd) ->               fpop1(0,2#011000100,Rs2,Rd).
354
 
fitod(Rs2, Rd) ->               fpop1(0,2#011001000,Rs2,Rd).
355
 
fitoq(Rs2, Rd) ->               fpop1(0,2#011001100,Rs2,Rd).
356
 
 
357
 
%% fstox(Rs2, Rd) ->               fpop1(0,2#010000001,Rs2,Rd).
358
 
%% fdtox(Rs2, Rd) ->               fpop1(0,2#010000010,Rs2,Rd).
359
 
%% fqtox(Rs2, Rd) ->               fpop1(0,2#010000011,Rs2,Rd).
360
 
%% fstoi(Rs2, Rd) ->               fpop1(0,2#011010001,Rs2,Rd).
361
 
%% fdtoi(Rs2, Rd) ->               fpop1(0,2#011010010,Rs2,Rd).
362
 
%% fqtoi(Rs2, Rd) ->               fpop1(0,2#011010011,Rs2,Rd).
363
 
  
364
 
%% fstod(Rs2, Rd) ->               fpop1(0,2#011001001,Rs2,Rd).
365
 
%% fstoq(Rs2, Rd) ->               fpop1(0,2#011001101,Rs2,Rd).
366
 
%% fdtos(Rs2, Rd) ->               fpop1(0,2#011000110,Rs2,Rd).
367
 
%% fdtoq(Rs2, Rd) ->               fpop1(0,2#011001110,Rs2,Rd).
368
 
%% fqtos(Rs2, Rd) ->               fpop1(0,2#011000111,Rs2,Rd).
369
 
%% fqtod(Rs2, Rd) ->               fpop1(0,2#011001011,Rs2,Rd).
370
 
  
371
 
fmovs(Rs2, Rd) ->               fpop1(0,2#000000001,Rs2,Rd).
372
 
fnegs(Rs2, Rd) ->               fpop1(0,2#000000101,Rs2,Rd).
373
 
fabss(Rs2, Rd) ->               fpop1(0,2#000001001,Rs2,Rd).
374
 
fmovd(Rs2, Rd) ->               fpop1(0,2#000000010,Rs2,Rd).
375
 
fnegd(Rs2, Rd) ->               fpop1(0,2#000000110,Rs2,Rd).
376
 
fabsd(Rs2, Rd) ->               fpop1(0,2#000001010,Rs2,Rd).
377
 
fmovq(Rs2, Rd) ->               fpop1(0,2#000000011,Rs2,Rd).
378
 
fnegq(Rs2, Rd) ->               fpop1(0,2#000000111,Rs2,Rd).
379
 
fabsq(Rs2, Rd) ->               fpop1(0,2#000001011,Rs2,Rd).
380
 
 
381
 
%% fsqrts(Rs2, Rd) ->              fpop1(0,2#000101001,Rs2,Rd).
382
 
%% fsqrtd(Rs2, Rd) ->              fpop1(0,2#000101010,Rs2,Rd).
383
 
%% fsqrtq(Rs2, Rd) ->              fpop1(0,2#000101011,Rs2,Rd).
384
 
 
385
 
fadds(Rs1, Rs2, Rd) ->          fpop1(Rs1,2#001000001,Rs2,Rd).
386
 
faddd(Rs1, Rs2, Rd) ->          fpop1(Rs1,2#001000010,Rs2,Rd).
387
 
faddq(Rs1, Rs2, Rd) ->          fpop1(Rs1,2#001000011,Rs2,Rd).
388
 
fsubs(Rs1, Rs2, Rd) ->          fpop1(Rs1,2#001000101,Rs2,Rd).
389
 
fsubd(Rs1, Rs2, Rd) ->          fpop1(Rs1,2#001000110,Rs2,Rd).
390
 
fsubq(Rs1, Rs2, Rd) ->          fpop1(Rs1,2#001000111,Rs2,Rd).
391
 
 
392
 
fmuls(Rs1, Rs2, Rd) ->          fpop1(Rs1,2#001001001,Rs2,Rd).
393
 
fmuld(Rs1, Rs2, Rd) ->          fpop1(Rs1,2#001001010,Rs2,Rd).
394
 
fmulq(Rs1, Rs2, Rd) ->          fpop1(Rs1,2#001001011,Rs2,Rd).
395
 
%% fsmuld(Rs1, Rs2, Rd) ->         fpop1(Rs1,2#001101001,Rs2,Rd).
396
 
%% fdmulq(Rs1, Rs2, Rd) ->         fpop1(Rs1,2#001101110,Rs2,Rd).
397
 
fdivs(Rs1, Rs2, Rd) ->          fpop1(Rs1,2#001001101,Rs2,Rd).
398
 
fdivd(Rs1, Rs2, Rd) ->          fpop1(Rs1,2#001001110,Rs2,Rd).
399
 
fdivq(Rs1, Rs2, Rd) ->          fpop1(Rs1,2#001001111,Rs2,Rd).
400
 
 
401
 
%% Uses fcc0
402
 
%% fcmps(Rs1, Rs2) ->              fpop2(Rs1,2#001010001,Rs2,0).
403
 
%% fcmpd(Rs1, Rs2) ->              fpop2(Rs1,2#001010010,Rs2,0).
404
 
%% fcmpq(Rs1, Rs2) ->              fpop2(Rs1,2#001010011,Rs2,0).
405
 
%% fcmpes(Rs1, Rs2) ->             fpop2(Rs1,2#001010101,Rs2,0).
406
 
%% fcmped(Rs1, Rs2) ->             fpop2(Rs1,2#001010110,Rs2,0).
407
 
%% fcmpeq(Rs1, Rs2) ->             fpop2(Rs1,2#001010111,Rs2,0).
408
 
 
409
 
%% fcmps(N, Rs1, Rs2) ->           fpcn(N,2#001010001,Rs1,Rs2).
410
 
%% fcmpd(N, Rs1, Rs2) ->           fpcn(N,2#001010010,Rs1,Rs2).
411
 
%% fcmpq(N, Rs1, Rs2) ->           fpcn(N,2#001010011,Rs1,Rs2).
412
 
%% fcmpes(N, Rs1, Rs2) ->          fpcn(N,2#001010101,Rs1,Rs2).
413
 
%% fcmped(N, Rs1, Rs2) ->          fpcn(N,2#001010110,Rs1,Rs2).
414
 
%% fcmpeq(N, Rs1, Rs2) ->          fpcn(N,2#001010111,Rs1,Rs2).
415
 
 
416
 
stf(Rd, Rs1, Rs2) ->            format3a(2#11, Rd, 2#100100, Rs1, 0, Rs2).
417
 
stfi(Rd, Rs1, Offset) ->        format3b(2#11, Rd, 2#100100, Rs1, Offset).
418
 
stdf(Rd, Rs1, Rs2) ->           format3a(2#11, Rd, 2#100111, Rs1, 0, Rs2).
419
 
stdfi(Rd, Rs1, Offset) ->       format3b(2#11, Rd, 2#100111, Rs1, Offset).
420
 
stqf(Rd, Rs1, Rs2) ->           format3a(2#11, Rd, 2#100110, Rs1, 0, Rs2).
421
 
stqfi(Rd, Rs1, Offset) ->       format3b(2#11, Rd, 2#100110, Rs1, Offset).
422
 
%% stfsr(Rd, Rs1, Rs2) ->          format3a(2#11, Rd, 2#100101, Rs1, 0, Rs2).
423
 
%% stfsri(Rd, Rs1, Offset) ->      format3b(2#11, Rd, 2#100101, Rs1, Offset).
424
 
 
425
 
ldf(Rd, Rs1, Rs2) ->            format3a(2#11, Rd, 2#100000, Rs1, 0, Rs2).
426
 
ldfi(Rd, Rs1, Offset) ->        format3b(2#11, Rd, 2#100000, Rs1, Offset).
427
 
lddf(Rd, Rs1, Rs2) ->           format3a(2#11, Rd, 2#100011, Rs1, 0, Rs2).
428
 
lddfi(Rd, Rs1, Offset) ->       format3b(2#11, Rd, 2#100011, Rs1, Offset).
429
 
ldqf(Rd, Rs1, Rs2) ->           format3a(2#11, Rd, 2#100010, Rs1, 0, Rs2).
430
 
ldqfi(Rd, Rs1, Offset) ->       format3b(2#11, Rd, 2#100010, Rs1, Offset).
431
 
%% ldxfsr(Rs1, Rs2) ->             format3a(2#11,  1, 2#100001, Rs1, 0, Rs2).
432
 
%% ldxfsri(Rs1, Offset) ->         format3b(2#11,  1, 2#100001, Rs1, Offset).
433
 
 
434
 
 
435
 
%% fpcn(N, Opf, Rs1, Rs2) -> 
436
 
%%   case N of
437
 
%%     0 -> fpc0(Opf, Rs1, Rs2);
438
 
%%     1 -> fpc1(Opf, Rs1, Rs2);
439
 
%%     2 -> fpc2(Opf, Rs1, Rs2);
440
 
%%     3 -> fpc3(Opf, Rs1, Rs2)
441
 
%%   end.
442
 
      
443
 
%% fpc0(Opf, Rs1, Rs2) ->          format3c(2#10, 2#00000, 2#110101, Rs1, Opf, Rs2).
444
 
%% fpc1(Opf, Rs1, Rs2) ->          format3c(2#10, 2#00001, 2#110101, Rs1, Opf, Rs2).
445
 
%% fpc2(Opf, Rs1, Rs2) ->          format3c(2#10, 2#00010, 2#110101, Rs1, Opf, Rs2).
446
 
%% fpc3(Opf, Rs1, Rs2) ->          format3c(2#10, 2#00011, 2#110101, Rs1, Opf, Rs2).
447
 
 
448
 
 
449
 
%% make_bitlist(sethi,hi) ->
450
 
%%   bitlist_sethi(21);
451
 
%% make_bitlist(alu,low) ->
452
 
%%   bitlist_lowlow(10);
453
 
%% make_bitlist(call,low) ->
454
 
%%   bitlist_call(29);
455
 
%% make_bitlist(I,Type) -> 
456
 
%%   exit({combination_not_handled,I,Type}).
457
 
%% 
458
 
%% bitlist_sethi(0) -> [{10,0}];
459
 
%% bitlist_sethi(N) ->
460
 
%%   [{10+N,N}|bitlist_sethi(N-1)].
461
 
%% 
462
 
%% bitlist_lowlow(0) -> [{0,0}];
463
 
%% bitlist_lowlow(N) ->
464
 
%%   [{N,N}|bitlist_lowlow(N-1)].
465
 
%% 
466
 
%% bitlist_call(0) -> [{2,0}];
467
 
%% bitlist_call(N) ->
468
 
%%   [{N+2,N}|bitlist_call(N-1)].