← Back to branch summary

~ubuntu-branches/debian/lenny/fpc/lenny

« back to all changes in this revision

Viewing changes to compiler/utils/mkx86reg.pp

  • Committer: Bazaar Package Importer
  • Author(s): Mazen Neifer, Torsten Werner, Mazen Neifer
  • Date: 2008-05-17 17:12:11 UTC
  • mfrom: (3.1.9 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080517171211-9qi33xhd9evfa0kg
Tags: 2.2.0-dfsg1-9
http://bugs.debian.org/477743
[ Torsten Werner ]
* Add Mazen Neifer to Uploaders field.

[ Mazen Neifer ]
* Moved FPC sources into a version dependent directory from /usr/share/fpcsrc
  to /usr/share/fpcsrc/${FPCVERSION}. This allow installing more than on FPC
  release.
* Fixed far call issue in compiler preventing building huge binearies.
  (closes: #477743)
* Updated building dependencies, recomennded and suggested packages.
* Moved fppkg to fp-utils as it is just a helper tool and is not required by
  compiler.

Show diffs side-by-side

added added

removed removed

Lines of Context:
compiler/utils/mkx86reg.pp
1
 
{
2
 
    $Id: mkx86reg.pp,v 1.4 2003/12/15 21:25:49 peter Exp $
3
 
    Copyright (c) 1998-2002 by Peter Vreman and Florian Klaempfl
4
 
 
5
 
    Convert i386reg.dat to several .inc files for usage with
6
 
    the Free pascal compiler
7
 
 
8
 
    See the file COPYING.FPC, included in this distribution,
9
 
    for details about the copyright.
10
 
 
11
 
    This program is distributed in the hope that it will be useful,
12
 
    but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14
 
 
15
 
 **********************************************************************}
16
 
{$mode objfpc}
17
 
{$i+}
18
 
program mkx86reg;
19
 
 
20
 
const Version = '1.00';
21
 
      max_regcount = 128;
22
 
 
23
 
var s : string;
24
 
    i : longint;
25
 
    line : longint;
26
 
    regcount:byte;
27
 
    regcount_bsstart:byte;
28
 
    names,numbers,stdnames,intnames,nasmnames,attnames,stabs,ots,ops:
29
 
        array[0..max_regcount-1] of string[63];
30
 
    regnumber_index,std_regname_index,int_regname_index,att_regname_index,
31
 
    nasm_regname_index:array[0..max_regcount-1] of byte;
32
 
    x86_64 : boolean;
33
 
    fileprefix : string;
34
 
 
35
 
{$ifndef FPC}
36
 
  procedure readln(var t:text;var s:string);
37
 
  var
38
 
    c : char;
39
 
    i : longint;
40
 
  begin
41
 
    c:=#0;
42
 
    i:=0;
43
 
    while (not eof(t)) and (c<>#10) do
44
 
     begin
45
 
       read(t,c);
46
 
       if c<>#10 then
47
 
        begin
48
 
          inc(i);
49
 
          s[i]:=c;
50
 
        end;
51
 
     end;
52
 
    if (i>0) and (s[i]=#13) then
53
 
     dec(i);
54
 
    s[0]:=chr(i);
55
 
  end;
56
 
{$endif}
57
 
 
58
 
function tostr(l : longint) : string;
59
 
 
60
 
begin
61
 
  str(l,tostr);
62
 
end;
63
 
 
64
 
function readstr : string;
65
 
  begin
66
 
     result:='';
67
 
     while (s[i]<>',') and (i<=length(s)) do
68
 
       begin
69
 
          result:=result+s[i];
70
 
          inc(i);
71
 
       end;
72
 
     readstr:=result;
73
 
  end;
74
 
 
75
 
 
76
 
procedure readcomma;
77
 
  begin
78
 
     if s[i]<>',' then
79
 
       begin
80
 
         writeln('Missing "," at line ',line);
81
 
         writeln('Line: "',s,'"');
82
 
         halt(1);
83
 
       end;
84
 
     inc(i);
85
 
  end;
86
 
 
87
 
 
88
 
procedure skipspace;
89
 
 
90
 
  begin
91
 
     while (s[i] in [' ',#9]) do
92
 
       inc(i);
93
 
  end;
94
 
 
95
 
procedure openinc(var f:text;const fn:string);
96
 
begin
97
 
  writeln('creating ',fn);
98
 
  assign(f,fn);
99
 
  rewrite(f);
100
 
  writeln(f,'{ don''t edit, this file is generated from x86reg.dat }');
101
 
end;
102
 
 
103
 
 
104
 
procedure closeinc(var f:text);
105
 
begin
106
 
  writeln(f);
107
 
  close(f);
108
 
end;
109
 
 
110
 
procedure build_regnum_index;
111
 
 
112
 
var h,i,j,p,t:byte;
113
 
 
114
 
begin
115
 
  {Build the registernumber2regindex index.
116
 
   Step 1: Fill.}
117
 
  for i:=0 to regcount-1 do
118
 
    regnumber_index[i]:=i;
119
 
  {Step 2: Sort. We use a Shell-Metzner sort.}
120
 
  p:=regcount_bsstart;
121
 
  repeat
122
 
    for h:=0 to regcount-p-1 do
123
 
      begin
124
 
        i:=h;
125
 
        repeat
126
 
          j:=i+p;
127
 
          if numbers[regnumber_index[j]]>=numbers[regnumber_index[i]] then
128
 
            break;
129
 
          t:=regnumber_index[i];
130
 
          regnumber_index[i]:=regnumber_index[j];
131
 
          regnumber_index[j]:=t;
132
 
          if i<p then
133
 
            break;
134
 
          dec(i,p);
135
 
        until false;
136
 
      end;
137
 
    p:=p shr 1;
138
 
  until p=0;
139
 
end;
140
 
 
141
 
procedure build_std_regname_index;
142
 
 
143
 
var h,i,j,p,t:byte;
144
 
 
145
 
begin
146
 
  {Build the registernumber2regindex index.
147
 
   Step 1: Fill.}
148
 
  for i:=0 to regcount-1 do
149
 
    std_regname_index[i]:=i;
150
 
  {Step 2: Sort. We use a Shell-Metzner sort.}
151
 
  p:=regcount_bsstart;
152
 
  repeat
153
 
    for h:=0 to regcount-p-1 do
154
 
      begin
155
 
        i:=h;
156
 
        repeat
157
 
          j:=i+p;
158
 
          if stdnames[std_regname_index[j]]>=stdnames[std_regname_index[i]] then
159
 
            break;
160
 
          t:=std_regname_index[i];
161
 
          std_regname_index[i]:=std_regname_index[j];
162
 
          std_regname_index[j]:=t;
163
 
          if i<p then
164
 
            break;
165
 
          dec(i,p);
166
 
        until false;
167
 
      end;
168
 
    p:=p shr 1;
169
 
  until p=0;
170
 
end;
171
 
 
172
 
procedure build_int_regname_index;
173
 
 
174
 
var h,i,j,p,t:byte;
175
 
 
176
 
begin
177
 
  {Build the registernumber2regindex index.
178
 
   Step 1: Fill.}
179
 
  for i:=0 to regcount-1 do
180
 
    int_regname_index[i]:=i;
181
 
  {Step 2: Sort. We use a Shell-Metzner sort.}
182
 
  p:=regcount_bsstart;
183
 
  repeat
184
 
    for h:=0 to regcount-p-1 do
185
 
      begin
186
 
        i:=h;
187
 
        repeat
188
 
          j:=i+p;
189
 
          if intnames[int_regname_index[j]]>=intnames[int_regname_index[i]] then
190
 
            break;
191
 
          t:=int_regname_index[i];
192
 
          int_regname_index[i]:=int_regname_index[j];
193
 
          int_regname_index[j]:=t;
194
 
          if i<p then
195
 
            break;
196
 
          dec(i,p);
197
 
        until false;
198
 
      end;
199
 
    p:=p shr 1;
200
 
  until p=0;
201
 
end;
202
 
 
203
 
procedure build_att_regname_index;
204
 
 
205
 
var h,i,j,p,t:byte;
206
 
 
207
 
begin
208
 
  {Build the registernumber2regindex index.
209
 
   Step 1: Fill.}
210
 
  for i:=0 to regcount-1 do
211
 
    att_regname_index[i]:=i;
212
 
  {Step 2: Sort. We use a Shell-Metzner sort.}
213
 
  p:=regcount_bsstart;
214
 
  repeat
215
 
    for h:=0 to regcount-p-1 do
216
 
      begin
217
 
        i:=h;
218
 
        repeat
219
 
          j:=i+p;
220
 
          if attnames[att_regname_index[j]]>=attnames[att_regname_index[i]] then
221
 
            break;
222
 
          t:=att_regname_index[i];
223
 
          att_regname_index[i]:=att_regname_index[j];
224
 
          att_regname_index[j]:=t;
225
 
          if i<p then
226
 
            break;
227
 
          dec(i,p);
228
 
        until false;
229
 
      end;
230
 
    p:=p shr 1;
231
 
  until p=0;
232
 
end;
233
 
 
234
 
procedure build_nasm_regname_index;
235
 
 
236
 
var h,i,j,p,t:byte;
237
 
 
238
 
begin
239
 
  {Build the registernumber2regindex index.
240
 
   Step 1: Fill.}
241
 
  for i:=0 to regcount-1 do
242
 
    nasm_regname_index[i]:=i;
243
 
  {Step 2: Sort. We use a Shell-Metzner sort.}
244
 
  p:=regcount_bsstart;
245
 
  repeat
246
 
    for h:=0 to regcount-p-1 do
247
 
      begin
248
 
        i:=h;
249
 
        repeat
250
 
          j:=i+p;
251
 
          if nasmnames[nasm_regname_index[j]]>=nasmnames[nasm_regname_index[i]] then
252
 
            break;
253
 
          t:=nasm_regname_index[i];
254
 
          nasm_regname_index[i]:=nasm_regname_index[j];
255
 
          nasm_regname_index[j]:=t;
256
 
          if i<p then
257
 
            break;
258
 
          dec(i,p);
259
 
        until false;
260
 
      end;
261
 
    p:=p shr 1;
262
 
  until p=0;
263
 
end;
264
 
 
265
 
procedure read_x86reg_file;
266
 
 
267
 
var infile:text;
268
 
    cpustr:string;
269
 
 
270
 
begin
271
 
   { open dat file }
272
 
   assign(infile,'x86reg.dat');
273
 
   reset(infile);
274
 
   while not(eof(infile)) do
275
 
     begin
276
 
        { handle comment }
277
 
        readln(infile,s);
278
 
        inc(line);
279
 
        while (s[1]=' ') do
280
 
         delete(s,1,1);
281
 
        if (s='') or (s[1]=';') then
282
 
          continue;
283
 
 
284
 
        i:=1;
285
 
        names[regcount]:=readstr;
286
 
        readcomma;
287
 
        numbers[regcount]:=readstr;
288
 
        readcomma;
289
 
        stdnames[regcount]:=readstr;
290
 
        readcomma;
291
 
        attnames[regcount]:=readstr;
292
 
        readcomma;
293
 
        intnames[regcount]:=readstr;
294
 
        readcomma;
295
 
        nasmnames[regcount]:=readstr;
296
 
        readcomma;
297
 
        stabs[regcount]:=readstr;
298
 
        readcomma;
299
 
        ots[regcount]:=readstr;
300
 
        readcomma;
301
 
        ops[regcount]:=readstr;
302
 
        if s[i]=',' then
303
 
          begin
304
 
            readcomma;
305
 
            cpustr:=readstr;
306
 
          end
307
 
        else
308
 
          cpustr:='';
309
 
        if i<length(s) then
310
 
          begin
311
 
            writeln('Extra chars at end of line, at line ',line);
312
 
            writeln('Line: "',s,'"');
313
 
            halt(1);
314
 
          end;
315
 
        if (cpustr<>'64') or x86_64 then
316
 
          begin
317
 
            inc(regcount);
318
 
            if regcount>max_regcount then
319
 
              begin
320
 
                writeln('Error: Too much registers, please increase maxregcount in source');
321
 
                halt(2);
322
 
              end;
323
 
          end;
324
 
     end;
325
 
   close(infile);
326
 
end;
327
 
 
328
 
procedure write_inc_files;
329
 
 
330
 
var attfile,intfile,otfile,opfile,
331
 
    norfile,nasmfile,stdfile,
332
 
    numfile,stabfile,confile,
333
 
    rnifile,irifile,srifile,
334
 
    arifile,nrifile:text;
335
 
    first:boolean;
336
 
 
337
 
begin
338
 
  { create inc files }
339
 
  openinc(confile,fileprefix+'con.inc');
340
 
  openinc(numfile,fileprefix+'num.inc');
341
 
  openinc(stdfile,fileprefix+'std.inc');
342
 
  openinc(attfile,fileprefix+'att.inc');
343
 
  if not(x86_64) then
344
 
    begin
345
 
      openinc(intfile,fileprefix+'int.inc');
346
 
      openinc(nasmfile,fileprefix+'nasm.inc');
347
 
    end;
348
 
  openinc(stabfile,fileprefix+'stab.inc');
349
 
  openinc(otfile,fileprefix+'ot.inc');
350
 
  openinc(opfile,fileprefix+'op.inc');
351
 
  openinc(norfile,fileprefix+'nor.inc');
352
 
  openinc(rnifile,fileprefix+'rni.inc');
353
 
  openinc(srifile,fileprefix+'sri.inc');
354
 
  openinc(arifile,fileprefix+'ari.inc');
355
 
  if not(x86_64) then
356
 
    begin
357
 
      openinc(nrifile,fileprefix+'nri.inc');
358
 
      openinc(irifile,fileprefix+'iri.inc');
359
 
    end;
360
 
  first:=true;
361
 
  for i:=0 to regcount-1 do
362
 
    begin
363
 
      if not first then
364
 
        begin
365
 
          writeln(numfile,',');
366
 
          writeln(stdfile,',');
367
 
          writeln(attfile,',');
368
 
          if not(x86_64) then
369
 
            begin
370
 
              writeln(intfile,',');
371
 
              writeln(nasmfile,',');
372
 
            end;
373
 
          writeln(stabfile,',');
374
 
          writeln(otfile,',');
375
 
          writeln(opfile,',');
376
 
          writeln(rnifile,',');
377
 
          writeln(srifile,',');
378
 
          writeln(arifile,',');
379
 
          if not(x86_64) then
380
 
            begin
381
 
              writeln(irifile,',');
382
 
              writeln(nrifile,',');
383
 
            end;
384
 
        end
385
 
      else
386
 
        first:=false;
387
 
      writeln(confile,names[i],' = ','tregister(',numbers[i],')',';');
388
 
      write(numfile,'tregister(',numbers[i],')');
389
 
      write(stdfile,'''',stdnames[i],'''');
390
 
      write(attfile,'''',attnames[i],'''');
391
 
      if not(x86_64) then
392
 
        begin
393
 
          write(intfile,'''',intnames[i],'''');
394
 
          write(nasmfile,'''',nasmnames[i],'''');
395
 
        end;
396
 
      write(stabfile,stabs[i]);
397
 
      write(otfile,ots[i]);
398
 
      write(opfile,ops[i]);
399
 
      write(rnifile,regnumber_index[i]);
400
 
      write(srifile,std_regname_index[i]);
401
 
      write(arifile,att_regname_index[i]);
402
 
 
403
 
      if not(x86_64) then
404
 
        begin
405
 
          write(irifile,int_regname_index[i]);
406
 
          write(nrifile,nasm_regname_index[i]);
407
 
        end;
408
 
    end;
409
 
  write(norfile,regcount);
410
 
  close(confile);
411
 
  closeinc(numfile);
412
 
  closeinc(attfile);
413
 
  closeinc(stdfile);
414
 
  if not(x86_64) then
415
 
    begin
416
 
      closeinc(intfile);
417
 
      closeinc(nasmfile);
418
 
    end;
419
 
  closeinc(stabfile);
420
 
  closeinc(otfile);
421
 
  closeinc(opfile);
422
 
  closeinc(norfile);
423
 
  closeinc(rnifile);
424
 
  closeinc(srifile);
425
 
  closeinc(arifile);
426
 
  if not(x86_64) then
427
 
    begin
428
 
      closeinc(nrifile);
429
 
      closeinc(irifile);
430
 
    end;
431
 
  writeln('Done!');
432
 
  writeln(regcount,' registers procesed');
433
 
end;
434
 
 
435
 
 
436
 
begin
437
 
   writeln('Register Table Converter Version ',Version);
438
 
   x86_64:=paramstr(1)='x86_64';
439
 
   if x86_64 then
440
 
     fileprefix:='r8664'
441
 
   else
442
 
     fileprefix:='r386';
443
 
   line:=0;
444
 
   regcount:=0;
445
 
   read_x86reg_file;
446
 
   regcount_bsstart:=1;
447
 
   while 2*regcount_bsstart<regcount do
448
 
     regcount_bsstart:=regcount_bsstart*2;
449
 
   build_regnum_index;
450
 
   if not(x86_64) then
451
 
     begin
452
 
       build_int_regname_index;
453
 
       build_nasm_regname_index;
454
 
     end;
455
 
   build_std_regname_index;
456
 
   build_att_regname_index;
457
 
   write_inc_files;
458
 
end.
459
 
{
460
 
  $Log: mkx86reg.pp,v $
461
 
  Revision 1.4  2003/12/15 21:25:49  peter
462
 
    * reg allocations for imaginary register are now inserted just
463
 
      before reg allocation
464
 
    * tregister changed to enum to allow compile time check
465
 
    * fixed several tregister-tsuperregister errors
466
 
 
467
 
  Revision 1.3  2003/09/24 17:11:33  florian
468
 
    * x86_64 support; turn on by passing x86_64
469
 
 
470
 
  Revision 1.2  2003/09/03 15:55:02  peter
471
 
    * NEWRA branch merged
472
 
 
473
 
  Revision 1.1.2.4  2003/08/31 18:46:57  peter
474
 
    * removed warning
475
 
 
476
 
  Revision 1.1.2.3  2003/08/29 09:41:25  daniel
477
 
    * Further mkx86reg development
478
 
 
479
 
  Revision 1.1.2.2  2003/08/27 20:30:46  peter
480
 
    * updated for opcode
481
 
 
482
 
  Revision 1.1.2.1  2003/08/27 19:13:10  peter
483
 
    * new tools
484
 
 
485
 
}