cpupara.pas 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371
  1. {
  2. Copyright (c) 1998-2002 by Florian Klaempfl and David Zhang
  3. Calling conventions for the MIPSEL
  4. This program is free software; you can redistribute it and/or modify
  5. it under the terms of the GNU General Public License as published by
  6. the Free Software Foundation; either version 2 of the License, or
  7. (at your option) any later version.
  8. This program is distributed in the hope that it will be useful,
  9. but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11. GNU General Public License for more details.
  12. You should have received a copy of the GNU General Public License
  13. along with this program; if not, write to the Free Software
  14. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  15. *****************************************************************************}
  16. unit cpupara;
  17. {$i fpcdefs.inc}
  18. interface
  19. uses
  20. globtype,
  21. cclasses,
  22. aasmtai,
  23. cpubase,cpuinfo,
  24. symconst,symbase,symsym,symtype,symdef,paramgr,parabase,cgbase;
  25. type
  26. TMIPSELParaManager=class(TParaManager)
  27. function push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;override;
  28. function get_volatile_registers_int(calloption : tproccalloption):TCpuRegisterSet;override;
  29. function get_volatile_registers_fpu(calloption : tproccalloption):TCpuRegisterSet;override;
  30. {Returns a structure giving the information on the storage of the parameter
  31. (which must be an integer parameter)
  32. @param(nr Parameter number of routine, starting from 1)}
  33. procedure getintparaloc(calloption : tproccalloption; nr : longint;var cgpara : TCGPara);override;
  34. function create_paraloc_info(p : TAbstractProcDef; side: tcallercallee):longint;override;
  35. function create_varargs_paraloc_info(p : TAbstractProcDef; varargspara:tvarargsparalist):longint;override;
  36. function get_funcretloc(p : tabstractprocdef; side: tcallercallee; def: tdef): tcgpara;override;
  37. private
  38. procedure create_funcretloc_info(p : tabstractprocdef; side: tcallercallee);
  39. procedure create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee; paras: tparalist;
  40. var intparareg,parasize:longint);
  41. end;
  42. implementation
  43. uses
  44. cutils,verbose,systems,
  45. defutil,
  46. cgutils,cgobj;
  47. type
  48. tparasupregs = array[0..5] of tsuperregister;
  49. pparasupregs = ^tparasupregs;
  50. const
  51. paraoutsupregs : tparasupregs = (RS_R4, RS_R5, RS_R6, RS_R7, RS_R8, RS_R9);
  52. parainsupregs : tparasupregs = (RS_R4, RS_R5, RS_R6, RS_R7, RS_R8, RS_R9);
  53. function TMIPSELParaManager.get_volatile_registers_int(calloption : tproccalloption):TCpuRegisterSet;
  54. begin
  55. result:=[RS_R16..RS_R23];
  56. end;
  57. function tMIPSELparamanager.get_volatile_registers_fpu(calloption : tproccalloption):TCpuRegisterSet;
  58. begin
  59. result:=[RS_F0..RS_F31];
  60. end;
  61. procedure TMIPSELParaManager.GetIntParaLoc(calloption : tproccalloption; nr : longint;var cgpara : tcgpara);
  62. var
  63. paraloc : pcgparalocation;
  64. begin
  65. if nr<1 then
  66. InternalError(2002100806);
  67. cgpara.reset;
  68. cgpara.size:=OS_INT;
  69. cgpara.intsize:=tcgsize2size[OS_INT];
  70. cgpara.alignment:=std_param_align;
  71. paraloc:=cgpara.add_location;
  72. with paraloc^ do
  73. begin
  74. { The six first parameters are passed into registers } {MIPS first four}
  75. dec(nr);
  76. if nr<6 then //MIPSEL nr<6
  77. begin
  78. loc:=LOC_REGISTER;
  79. register:=newreg(R_INTREGISTER,(RS_R4+nr),R_SUBWHOLE);
  80. end
  81. else
  82. begin
  83. { The other parameters are passed on the stack }
  84. loc:=LOC_REFERENCE;
  85. reference.index:=NR_STACK_POINTER_REG;
  86. reference.offset:=92+(nr-6)*4;
  87. end;
  88. size:=OS_INT;
  89. end;
  90. end;
  91. { true if a parameter is too large to copy and only the address is pushed }
  92. function tMIPSELparamanager.push_addr_param(varspez:tvarspez;def : tdef;calloption : tproccalloption) : boolean;
  93. begin
  94. result:=false;
  95. { var,out,constref always require address }
  96. if varspez in [vs_var,vs_out,vs_constref] then
  97. begin
  98. result:=true;
  99. exit;
  100. end;
  101. case def.typ of
  102. recorddef,
  103. arraydef,
  104. variantdef,
  105. formaldef :
  106. push_addr_param:=true;
  107. objectdef :
  108. result:=is_object(def);
  109. stringdef :
  110. result:=(tstringdef(def).stringtype in [st_shortstring,st_longstring]);
  111. procvardef :
  112. result:=not tprocvardef(def).is_addressonly;
  113. setdef :
  114. result:=not(is_smallset(def));
  115. end;
  116. end;
  117. procedure tMIPSELparamanager.create_funcretloc_info(p : tabstractprocdef; side: tcallercallee);
  118. begin
  119. p.funcretloc[side]:=get_funcretloc(p,side,p.returndef);
  120. end;
  121. function tMIPSELparamanager.get_funcretloc(p : tabstractprocdef; side: tcallercallee; def: tdef): tcgpara;
  122. var
  123. paraloc : pcgparalocation;
  124. retcgsize : tcgsize;
  125. begin
  126. result.init;
  127. result.alignment:=get_para_align(p.proccalloption);
  128. { void has no location }
  129. if is_void(def) then
  130. begin
  131. paraloc:=result.add_location;
  132. result.size:=OS_NO;
  133. result.intsize:=0;
  134. paraloc^.size:=OS_NO;
  135. paraloc^.loc:=LOC_VOID;
  136. exit;
  137. end;
  138. { Constructors return self instead of a boolean }
  139. if (p.proctypeoption=potype_constructor) then
  140. begin
  141. retcgsize:=OS_ADDR;
  142. result.intsize:=sizeof(pint);
  143. end
  144. else
  145. begin
  146. retcgsize:=def_cgsize(def);
  147. result.intsize:=def.size;
  148. end;
  149. result.size:=retcgsize;
  150. { Return is passed as var parameter }
  151. if ret_in_param(def,p.proccalloption) then
  152. begin
  153. paraloc:=result.add_location;
  154. paraloc^.loc:=LOC_REFERENCE;
  155. paraloc^.size:=retcgsize;
  156. exit;
  157. end;
  158. paraloc:=result.add_location;
  159. { Return in FPU register? }
  160. if p.returndef.typ=floatdef then
  161. begin
  162. paraloc^.loc:=LOC_FPUREGISTER;
  163. paraloc^.register:=NR_FPU_RESULT_REG;
  164. if retcgsize=OS_F64 then
  165. setsubreg(paraloc^.register,R_SUBFD);
  166. paraloc^.size:=retcgsize;
  167. end
  168. else
  169. { Return in register }
  170. begin
  171. {$ifndef cpu64bit}
  172. if retcgsize in [OS_64,OS_S64] then
  173. begin
  174. { high }
  175. paraloc^.loc:=LOC_REGISTER;
  176. if side=callerside then
  177. paraloc^.register:=NR_FUNCTION_RESULT64_HIGH_REG
  178. else
  179. paraloc^.register:=NR_FUNCTION_RETURN64_HIGH_REG;
  180. paraloc^.size:=OS_32;
  181. { low }
  182. paraloc:=result.add_location;
  183. paraloc^.loc:=LOC_REGISTER;
  184. if side=callerside then
  185. paraloc^.register:=NR_FUNCTION_RESULT64_LOW_REG
  186. else
  187. paraloc^.register:=NR_FUNCTION_RETURN64_LOW_REG;
  188. paraloc^.size:=OS_32;
  189. end
  190. else
  191. {$endif cpu64bit}
  192. begin
  193. paraloc^.loc:=LOC_REGISTER;
  194. paraloc^.size:=retcgsize;
  195. if side=callerside then
  196. paraloc^.register:=newreg(R_INTREGISTER,RS_FUNCTION_RESULT_REG,cgsize2subreg(R_INTREGISTER,retcgsize))
  197. else
  198. paraloc^.register:=newreg(R_INTREGISTER,RS_FUNCTION_RETURN_REG,cgsize2subreg(R_INTREGISTER,retcgsize));
  199. end;
  200. end
  201. end;
  202. var
  203. param_offset:array[0..20] of ^Aint;
  204. procedure tMIPSELparamanager.create_paraloc_info_intern(p : tabstractprocdef; side: tcallercallee;paras:tparalist;
  205. var intparareg,parasize:longint);
  206. var
  207. paraloc : pcgparalocation;
  208. i : integer;
  209. hp : tparavarsym;
  210. paracgsize : tcgsize;
  211. hparasupregs : pparasupregs;
  212. paralen : longint;
  213. begin
  214. if side=callerside then
  215. hparasupregs:=@paraoutsupregs
  216. else
  217. hparasupregs:=@parainsupregs;
  218. for i:=0 to paras.count-1 do
  219. begin
  220. param_offset[i] := Nil;
  221. hp:=tparavarsym(paras[i]);
  222. { currently only support C-style array of const,
  223. there should be no location assigned to the vararg array itself }
  224. if (p.proccalloption in [pocall_cdecl,pocall_cppdecl]) and
  225. is_array_of_const(hp.vardef) then
  226. begin
  227. paraloc:=hp.paraloc[side].add_location;
  228. { hack: the paraloc must be valid, but is not actually used }
  229. paraloc^.loc:=LOC_REGISTER;
  230. paraloc^.register:=NR_R0;
  231. paraloc^.size:=OS_ADDR;
  232. break;
  233. end;
  234. if push_addr_param(hp.varspez,hp.vardef,p.proccalloption) then
  235. paracgsize:=OS_ADDR
  236. else
  237. begin
  238. paracgsize:=def_cgSize(hp.vardef);
  239. if paracgsize=OS_NO then
  240. paracgsize:=OS_ADDR;
  241. end;
  242. hp.paraloc[side].reset;
  243. hp.paraloc[side].size:=paracgsize;
  244. hp.paraloc[side].Alignment:=std_param_align;
  245. paralen:=tcgsize2size[paracgsize];
  246. hp.paraloc[side].intsize:=paralen;
  247. while paralen>0 do
  248. begin
  249. paraloc:=hp.paraloc[side].add_location;
  250. { Floats are passed in int registers,
  251. We can allocate at maximum 32 bits per register }
  252. if paracgsize in [OS_64,OS_S64,OS_F32,OS_F64] then
  253. paraloc^.size:=OS_32
  254. else
  255. paraloc^.size:=paracgsize;
  256. { ret in param? }
  257. if vo_is_funcret in hp.varoptions then
  258. begin
  259. paraloc^.loc:=LOC_REFERENCE;
  260. if side=callerside then
  261. begin
  262. paraloc^.reference.index := NR_STACK_POINTER_REG;
  263. paraloc^.reference.offset:=target_info.first_parm_offset{1000}-12 - parasize;
  264. end
  265. else
  266. begin
  267. paraloc^.reference.index := NR_FRAME_POINTER_REG;
  268. paraloc^.reference.offset:=target_info.first_parm_offset{1000}-4 - parasize;
  269. param_offset[i] := @paraloc^.reference.offset;
  270. end;
  271. inc(parasize,align(tcgsize2size[paraloc^.size],sizeof(aint)));
  272. end
  273. { In case of po_delphi_nested_cc, the parent frame pointer
  274. is always passed on the stack. }
  275. else if (intparareg<=high(tparasupregs)) and
  276. (not(vo_is_parentfp in hp.varoptions) or
  277. not(po_delphi_nested_cc in p.procoptions)) then
  278. begin
  279. paraloc^.loc:=LOC_REGISTER;
  280. paraloc^.register:=newreg(R_INTREGISTER,hparasupregs^[intparareg],R_SUBWHOLE);
  281. inc(intparareg);
  282. end
  283. else
  284. begin
  285. paraloc^.loc:=LOC_REFERENCE;
  286. if side=callerside then
  287. begin
  288. paraloc^.reference.index := {NR_R17;//}NR_STACK_POINTER_REG;
  289. paraloc^.reference.offset:=target_info.first_parm_offset{1000}-12 - parasize;
  290. end
  291. else
  292. begin
  293. paraloc^.reference.index := {NR_R18;//}NR_FRAME_POINTER_REG;
  294. paraloc^.reference.offset:=target_info.first_parm_offset{1000}-4 - parasize;
  295. param_offset[i] := @paraloc^.reference.offset;
  296. end;
  297. { Parameters are aligned at 4 bytes }
  298. inc(parasize,align(tcgsize2size[paraloc^.size],sizeof(aint)));
  299. end;
  300. dec(paralen,tcgsize2size[paraloc^.size]);
  301. end;
  302. end;
  303. for i:=0 to paras.count-1 do
  304. begin
  305. if (side = calleeside) and (param_offset[i] <> nil) then
  306. param_offset[i]^ := param_offset[i]^ + parasize - 8;
  307. end;
  308. end;
  309. function TMIPSELParaManager.create_varargs_paraloc_info(p : tabstractprocdef; varargspara:tvarargsparalist):longint;
  310. var
  311. intparareg,
  312. parasize : longint;
  313. begin
  314. intparareg:=0;
  315. parasize:=0;
  316. { calculate the registers for the normal parameters }
  317. create_paraloc_info_intern(p,callerside,p.paras,intparareg,parasize);
  318. { append the varargs }
  319. create_paraloc_info_intern(p,callerside,varargspara,intparareg,parasize);
  320. result:=parasize;
  321. end;
  322. function tMIPSELparamanager.create_paraloc_info(p : tabstractprocdef; side: tcallercallee):longint;
  323. var
  324. intparareg,
  325. parasize : longint;
  326. begin
  327. intparareg:=0;
  328. parasize:=0;
  329. create_paraloc_info_intern(p,side,p.paras,intparareg,parasize);
  330. { Create Function result paraloc }
  331. create_funcretloc_info(p,side);
  332. { We need to return the size allocated on the stack }
  333. result:=parasize;
  334. end;
  335. begin
  336. ParaManager:=TMIPSELParaManager.create;
  337. end.