← Back to branch summary

~ubuntu-branches/debian/squeeze/erlang/squeeze

« back to all changes in this revision

Viewing changes to lib/hipe/sparc/hipe_sparc_frame.erl

  • Committer: Bazaar Package Importer
  • Author(s): Erlang Packagers, Sergei Golovan
  • Date: 2006-12-03 17:07:44 UTC
  • mfrom: (2.1.11 feisty)
  • Revision ID: james.westby@ubuntu.com-20061203170744-rghjwupacqlzs6kv
Tags: 1:11.b.2-4
[ Sergei Golovan ]
Fixed erlang-base and erlang-base-hipe prerm scripts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/hipe/sparc/hipe_sparc_frame.erl
24
24
%%  History  :  * 2001-10-25 Erik Johansson (happi@csd.uu.se): 
25
25
%%               Created.
26
26
%%  CVS      :
27
 
%%              $Author: richardc $
28
 
%%              $Date: 2002/10/01 12:47:16 $
29
 
%%              $Revision: 1.22 $
 
27
%%              $Author: kostis $
 
28
%%              $Date: 2006/09/14 15:33:58 $
 
29
%%              $Revision: 1.38 $
30
30
%% ====================================================================
31
31
%%  Exports  :
32
32
%%
50
50
 
51
51
%% -define(DO_ASSERT,true).
52
52
-include("../main/hipe.hrl").
 
53
-include("hipe_sparc.hrl").
53
54
-include("../rtl/hipe_literals.hrl").
54
 
-include("../util/hipe_vector.hrl").
55
55
 
56
56
-define(MK_CP_REG(),(hipe_sparc:mk_reg(hipe_sparc_registers:return_address()))).
57
57
-define(MK_SP_REG(),(hipe_sparc:mk_reg(hipe_sparc_registers:stack_pointer()))).
60
60
-define(IS_SPILLED(Reg,Map),hipe_temp_map:is_spilled(hipe_sparc:reg_nr(Reg),Map)).
61
61
 
62
62
frame(Cfg, TempMap, FpMap, NextSpillPos, _Options) ->
63
 
  %%  io:format("~p\n",[TempMap]),
 
63
  %% io:format("~p\n",[TempMap]),
64
64
  rewrite(Cfg, TempMap, FpMap, NextSpillPos).
65
65
 
66
 
 
67
66
rewrite(Cfg, TempMap, FpMap, NextSpillPos) ->
68
 
  %%  hipe_sparc_cfg:pp(Cfg),
69
 
 
 
67
  %% hipe_sparc_cfg:pp(Cfg),
70
68
  Sparc = hipe_sparc_cfg:linearize(Cfg),
71
69
  Arity = hipe_sparc:sparc_arity(Sparc),
72
70
  Code = hipe_sparc:sparc_code(Sparc),
73
 
 
74
 
  
75
71
  %% ConvNeed is added if there are any conv_fp instructions.
76
72
  ConvNeed = 
77
73
    case get(hipe_inline_fp) of
78
74
      true ->  
79
 
        lists:foldl(
80
 
          fun(I, Acc) -> case hipe_sparc:is_conv_fp(I) of true->1; _->Acc end
81
 
          end, 0, Code);
82
 
      _->
 
75
        lists:foldl(fun(I, Acc) -> 
 
76
                        case hipe_sparc:is_conv_fp(I) of true -> 1; _ -> Acc end
 
77
                    end, 0, Code);
 
78
      _ ->
83
79
        0
84
80
    end,
85
81
  
96
92
  CP = ?MK_CP_REG(),
97
93
  NewStart = hipe_sparc:label_create_new(),
98
94
 
99
 
  {StackTestCode, StackIncCode} =  
 
95
  {StackTestCode, StackIncCode} =
100
96
    gen_stack_test(StackNeed, SP, CP, Arity, Cfg),
101
 
  AllocCode = gen_alloc_code(Need*4, SP),
 
97
  NeedInBytes = Need bsl ?log2_wordsize,
 
98
  AllocCode = gen_alloc_code(NeedInBytes, SP),
102
99
 
103
100
  EntryCode = 
104
101
    [NewStart,
113
110
     %% Rewrite instructions to use physical registers 
114
111
     %% instead of temps.
115
112
     %% Also, handle pseudo instructions.
116
 
     if is_tuple(TempMap) ->
117
 
         [rewrite_instr(I, TempMap, FpMap, Need, Arity, RetLabel) || 
118
 
           I <- Code];
 
113
     if is_tuple(TempMap) -> % XXX: can someone please explain the logic here?
 
114
         [rewrite_instr(I, TempMap, FpMap, Need, Arity, RetLabel) || I <- Code];
119
115
        true ->
120
116
         rewrite_instrs(Code, [], TempMap, FpMap, Need, Arity, RetLabel)
121
117
     end,
126
122
  %% Create a new CFG
127
123
  NewSparc = hipe_sparc:sparc_code_update(Sparc, lists:flatten(NewCode)),
128
124
  CFG0 = hipe_sparc_cfg:init(NewSparc),
129
 
  CFG1 = hipe_sparc_cfg:var_range_update(CFG0, {0, 31}),
130
125
  %% io:format("\n\n\n\n\n\n\n\nAfter frame\n"),
131
126
  %%  hipe_sparc_cfg:pp(CFG1),
132
 
  CFG1.
 
127
  CFG0.
133
128
 
134
129
rewrite_instrs([I|Is], TempMap, TempMaps, FpMap, Need, Arity, RetLabel) ->
135
130
  NewMap = 
136
131
    case hipe_sparc:is_label(I) of
137
132
      true ->
138
 
%%      io:format("~w\n",[?vector_get(hipe_sparc:label_name(I),TempMaps)]),
139
 
        ?vector_get(hipe_sparc:label_name(I),TempMaps);
 
133
%%      io:format("~w\n",[hipe_vectors:get(TempMaps, hipe_sparc:label_name(I)-1)]),
 
134
        hipe_vectors:get(TempMaps, hipe_sparc:label_name(I)-1);
140
135
      false ->
141
136
        TempMap
142
137
    end,
143
138
  [rewrite_instr(I, NewMap, FpMap, Need, Arity, RetLabel) |
144
139
   rewrite_instrs(Is, NewMap, TempMaps, FpMap, Need, Arity, RetLabel)];
145
 
rewrite_instrs([],_,_,_,_,_,_) -> [].
146
 
    
 
140
rewrite_instrs([],_,_,_,_,_,_) ->
 
141
  [].
147
142
 
148
143
rewrite_instr(I, TempMap, FpMap, Need, Arity, RetLabel) ->
149
144
  %%  io:format("\n\n~w -> \n",[I]),
153
148
  I2.
154
149
 
155
150
remap_fp_regs(I, FpMap) ->
156
 
  case hipe_sparc:type(I) of
157
 
    %% These instructions handles their own remapping.
158
 
    fmov -> I;
159
 
    pseudo_spill-> I;
160
 
    pseudo_unspill-> I;
161
 
    _->
 
151
  case I of
 
152
    %% These instructions handle their own remapping.
 
153
    #fmove{} -> I;
 
154
    #pseudo_spill{} -> I;
 
155
    #pseudo_unspill{} -> I;
 
156
    _ ->
162
157
      Defs = hipe_sparc:fp_reg_defines(I),
163
 
      NewI = remap_fp(remap_fp(I, Defs, FpMap), 
 
158
      NewI = remap_fp(remap_fp(I, Defs, FpMap),
164
159
                      hipe_sparc:fp_reg_uses(I),
165
160
                      FpMap),
166
161
      NewI
167
162
  end.
168
163
 
169
164
rewrite_instr2(I, TempMap, FpMap, Need, Arity, RetLabel) ->
170
 
 
171
 
  case hipe_sparc:type(I) of
172
 
    pseudo_push ->
 
165
  case I of
 
166
    #pseudo_push{} ->
173
167
      ?EXIT({pseudo_push, not_supportet_any_more,I});
174
 
    pseudo_pop ->
 
168
    #pseudo_pop{} ->
175
169
      Temp = hipe_sparc:pseudo_pop_reg(I),
176
170
      Reg = map(Temp,TempMap),
177
 
      %% Arg position on stack = -(arg index + need)*4 
178
 
      Pos = - ((hipe_sparc:imm_value(
179
 
                  hipe_sparc:pseudo_pop_index(I)) +
180
 
                Need) * 4),
 
171
      %% Arg position on stack = -(arg index + need)*4
 
172
      ArgIndex = hipe_sparc:imm_value(hipe_sparc:pseudo_pop_index(I)),
 
173
      Pos = - ((ArgIndex + Need) bsl ?log2_wordsize),
181
174
      gen_stack_load(Pos, Reg);
182
 
    move ->
 
175
    #move{} ->
183
176
      rewrite_move(I, TempMap);
184
 
    pseudo_spill ->
 
177
    #pseudo_spill{} ->
185
178
      rewrite_spill(I, TempMap, FpMap);
186
 
    pseudo_unspill ->
 
179
    #pseudo_unspill{} ->
187
180
      rewrite_unspill(I, TempMap, FpMap);
188
 
 
189
 
    call_link ->
 
181
    #call_link{} ->
190
182
      rewrite_call(I, TempMap, Need, Arity);
191
 
 
192
 
    pseudo_return ->
 
183
    #pseudo_return{} ->
193
184
      %% Note we assume that the arguments to return have been 
194
185
      %% mapped to physical register in the translation RTL->SPARC.
195
186
 
196
187
      %% XXX: Fix if we start using multiple return values
197
188
      %%      Acctually just fix gen_ret/2 to annotate the
198
189
      %%      jmp with the live registers...
199
 
      case length(hipe_sparc:pseudo_return_regs(I)) == 1 of
 
190
      case length(hipe_sparc:pseudo_return_regs(I)) =:= 1 of
200
191
        true -> %% Just one retval all is ok
201
 
          hipe_sparc:goto_create(RetLabel,[return]);
 
192
          hipe_sparc:goto_create(RetLabel);
202
193
        false ->
203
194
          %% Number of retvalues not 1.
204
195
          ?EXIT({multiple_retvals_not_handled,I})
205
196
      end;
206
 
 
207
 
    pseudo_enter ->
 
197
    #pseudo_enter{} ->
208
198
      rewrite_enter(I, TempMap, Need, Arity);
209
 
 
210
 
    fmov ->
211
 
      rewrite_fmov(I, TempMap, FpMap);
212
 
    load_fp -> 
 
199
    #fmove{} ->
 
200
      rewrite_fmove(I, TempMap, FpMap);
 
201
    #load_fp{} -> 
213
202
      rewrite_load_fp(I, TempMap);
214
 
    store_fp -> 
 
203
    #store_fp{} -> 
215
204
      rewrite_store_fp(I, TempMap);
216
 
    conv_fp ->
 
205
    #conv_fp{} ->
217
206
      NewI = map_temps(I, TempMap),
218
207
      Source = hipe_sparc:conv_fp_src(NewI),
219
208
      Dest = hipe_sparc:conv_fp_dest(NewI),
220
209
      Off = hipe_sparc:mk_imm(get_offset(Need - 1)),
221
210
      SP = hipe_sparc:mk_reg(hipe_sparc_registers:stack_pointer()),
222
 
 
223
 
      [hipe_sparc:store_create(SP, Off, w, Source, []),
224
 
       hipe_sparc:load_fp_create(Dest, 32, single, SP, Off, []),
 
211
      [hipe_sparc:store_create(SP, Off, w, Source),
 
212
       hipe_sparc:load_fp_create(Dest, 32, single, SP, Off),
225
213
       hipe_sparc:conv_fp_create(Dest, Dest)];
226
 
        
227
214
    _ -> 
228
215
      %% All other instructions.
229
216
      %% No special handling, just map the temps to regs or spill positions.
244
231
  Args = hipe_sparc:pseudo_enter_args(I), 
245
232
  RegArgs = lists:sublist(Args,1,NoRegArgs),
246
233
  %% Get target (closure or address).
247
 
  {Target,GetTInstr}
248
 
    = case hipe_sparc:pseudo_enter_type(I) of
249
 
        closure ->
250
 
          {map(hipe_sparc:pseudo_enter_target(I), TempMap),[]};
251
 
        _ ->
252
 
          TL = hipe_sparc:pseudo_enter_target(I),
253
 
          TR = ?MK_TEMP_REG(),
254
 
          TI = hipe_sparc:load_address_create(TR,TL,
255
 
                                              function,[]),
256
 
          {TR,TI}
257
 
      end,
258
 
  
 
234
  T = hipe_sparc:pseudo_enter_target(I),
 
235
  {Target,GetTInstr} =
 
236
    case hipe_sparc:pseudo_enter_is_known(I) of
 
237
      false ->
 
238
        {map(T, TempMap),[]};
 
239
      true ->
 
240
        TR = ?MK_TEMP_REG(),
 
241
        TT = case hipe_sparc:pseudo_enter_type(I) of
 
242
               remote -> remote_function;
 
243
               not_remote -> local_function
 
244
             end,
 
245
        TI = hipe_sparc:load_address_create(TR, T, TT),
 
246
        {TR,TI}
 
247
    end,
259
248
  CP = ?MK_CP_REG(),
260
249
 
261
250
  %% The code for enter.
262
251
  [
263
252
   %% Restore CP from stack
264
253
   %% TODO: Do this only in non-leaf functions.
265
 
   gen_stack_load(-(Need*4),CP),
 
254
   gen_stack_load(-(Need bsl ?log2_wordsize), CP),
266
255
   
267
256
   %% If arguments to the called function spill over to the 
268
257
   %% stack, do some shuffling.
271
260
     true ->
272
261
       enter_stack_args(Args, Need, TempMap, ArgsOnStack);
273
262
     false ->
274
 
       gen_dealloc_code((ArgsOnStack+Need)*4)
 
263
       gen_dealloc_code((ArgsOnStack+Need) bsl ?log2_wordsize)
275
264
   end,
276
265
   
277
266
   %% Jump to the target function.
279
268
   hipe_sparc:jmp_create(Target, hipe_sparc:mk_imm(0), 
280
269
                         [map(R,TempMap)||R <- RegArgs] , [])].
281
270
 
282
 
map_temps(I, TempMap)->
 
271
map_temps(I, TempMap) ->
283
272
  Defs = hipe_sparc:keep_registers(hipe_sparc:defines(I)),
284
273
  Uses = hipe_sparc:keep_registers(hipe_sparc:uses(I)),
285
274
  remap(remap(I, Defs, TempMap), Uses, TempMap).
286
275
 
287
 
 
288
276
rewrite_call(Call, TempMap, Need, Arity) ->
289
277
  I = set_stack_size(Call,Need, Arity),
290
278
  Args = hipe_sparc:call_link_args(I),
295
283
 
296
284
remap_call_regs(I, TempMap) ->
297
285
  Defs = hipe_sparc:keep_registers(hipe_sparc:defines(I)),
298
 
  ArgsInRegs = 
299
 
    lists:sublist(hipe_sparc:call_link_args(I), 
300
 
                  hipe_sparc_registers:register_args()),
301
 
 
302
 
  case hipe_sparc:call_link_type(I) of
303
 
    closure ->
 
286
  ArgsInRegs = lists:sublist(hipe_sparc:call_link_args(I), 
 
287
                             hipe_sparc_registers:register_args()),
 
288
  case hipe_sparc:call_link_is_known(I) of
 
289
    false ->
304
290
      Target = hipe_sparc:call_link_target(I),
305
291
      case ?IS_SPILLED(Target,TempMap) of
306
292
        true ->
307
 
          RemappedCall = 
308
 
            remap(I, [(Defs ++ ArgsInRegs)],TempMap),
 
293
          RemappedCall = remap(I, [(Defs ++ ArgsInRegs)],TempMap),
309
294
          Temp = ?MK_TEMP_REG(),
310
 
          Pos = get_spill_offset(hipe_temp_map:find(Target, TempMap)),
 
295
          Pos = get_spill_offset(hipe_temp_map:find(hipe_sparc:reg_nr(Target), TempMap)),
311
296
          [gen_stack_load(Pos, Temp),
312
297
           hipe_sparc:call_link_target_update(RemappedCall, Temp)];
313
298
        false ->
314
299
          remap(I, [Target | (Defs ++ ArgsInRegs)],TempMap)
315
300
      end;
316
 
    _ ->
 
301
    true ->
317
302
      remap(I,Defs ++ ArgsInRegs, TempMap)
318
303
  end.
319
304
 
320
305
 
321
306
%% ____________________________________________________________________
322
 
%%      
 
307
%%
323
308
%% Returns:     
324
309
%% Arguments:   
325
310
%% Description:  
342
327
      end;
343
328
    true ->
344
329
      SrcReg = hipe_sparc:reg_nr(Src),
345
 
 
346
 
  
347
330
      case {hipe_temp_map:is_spilled(SrcReg,TempMap),
348
331
            hipe_temp_map:is_spilled(DestReg,TempMap)} of
349
 
        {false,true} -> %% Spill
 
332
        {false,true} -> %% spill
350
333
          Pos = get_spill_offset(hipe_temp_map:find(DestReg, TempMap)),
351
334
          Reg = map(Src,TempMap),
352
335
          gen_stack_store(Pos, Reg);
353
 
        {true, false} -> %% unspill
 
336
        {true,false} -> %% unspill
354
337
          Pos = get_spill_offset(hipe_temp_map:find(SrcReg, TempMap)),
355
338
          Reg = map(Dest,TempMap),
356
339
          gen_stack_load(Pos, Reg);
382
365
        false ->
383
366
          %% Spilling a spilled reg...
384
367
          ?ASSERT(check_spill(SrcFpRegNr,FpMap,Pos,I)),
385
 
          hipe_sparc:comment_create({already_spilled,I},[]);
 
368
          hipe_sparc:comment_create({already_spilled,I});
386
369
        true -> %% Not spilled...
387
370
          Reg = map_fp(SrcReg, FpMap),
388
371
          gen_stack_store_fp(Pos, Reg)
393
376
        false ->
394
377
          %% Spilling a spilled reg...
395
378
          ?ASSERT(check_spill(SrcRegNr,TempMap,Pos,I)),
396
 
          hipe_sparc:comment_create({already_spilled,I},[]);
 
379
          hipe_sparc:comment_create({already_spilled,I});
397
380
        true -> %% Not spilled...
398
381
          Reg = map(SrcReg,TempMap),
399
382
          gen_stack_store(Pos, Reg)
417
400
        false ->
418
401
          %% Unspilling to a spilled fpreg...
419
402
          ?ASSERT(check_spill(DstFpRegNr,FpMap,Pos,I)),
420
 
          hipe_sparc:comment_create({already_unspilled,I},[]);
 
403
          hipe_sparc:comment_create({already_unspilled,I});
421
404
        true -> %% Not spilled...
422
405
          Reg = map_fp(DstReg, FpMap),
423
406
          gen_stack_load_fp(Pos, Reg)
427
410
      case hipe_temp_map:in_reg(DstRegNr,TempMap) of
428
411
        false -> %% Unspilling to a spilled reg.
429
412
          ?ASSERT(check_spill(DstRegNr,TempMap,Pos,I)),
430
 
          hipe_sparc:comment_create({already_unspilled,I},[]);
 
413
          hipe_sparc:comment_create({already_unspilled,I});
431
414
        true -> %% Not spilled.
432
415
          Reg = map(DstReg,TempMap),
433
416
          gen_stack_load(Pos,Reg)
442
425
  end.
443
426
-endif.
444
427
 
445
 
rewrite_fmov(I0, TempMap, FpMap)->
 
428
rewrite_fmove(I0, TempMap, FpMap)->
446
429
  I = map_temps(I0, TempMap),
447
 
  Src = hipe_sparc:fmov_src(I),
448
 
  Dest = hipe_sparc:fmov_dest(I),
 
430
  Src = hipe_sparc:fmove_src(I),
 
431
  Dest = hipe_sparc:fmove_dest(I),
449
432
  DestReg = hipe_sparc:fpreg_nr(Dest),
450
433
 
451
434
  case hipe_sparc:is_fpreg(Src) of
454
437
        true ->
455
438
          Pos = get_spill_offset(hipe_temp_map:find(DestReg, FpMap)),
456
439
          Reg = ?MK_TEMP_FPREG(),
457
 
          [hipe_sparc:fmov_dest_update(I,Reg)|
 
440
          [hipe_sparc:fmove_dest_update(I,Reg)|
458
441
           gen_stack_store_fp(Pos, Reg)];
459
442
        false ->
460
443
          remap_fp(I, [Dest], FpMap)
464
447
 
465
448
      case {hipe_temp_map:is_spilled(SrcReg,FpMap),
466
449
            hipe_temp_map:is_spilled(DestReg,FpMap)} of
467
 
        {false,true} -> %% Spill
 
450
        {false,true} -> %% spill
468
451
          Pos = get_spill_offset(hipe_temp_map:find(DestReg, FpMap)),
469
452
          Reg = map_fp(Src,FpMap),
470
453
          gen_stack_store_fp(Pos, Reg);
471
 
        {true, false} -> %% unspill
 
454
        {true,false} -> %% unspill
472
455
          Pos = get_spill_offset(hipe_temp_map:find(SrcReg, FpMap)),
473
456
          Reg = map_fp(Dest,FpMap),
474
457
          gen_stack_load_fp(Pos, Reg);
484
467
  end.  
485
468
 
486
469
rewrite_load_fp(I, TempMap)->
487
 
      NewI = map_temps(I, TempMap),
488
 
      Source = hipe_sparc:load_fp_src(NewI),
489
 
      Dest = hipe_sparc:load_fp_dest(NewI),
490
 
      Off = hipe_sparc:load_fp_off(NewI),
491
 
      Align = hipe_sparc:load_fp_align(NewI),
492
 
      case hipe_sparc:load_fp_type(NewI) of
493
 
        double ->
494
 
          Dest2 = hipe_sparc:mk_fpreg(hipe_sparc:fpreg_nr(Dest) + 1),
495
 
          case hipe_sparc:is_imm(Off) of
496
 
            true ->
497
 
              Off2 = hipe_sparc:mk_imm(hipe_sparc:imm_value(Off) + 4),
498
 
              [hipe_sparc:load_fp_create(Dest, Align, single, Source, Off, []),
499
 
               hipe_sparc:load_fp_create(Dest2, Align, single, Source, Off2,[])];
500
 
            _ -> %% The offset is a register
501
 
              [hipe_sparc:load_fp_create(Dest, Align, single, Source, Off, []),
502
 
               hipe_sparc:alu_create(Off, Off, '+', hipe_sparc:mk_imm(4), []),
503
 
               hipe_sparc:load_fp_create(Dest2, Align, single, Source, Off,[]),
504
 
               hipe_sparc:alu_create(Off, Off, '-', hipe_sparc:mk_imm(4), [])]
505
 
          end;
506
 
        _ ->
507
 
          NewI
508
 
      end.
509
 
 
 
470
  NewI = map_temps(I, TempMap),
 
471
  Source = hipe_sparc:load_fp_src(NewI),
 
472
  Dest = hipe_sparc:load_fp_dest(NewI),
 
473
  Off = hipe_sparc:load_fp_off(NewI),
 
474
  Align = hipe_sparc:load_fp_align(NewI),
 
475
  case hipe_sparc:load_fp_type(NewI) of
 
476
    double ->
 
477
      Dest2 = hipe_sparc:mk_fpreg(hipe_sparc:fpreg_nr(Dest) + 1),
 
478
      case hipe_sparc:is_imm(Off) of
 
479
        true ->
 
480
          Off2 = hipe_sparc:mk_imm(hipe_sparc:imm_value(Off) + 4),
 
481
          [hipe_sparc:load_fp_create(Dest, Align, single, Source, Off),
 
482
           hipe_sparc:load_fp_create(Dest2, Align, single, Source, Off2)];
 
483
        _ -> %% The offset is a register
 
484
          [hipe_sparc:load_fp_create(Dest, Align, single, Source, Off),
 
485
           hipe_sparc:alu_create(Off, Off, '+', hipe_sparc:mk_imm(4)),
 
486
           hipe_sparc:load_fp_create(Dest2, Align, single, Source, Off),
 
487
           hipe_sparc:alu_create(Off, Off, '-', hipe_sparc:mk_imm(4))]
 
488
      end;
 
489
    _ ->
 
490
      NewI
 
491
  end.
510
492
 
511
493
rewrite_store_fp(I, TempMap)->
512
 
      NewI = map_temps(I, TempMap),
513
 
      Source = hipe_sparc:store_fp_src(NewI),
514
 
      Dest = hipe_sparc:store_fp_dest(NewI),
515
 
      Off = hipe_sparc:store_fp_off(NewI),
516
 
      Align = hipe_sparc:store_fp_align(NewI),
517
 
      case hipe_sparc:store_fp_type(NewI) of
518
 
        double ->
519
 
          Source2 = hipe_sparc:mk_fpreg(hipe_sparc:fpreg_nr(Source) + 1),
520
 
          case hipe_sparc:is_imm(Off) of
521
 
            true ->
522
 
              Off2 = hipe_sparc:mk_imm(hipe_sparc:imm_value(Off) + 4),
523
 
              [hipe_sparc:store_fp_create(Dest, Off, single, Align, Source, []),
524
 
               hipe_sparc:store_fp_create(Dest, Off2, single, Align, Source2, [])];
525
 
            _ ->
526
 
              [hipe_sparc:store_fp_create(Dest, Off, single, Align, Source, []),
527
 
               hipe_sparc:alu_create(Off, Off, '+', hipe_sparc:mk_imm(4), []),
528
 
               hipe_sparc:store_fp_create(Dest, Off, single, Align, Source2, []),
529
 
               hipe_sparc:alu_create(Off, Off, '-', hipe_sparc:mk_imm(4), [])]
530
 
          end;
 
494
  NewI = map_temps(I, TempMap),
 
495
  Source = hipe_sparc:store_fp_src(NewI),
 
496
  Dest = hipe_sparc:store_fp_dest(NewI),
 
497
  Off = hipe_sparc:store_fp_off(NewI),
 
498
  Align = hipe_sparc:store_fp_align(NewI),
 
499
  case hipe_sparc:store_fp_type(NewI) of
 
500
    double ->
 
501
      Source2 = hipe_sparc:mk_fpreg(hipe_sparc:fpreg_nr(Source) + 1),
 
502
      case hipe_sparc:is_imm(Off) of
 
503
        true ->
 
504
          Off2 = hipe_sparc:mk_imm(hipe_sparc:imm_value(Off) + 4),
 
505
          [hipe_sparc:store_fp_create(Dest, Off, single, Align, Source),
 
506
           hipe_sparc:store_fp_create(Dest, Off2, single, Align, Source2)];
531
507
        _ ->
532
 
          NewI
533
 
      end.
 
508
          [hipe_sparc:store_fp_create(Dest, Off, single, Align, Source),
 
509
           hipe_sparc:alu_create(Off, Off, '+', hipe_sparc:mk_imm(4)),
 
510
           hipe_sparc:store_fp_create(Dest, Off, single, Align, Source2),
 
511
           hipe_sparc:alu_create(Off, Off, '-', hipe_sparc:mk_imm(4))]
 
512
      end;
 
513
    _ ->
 
514
      NewI
 
515
  end.
534
516
 
535
517
get_offset(O) ->
536
518
  -4*(O).
625
607
%%        | t1      |
626
608
%%        |OLD FRAME|
627
609
 
628
 
%% TODO: Verify that this realy is correct.
 
610
%% TODO: Verify that this really is correct.
629
611
 
630
612
enter_stack_args(ArgNo, ArgNo, Args, Need, TempMap, ArgsOnStack) ->
631
613
  %% How many args has to be spilled to the stack?
641
623
  SaveCode = save(ToSave,0, TempReg),
642
624
  PushCode = pushem(RealArgs, Base, TempReg),
643
625
 
644
 
  AdjustSP = 
645
 
    gen_dealloc_code((ArgsOnStack + Need - NoNewArgsOnStack)*4),
646
 
  [ SaveCode, PushCode, AdjustSP];
 
626
  AdjustOffset = (ArgsOnStack + Need - NoNewArgsOnStack) bsl ?log2_wordsize,
 
627
  AdjustSP = gen_dealloc_code(AdjustOffset),
 
628
  [SaveCode, PushCode, AdjustSP];
647
629
enter_stack_args(No, NoRegArgs, [_Arg|Args], Need, TempMap, ArgsOnStack) ->
648
630
  enter_stack_args(No+1, NoRegArgs, Args, Need, TempMap, ArgsOnStack).
649
631
 
677
659
  {lists:reverse(ToSave),lists:reverse(Args)}.
678
660
 
679
661
save([Pos|Poses], Offset, TempReg) ->
680
 
  ToPos = Offset*4,
 
662
  ToPos = Offset bsl ?log2_wordsize,
681
663
  FromPos = get_offset(Pos+1),
682
 
  [gen_stack_load(FromPos,TempReg),
 
664
  [gen_stack_load(FromPos, TempReg),
683
665
   gen_stack_store(ToPos, TempReg)
684
666
   | save(Poses, Offset+1, TempReg)];
685
667
save([],_,_) -> [].
686
668
 
687
669
pushem([{reg,R}|Args], Pos, Temp) ->
688
 
  ToPos = Pos*4,
689
 
  [gen_stack_store(ToPos, hipe_sparc:mk_reg(R))|
 
670
  ToPos = Pos bsl ?log2_wordsize,
 
671
  [gen_stack_store(ToPos, hipe_sparc:mk_reg(R)) | pushem(Args,Pos+1, Temp)];
 
672
pushem([{spill,P}|Args], Pos, Temp) ->
 
673
  FromPos = P bsl ?log2_wordsize, 
 
674
  ToPos = Pos bsl ?log2_wordsize,
 
675
  [gen_stack_load(FromPos, Temp),
 
676
   gen_stack_store(ToPos, Temp) |
690
677
   pushem(Args,Pos+1, Temp)];
691
 
pushem([{spill,P}|Args], Pos, Temp) ->
692
 
  FromPos = P*4, 
693
 
  ToPos = Pos*4,
694
 
  [gen_stack_load(FromPos,Temp),
695
 
   gen_stack_store(ToPos, Temp)|
696
 
    pushem(Args,Pos+1, Temp)];
697
678
pushem([{imm,I}|Args], Pos, Temp) ->
698
 
  ToPos = Pos*4,
699
 
  [ hipe_sparc:move_create(Temp, hipe_sparc:mk_imm(I), [get_arg]),
700
 
    gen_stack_store(ToPos, Temp)|
701
 
    pushem(Args,Pos+1, Temp)];
702
 
pushem([],_,_) -> [].
703
 
 
704
 
 
 
679
  ToPos = Pos bsl ?log2_wordsize,
 
680
  [hipe_sparc:move_create(Temp, hipe_sparc:mk_imm(I)),
 
681
   gen_stack_store(ToPos, Temp) |
 
682
   pushem(Args, Pos+1, Temp)];
 
683
pushem([], _, _) -> [].
705
684
 
706
685
find_reg(Temp,Map) ->
707
 
    case hipe_temp_map:find(hipe_sparc:reg_nr(Temp), Map) of 
708
 
        {reg, Pos} ->
709
 
            Pos;
710
 
        Where -> ?EXIT({temp_assumed_in_reg,Temp,Where})
711
 
    end.
 
686
  case hipe_temp_map:find(hipe_sparc:reg_nr(Temp), Map) of 
 
687
    {reg, Pos} ->
 
688
      Pos;
 
689
    Where -> ?EXIT({temp_assumed_in_reg,Temp,Where})
 
690
  end.
712
691
 
713
692
find_fpreg(Temp,Map) ->
714
 
    case hipe_temp_map:find(hipe_sparc:fpreg_nr(Temp), Map) of 
715
 
        {fp_reg, Pos} ->
716
 
            Pos;
717
 
        Where -> ?EXIT({temp_assumed_in_fpreg,Temp,Where})
718
 
    end.
 
693
  case hipe_temp_map:find(hipe_sparc:fpreg_nr(Temp), Map) of 
 
694
    {fp_reg, Pos} ->
 
695
      Pos;
 
696
    Where -> ?EXIT({temp_assumed_in_fpreg,Temp,Where})
 
697
  end.
719
698
 
720
699
%%find_pos(Temp,Map) ->
721
700
%%    case hipe_temp_map:find(hipe_sparc:reg_nr(Temp), Map) of
734
713
remap_fp(I, Temps, Map) ->
735
714
%%  io:format("\n\n~w~w\n~w\n",[I,Temps,Map]),
736
715
  Substs = 
737
 
    [{Temp, hipe_sparc:mk_fpreg(find_fpreg(Temp,Map))}
738
 
     || Temp <- Temps],
 
716
    [{Temp, hipe_sparc:mk_fpreg(find_fpreg(Temp,Map))} || Temp <- Temps],
739
717
  hipe_sparc:subst(I, Substs).
740
718
 
741
719
map_fp(Temp, Map) ->
753
731
    false ->
754
732
      Temp
755
733
  end.
756
 
 
757
 
         
758
 
 
 
734
 
759
735
max(P,A) ->
760
736
  if P > A -> P;
761
737
     true -> A
762
738
  end.
 
739
 
763
740
min(P,A) ->
764
741
  if P < A -> P;
765
742
     true -> A
766
743
  end.
767
744
 
768
 
 
769
 
 
770
745
push_call_args(Args, TempMap) ->
771
 
  ArgsOnStack = 
772
 
    args_on_stack(hipe_sparc_registers:register_args(), Args),
 
746
  ArgsOnStack = args_on_stack(hipe_sparc_registers:register_args(), Args),
773
747
  NoArgs = length(ArgsOnStack),      
774
748
  if 
775
749
    NoArgs > 0 ->
792
766
         end
793
767
         || Arg <- ArgsOnStack],
794
768
 
795
 
 
796
769
      SP = ?MK_SP_REG(),
797
770
      TempReg = ?MK_TEMP_REG(),
798
 
      AdjustSP = 
799
 
        hipe_sparc:alu_create(
800
 
          SP,SP,'+',hipe_sparc:mk_imm(4*NoArgs),[]),
 
771
      AdjustSP = hipe_sparc:alu_create(SP,SP,'+',hipe_sparc:mk_imm(4*NoArgs)),
801
772
      PushCode = pushem(MappedArgs,-NoArgs,TempReg),
802
773
      [AdjustSP|PushCode];
803
774
    true -> [] %% No args on the stack.
805
776
 
806
777
args_on_stack(0, Args) ->
807
778
  Args;
808
 
args_on_stack(N,[_Arg|Args]) ->
809
 
  args_on_stack(N-1,Args);
810
 
args_on_stack(_N,[]) -> 
 
779
args_on_stack(N, [_Arg|Args]) ->
 
780
  args_on_stack(N-1, Args);
 
781
args_on_stack(_N, []) -> 
811
782
  [].
812
783
 
813
784
 
827
798
 
828
799
stack_need(I, PrevSPLevel) ->
829
800
  %% io:format("\n\n~w\n~w\n",[I,TempMap]),
830
 
  case hipe_sparc:type(I) of
831
 
    call_link ->
 
801
  case I of
 
802
    #call_link{} ->
832
803
      Argneed = call_args_need(hipe_sparc:call_link_args(I)),
833
804
      Argneed;
834
 
 
835
 
    pseudo_enter ->
 
805
    #pseudo_enter{} ->
836
806
      NoArgs = length(hipe_sparc:pseudo_enter_args(I)),
837
807
      NoRegArgs = hipe_sparc_registers:register_args(),
838
808
      %% stack, do some shuffling.
841
811
        true ->        
842
812
          %% Arguments to the called function spill 
843
813
          NewOnStack = NoArgs - NoRegArgs,
844
 
 
845
814
          case NewOnStack > PrevSPLevel of
846
815
            true -> NewOnStack - PrevSPLevel;
847
816
            false -> 0
857
826
call_args_need(Args) ->
858
827
  length(args_on_stack(hipe_sparc_registers:register_args(), Args)).
859
828
 
860
 
 
861
 
 
862
 
 
863
829
set_stack_size(Call,Size, Arity) ->
864
830
  SD = hipe_sparc:call_link_stack_desc(Call),
865
 
  NewSD = hipe_sparc_stack_descriptors:set_size(SD, Size),
866
 
  NewSD2 = hipe_sparc_stack_descriptors:set_arity(NewSD, Arity),
 
831
  NewSD = hipe_sparc:sdesc_size_update(SD, Size),
 
832
  NewSD2 = hipe_sparc:sdesc_arity_update(NewSD, Arity),
867
833
  hipe_sparc:call_link_stack_desc_update(Call,NewSD2).
868
834
 
869
 
 
870
835
gen_stack_test(StackNeed, SP, CP, Arity, Cfg) ->
871
 
  Leaf =  hipe_sparc_cfg:is_leaf(Cfg),
 
836
  Leaf = hipe_sparc_cfg:is_leaf(Cfg),
872
837
  TempReg = ?MK_TEMP_REG(),
873
838
  TempReg1 = hipe_sparc:mk_reg(hipe_sparc_registers:temp1()),  
874
839
 
875
 
 
876
 
  if (StackNeed) =:= 0 -> {[],[]};
877
 
     (StackNeed) < ?HIPE_SPARC_LEAF_WORDS, Leaf =:= true -> {[],[]};
 
840
  if (StackNeed) =:= 0 ->
 
841
      {[],[]};
 
842
     (StackNeed) < ?SPARC_LEAF_WORDS, Leaf =:= true ->
 
843
      {[],[]};
878
844
     true -> 
879
845
      Zero = hipe_sparc:mk_reg(hipe_sparc_registers:zero()),
880
846
      SL = hipe_sparc:mk_reg(hipe_sparc_registers:stack_limit()),
886
852
      OverflowName = hipe_rtl:label_name(OverflowLbl), 
887
853
      StartName = hipe_rtl:label_name(StartLbl),
888
854
      TestName = hipe_rtl:label_name(TestLbl),
889
 
      ByteNeed = (?HIPE_SPARC_LEAF_WORDS+StackNeed)*4, 
 
855
      ByteNeed = (?SPARC_LEAF_WORDS+StackNeed) bsl ?log2_wordsize, 
890
856
      TestCode = 
891
857
        if ByteNeed > 16#fff -> %% Max in simm13.
892
858
            [
893
 
             hipe_sparc:alu_create(TempReg, SL, '-', SP, []),
 
859
             hipe_sparc:alu_create(TempReg, SL, '-', SP),
894
860
             hipe_sparc:sethi_create(TempReg1,
895
 
                                     hipe_sparc:mk_imm(
896
 
                                       high22(ByteNeed)),[]),
 
861
                                     hipe_sparc:mk_imm(high22(ByteNeed))),
897
862
             hipe_sparc:alu_create(TempReg1, TempReg1, 'or', 
898
 
                                   hipe_sparc:mk_imm(
899
 
                                     low10(ByteNeed)), 
900
 
                                   []),
901
 
             hipe_sparc:alu_cc_create(Zero, TempReg, '-', TempReg1,
902
 
                                      []),
903
 
             hipe_sparc:b_create(l, OverflowName, 
904
 
                                 StartName, Pred, na, []),
 
863
                                   hipe_sparc:mk_imm(low10(ByteNeed))),
 
864
             hipe_sparc:alu_cc_create(Zero, TempReg, '-', TempReg1),
 
865
             hipe_sparc:b_create(l, OverflowName, StartName, Pred, na),
905
866
             StartLbl];
906
 
           
907
867
           true ->
908
 
            [hipe_sparc:alu_create(TempReg, SL, '-', SP, []),
 
868
            [hipe_sparc:alu_create(TempReg, SL, '-', SP),
909
869
             hipe_sparc:alu_cc_create(Zero, TempReg, '-', 
910
 
                                      hipe_sparc:mk_imm(ByteNeed),
911
 
                                      []),
912
 
             hipe_sparc:b_create(l, OverflowName, 
913
 
                                 StartName, Pred, na, []),
 
870
                                      hipe_sparc:mk_imm(ByteNeed)),
 
871
             hipe_sparc:b_create(l, OverflowName, StartName, Pred, na),
914
872
             StartLbl]
915
873
        end,
916
 
        
917
 
      
918
874
      CPSAVE = hipe_sparc:mk_reg(hipe_sparc_registers:cpsave()),
919
 
      {[hipe_sparc:goto_create(TestName,[]),
 
875
      {[hipe_sparc:goto_create(TestName),
920
876
        TestLbl|TestCode],
921
877
       [OverflowLbl,
922
 
        hipe_sparc:move_create(CPSAVE, CP,[savecp]),
 
878
        hipe_sparc:move_create(CPSAVE, CP),
923
879
        hipe_sparc:call_link_create(inc_stack_fun(Arity),
924
 
                                   CP,
925
 
                                   [CPSAVE],
926
 
                                    hipe_rtl:label_name(RetLbl), [], c, []), 
 
880
                                    CP,
 
881
                                    [CPSAVE],
 
882
                                    hipe_rtl:label_name(RetLbl), [], not_remote),
927
883
        RetLbl,
928
 
        hipe_sparc:move_create(CP, CPSAVE,[restorecp]),
929
 
        hipe_sparc:goto_create(TestName,[])]
930
 
      };
931
 
     false ->
932
 
      {[],[]}
 
884
        hipe_sparc:move_create(CP, CPSAVE),
 
885
        hipe_sparc:goto_create(TestName)]
 
886
      }
933
887
  end.
934
888
 
935
889
inc_stack_fun(Arity) ->
936
 
  ArgsInRegs = 
937
 
    min(Arity,
938
 
        hipe_sparc_registers:register_args()), 
939
 
  list_to_atom("inc_stack_" ++ 
940
 
               integer_to_list(ArgsInRegs) ++ "args_0").
 
890
  ArgsInRegs = min(Arity, hipe_sparc_registers:register_args()), 
 
891
  list_to_atom("inc_stack_" ++ integer_to_list(ArgsInRegs) ++ "args_0").
941
892
 
942
893
 
943
894
gen_alloc_code(NeededBytes,SP) ->
947
898
  %% Alloc space on stack.
948
899
  if NeededBytes > 4092 -> %% To big for imm
949
900
      [hipe_sparc:sethi_create(TempReg,
950
 
                               hipe_sparc:mk_imm(
951
 
                                 high22(NeededBytes)),[frame]),
 
901
                               hipe_sparc:mk_imm(high22(NeededBytes))),
952
902
       hipe_sparc:alu_create(TempReg, TempReg, 'or', 
953
 
                             hipe_sparc:mk_imm(
954
 
                               low10(NeededBytes)), 
955
 
                             []),
956
 
       hipe_sparc:alu_create(
957
 
         SP,SP,'+',TempReg,[frame])];
 
903
                             hipe_sparc:mk_imm(low10(NeededBytes))),
 
904
       hipe_sparc:alu_create(SP,SP,'+',TempReg)];
958
905
     true ->
959
 
      [hipe_sparc:alu_create(
960
 
         SP,SP,'+',hipe_sparc:mk_imm(NeededBytes),[frame])]
 
906
      [hipe_sparc:alu_create(SP,SP,'+',hipe_sparc:mk_imm(NeededBytes))]
961
907
  end.
962
908
 
963
909
gen_dealloc_code(Bytes) ->
966
912
  %% dealloc space on stack.
967
913
  if Bytes > 4092 -> %% To big for imm
968
914
      [hipe_sparc:sethi_create(TempReg,
969
 
                               hipe_sparc:mk_imm(
970
 
                                 high22(Bytes)),[dealloc_frame]),
 
915
                               hipe_sparc:mk_imm(high22(Bytes))),
971
916
       hipe_sparc:alu_create(TempReg, TempReg, 'or', 
972
 
                             hipe_sparc:mk_imm(
973
 
                               low10(Bytes)), 
974
 
                             []),
975
 
       hipe_sparc:alu_create(
976
 
         SP,SP,'-',TempReg,[dealloc__frame])];
 
917
                             hipe_sparc:mk_imm(low10(Bytes))),
 
918
       hipe_sparc:alu_create(SP,SP,'-',TempReg)];
977
919
     true ->
978
 
      [hipe_sparc:alu_create(
979
 
         SP,SP,'-',hipe_sparc:mk_imm(Bytes),[dealloc_frame])]
 
920
      [hipe_sparc:alu_create(SP,SP,'-',hipe_sparc:mk_imm(Bytes))]
980
921
  end.
981
922
                                        
982
923
gen_save_cp(Need)->
1000
941
    end,
1001
942
  RetLabel = hipe_sparc:label_create_new(),
1002
943
  
1003
 
  StackAdjust = (ArgsOnStack+Need)*4,
 
944
  StackAdjust = (ArgsOnStack+Need) bsl ?log2_wordsize,
1004
945
  {[RetLabel,
1005
946
    gen_stack_load(get_offset(Need),CP),
1006
947
    gen_dealloc_code(StackAdjust),
1007
948
    hipe_sparc:jmp_create(CP, hipe_sparc:mk_imm(8), RegArgs, [])
1008
949
   ],
1009
950
   hipe_sparc:label_name(RetLabel)}.
1010
 
         
1011
951
 
1012
952
high22(X) -> X bsr 10.
1013
953
low10(X) -> X band 16#3ff.
1018
958
     true ->
1019
959
      SP = ?MK_SP_REG(),
1020
960
      ImmOffset = hipe_sparc:mk_imm(Offset),
1021
 
      [hipe_sparc:load_create(DestReg, uw, SP, ImmOffset, [])]
 
961
      [hipe_sparc:load_create(DestReg, uw, SP, ImmOffset)]
1022
962
  end.
1023
963
 
1024
964
gen_stack_store(Offset, Reg) ->
1027
967
     true ->
1028
968
      SP = ?MK_SP_REG(),
1029
969
      ImmOffset = hipe_sparc:mk_imm(Offset),
1030
 
      [hipe_sparc:store_create(SP,ImmOffset, w, Reg, [])]
 
970
      [hipe_sparc:store_create(SP,ImmOffset, w, Reg)]
1031
971
  end.
1032
972
 
1033
973
store_huge_spillpos(Offset,RegToSave)->
1039
979
load_huge_spillpos(Offset,RegToLoad)->
1040
980
  SP = ?MK_SP_REG(),
1041
981
  {DecCode, _IncCode, NewOffset} = adjust(Offset,RegToLoad),
1042
 
  [hipe_sparc:move_create(RegToLoad,SP,[]),
 
982
  [hipe_sparc:move_create(RegToLoad,SP),
1043
983
   DecCode, 
1044
984
   hipe_sparc:load_create(RegToLoad,RegToLoad,
1045
985
                          hipe_sparc:mk_imm(NewOffset))].
1046
986
 
1047
987
gen_stack_load_fp(Offset, DestReg) ->
1048
 
  Offset2 = Offset -4,
 
988
  Offset2 = Offset - 4,
1049
989
  if Offset2 < -4092 ->
1050
990
      load_huge_spillpos_fp(Offset2,DestReg);
1051
991
     true ->
1053
993
      DestReg2 = hipe_sparc:mk_fpreg(DestRegNr + 1),
1054
994
      SP = ?MK_SP_REG(),
1055
995
      [hipe_sparc:load_fp_create(DestReg, 32, single, SP, 
1056
 
                                 hipe_sparc:mk_imm(Offset), []),
1057
 
       hipe_sparc:load_fp_create(DestReg2, 32, single, SP, 
1058
 
                                 hipe_sparc:mk_imm(Offset2), [])]
 
996
                                 hipe_sparc:mk_imm(Offset)),
 
997
       hipe_sparc:load_fp_create(DestReg2, 32, single, SP,
 
998
                                 hipe_sparc:mk_imm(Offset2))]
1059
999
  end.
1060
1000
 
1061
1001
gen_stack_store_fp(Offset, SrcReg) ->
1062
 
  Offset2 = Offset-4,
 
1002
  Offset2 = Offset - 4,
1063
1003
  if Offset2 < -4092 ->
1064
1004
      store_huge_spillpos_fp(Offset2,SrcReg);
1065
1005
     true ->  
1067
1007
      SrcReg2 = hipe_sparc:mk_fpreg(SrcRegNr + 1),
1068
1008
      SP = ?MK_SP_REG(),
1069
1009
      [hipe_sparc:store_fp_create(SP, hipe_sparc:mk_imm(Offset), 
1070
 
                                  single, 32, SrcReg,[]),
 
1010
                                  single, 32, SrcReg),
1071
1011
       hipe_sparc:store_fp_create(SP, hipe_sparc:mk_imm(Offset2), 
1072
 
                                  single, 32, SrcReg2,[])]
 
1012
                                  single, 32, SrcReg2)]
1073
1013
  end.
1074
1014
 
1075
1015
store_huge_spillpos_fp(Offset2,RegToSave)->
1079
1019
  {DecCode, IncCode, NewOffset2} = adjust(Offset2,SP),
1080
1020
  [DecCode,
1081
1021
   hipe_sparc:store_fp_create(SP, hipe_sparc:mk_imm(NewOffset2+4), 
1082
 
                              single, 32, RegToSave,[]),
 
1022
                              single, 32, RegToSave),
1083
1023
   hipe_sparc:store_fp_create(SP, hipe_sparc:mk_imm(NewOffset2), 
1084
 
                              single, 32, RegToSave2,[]),
 
1024
                              single, 32, RegToSave2),
1085
1025
   IncCode].
1086
1026
 
1087
1027
load_huge_spillpos_fp(Offset2,RegToLoad)->
1091
1031
  {DecCode, IncCode, NewOffset2} = adjust(Offset2,SP),
1092
1032
  [DecCode,
1093
1033
   hipe_sparc:load_fp_create(RegToLoad, 32, single, SP, 
1094
 
                             hipe_sparc:mk_imm(NewOffset2+4), []),
 
1034
                             hipe_sparc:mk_imm(NewOffset2+4)),
1095
1035
   hipe_sparc:load_fp_create(RegToLoad2, 32, single, SP, 
1096
 
                             hipe_sparc:mk_imm(NewOffset2), []),
 
1036
                             hipe_sparc:mk_imm(NewOffset2)),
1097
1037
   IncCode].
1098
1038
 
1099
1039
adjust(Offset,Reg) ->
1105
1045
  NewOffset = Offset + 4092,
1106
1046
  Step = hipe_sparc:mk_imm(4092),
1107
1047
  adjust(NewOffset, Reg,
1108
 
         [hipe_sparc:alu_create(Reg,Reg,'-',Step,[])| Dec],
1109
 
         [hipe_sparc:alu_create(Reg,Reg,'+',Step,[])| Inc]).
1110
 
         
1111
 
 
1112
 
  
 
1048
         [hipe_sparc:alu_create(Reg,Reg,'-',Step)| Dec],
 
1049
         [hipe_sparc:alu_create(Reg,Reg,'+',Step)| Inc]).