--- gforth/libcc.fs 2006/12/26 19:10:54 1.2 +++ gforth/libcc.fs 2007/07/21 18:18:20 1.21 @@ -21,9 +21,8 @@ \ What this implementation does is this: if it sees a declaration like -\ \ something that tells it to include \ \ something that tells it that the current library is libc - +\ \c #include \ c-function dlseek lseek n d n -- d \ it genererates C code similar to the following: @@ -46,27 +45,199 @@ \ the function pointer of gforth_c_lseek_ndn_d on the stack and \ calls CALL-C. +\ ToDo: + +\ Batching, caching and lazy evaluation: + +\ Batching: + +\ New words are deferred, and the corresponding C functions are +\ collected in one file, until the first word is EXECUTEd; then the +\ file is compiled and linked into the system, and the word is +\ resolved. + +\ Caching: + +\ Instead of compiling all this stuff anew for every execution, we +\ keep the files around and have an index file containing the function +\ names and their corresponding .so files. If the needed wrapper name +\ is already present, it is just linked instead of generating the +\ wrapper again. This is all done by loading the index file(s?), +\ which define words for the wrappers in a separate wordlist. + +\ The files are built in .../lib/gforth/$VERSION/libcc/ or +\ ~/.gforth/libcc/$HOST/. + \ other things to do: \ c-variable forth-name c-name \ c-constant forth-name c-name +\ Todo: conversion between function pointers and xts (both directions) + +\ taking an xt and turning it into a function pointer: + +\ e.g., assume we have the xt of + and want to create a C function int +\ gforth_callback_plus(int, int), and then pass the pointer to that +\ function: + +\ There should be Forth code like this: +\ ] + 0 (bye) +\ Assume that the start of this code is START + +\ Now, there should be a C function: + +\ int gforth_callback_plus(int p1, int p2) +\ { +\ Cell *sp = gforth_SP; +\ Float *fp = gforth_FP; +\ Float *fp = gforth_FP; +\ Address lp = gforth_LP; +\ sp -= 2; +\ sp[0] = p1; +\ sp[1] = p2; +\ gforth_engine(START, sp, rp, fp, lp); +\ sp += 1; +\ gforth_RP = rp; +\ gforth_SP = sp; +\ gforth_FP = fp; +\ gforth_LP = lp; +\ return sp[0]; +\ } + +\ and the pointer to that function is the C function pointer for the XT of +. + +\ Future problems: +\ how to combine the Forth code generation with inlining +\ START is not a constant across executions (when caching the C files) +\ Solution: make START a variable, and store into it on startup with dlsym + +\ Syntax: +\ callback -- + \ data structures -\ c-function word body: -\ cell function pointer -\ char return type index -\ char parameter count n -\ char*n parameters (type indices) -\ counted string: c-name +\ For every c-function, we have three words: two anonymous words +\ created by c-function-ft (first time) and c-function-rt (run-time), +\ and a named deferred word. The deferred word first points to the +\ first-time word, then to the run-time word; the run-time word calls +\ the c function. + + +require struct.fs + + \ counted-string + +\ c-function-ft word body: +struct + cell% field cff-cfr \ xt of c-function-rt word + cell% field cff-deferred \ xt of c-function deferred word + cell% field cff-lha \ address of the lib-handle for the lib that + \ contains the wrapper function of the word + char% field cff-rtype \ return type + char% field cff-np \ number of parameters + 1 0 field cff-ptypes \ #npar parameter types + \ counted string: c-name +end-struct cff% + +variable c-source-file-id \ contains the source file id of the current batch +0 c-source-file-id ! +variable lib-handle-addr \ points to the library handle of the current batch. + \ the library handle is 0 if the current + \ batch is not yet compiled. +2variable lib-filename \ filename without extension -: .n ( n -- ) +: .nb ( n -- ) 0 .r ; : const+ ( n1 "name" -- n2 ) dup constant 1+ ; +: front-string { c-addr1 u1 c-addr2 u2 -- c-addr3 u3 } + \ insert string c-addr2 u2 in buffer c-addr1 u1; c-addr3 u3 is the + \ remainder of the buffer. + assert( u1 u2 u>= ) + c-addr2 c-addr1 u2 move + c-addr1 u1 u2 /string ; + +: front-char { c-addr1 u1 c -- c-addr3 u2 } + \ insert c in buffer c-addr1 u1; c-addr3 u3 is the remainder of + \ the buffer. + assert( u1 0 u> ) + c c-addr1 c! + c-addr1 u1 1 /string ; + +: s+ { addr1 u1 addr2 u2 -- addr u } + u1 u2 + allocate throw { addr } + addr1 addr u1 move + addr2 addr u1 + u2 move + addr u1 u2 + +; + +: append { addr1 u1 addr2 u2 -- addr u } + addr1 u1 u2 + dup { u } resize throw { addr } + addr2 addr u1 + u2 move + addr u ; + +\ linked list stuff (should go elsewhere) + +struct + cell% field list-next + 1 0 field list-payload +end-struct list% + +: list-insert { node list -- } + list list-next @ node list-next ! + node list list-next ! ; + +: list-append { node endlistp -- } + \ insert node at place pointed to by endlistp + node endlistp @ list-insert + node list-next endlistp ! ; + +: list-map ( ... list xt -- ... ) + \ xt ( ... node -- ... ) + { xt } begin { node } + node while + node xt execute + node list-next @ + repeat ; + +\ C prefix lines + +\ linked list of longcstrings: [ link | count-cell | characters ] + +list% + cell% field c-prefix-count + 1 0 field c-prefix-chars +end-struct c-prefix% + +variable c-prefix-lines 0 c-prefix-lines ! +variable c-prefix-lines-end c-prefix-lines c-prefix-lines-end ! + +: print-c-prefix-line ( node -- ) + dup c-prefix-chars swap c-prefix-count @ type cr ; + +: print-c-prefix-lines ( -- ) + c-prefix-lines @ ['] print-c-prefix-line list-map ; + +: save-c-prefix-line ( c-addr u -- ) + c-source-file-id @ ?dup-if + >r 2dup r> write-line throw + then + align here 0 , c-prefix-lines-end list-append ( c-addr u ) + longstring, ; + +: \c ( "rest-of-line" -- ) \ gforth backslash-c + \G One line of C declarations for the C interface + -1 parse save-c-prefix-line ; + +s" #include " append ( c-addr u ) + 2dup save-c-prefix-line drop free throw + +\ Types (for parsing) + wordlist constant libcc-types get-current libcc-types set-current @@ -75,7 +246,7 @@ get-current libcc-types set-current -1 const+ -- \ end of arguments const+ n \ integer cell -const+ p \ pointer cell +const+ a \ address cell const+ d \ double const+ r \ float const+ func \ C function pointer @@ -92,18 +263,18 @@ set-current parse-libcc-type dup 0>= while c, repeat - drop swap - over char+ c! - parse-libcc-type 0< -32 and throw swap c! ; + drop here swap - over char+ c! + parse-libcc-type dup 0< -32 and throw swap c! ; : type-letter ( n -- c ) - chars s" npdrfv" drop + c@ ; + chars s" nadrfv" drop + c@ ; \ count-stacks : count-stacks-n ( fp-change1 sp-change1 -- fp-change2 sp-change2 ) 1+ ; -: count-stacks-p ( fp-change1 sp-change1 -- fp-change2 sp-change2 ) +: count-stacks-a ( fp-change1 sp-change1 -- fp-change2 sp-change2 ) 1+ ; : count-stacks-d ( fp-change1 sp-change1 -- fp-change2 sp-change2 ) @@ -120,7 +291,7 @@ set-current create count-stacks-types ' count-stacks-n , -' count-stacks-p , +' count-stacks-a , ' count-stacks-d , ' count-stacks-r , ' count-stacks-func , @@ -129,45 +300,45 @@ create count-stacks-types : count-stacks ( pars -- fp-change sp-change ) \ pars is an addr u pair 0 0 2swap over + swap u+do - i c@ cells count-stacks-type + @ execute + i c@ cells count-stacks-types + @ execute loop ; \ gen-pars : gen-par-n ( fp-depth1 sp-depth1 -- fp-depth2 sp-depth2 ) - 1- dup ." sp[" .n ." ]" ; + ." sp[" 1- dup .nb ." ]" ; -: gen-par-p ( fp-depth1 sp-depth1 -- fp-depth2 sp-depth2 ) +: gen-par-a ( fp-depth1 sp-depth1 -- fp-depth2 sp-depth2 ) ." (void *)(" gen-par-n ." )" ; : gen-par-d ( fp-depth1 sp-depth1 -- fp-depth2 sp-depth2 ) - ." gforthd2ll(" gen-par-n ." ," gen-par-n ." )" ; + ." gforth_d2ll(" gen-par-n ." ," gen-par-n ." )" ; : gen-par-r ( fp-depth1 sp-depth1 -- fp-depth2 sp-depth2 ) - swap 1- tuck ." fp[" .n ." ]" ; + swap 1- tuck ." fp[" .nb ." ]" ; : gen-par-func ( fp-depth1 sp-depth1 -- fp-depth2 sp-depth2 ) - gen-par-p ; + gen-par-a ; : gen-par-void ( fp-depth1 sp-depth1 -- fp-depth2 sp-depth2 ) -32 throw ; create gen-par-types ' gen-par-n , -' gen-par-p , +' gen-par-a , ' gen-par-d , ' gen-par-r , ' gen-par-func , ' gen-par-void , : gen-par ( fp-depth1 sp-depth1 partype -- fp-depth2 sp-depth2 ) - cells gen-par-types @ execute ; + cells gen-par-types + @ execute ; \ the call itself : gen-wrapped-call { d: pars d: c-name fp-change1 sp-change1 -- } c-name type ." (" - fp-change1 sp-change1 pars over + swap u+do + fp-change1 sp-change1 pars over + swap u+do i c@ gen-par i 1+ i' < if ." ," @@ -180,58 +351,134 @@ create gen-par-types : gen-wrapped-void ( pars c-name fp-change1 sp-change1 -- fp-change sp-change ) 2dup 2>r gen-wrapped-call 2r> ; +: gen-wrapped-n ( pars c-name fp-change1 sp-change1 -- fp-change sp-change ) + 2dup gen-par-n 2>r ." =" gen-wrapped-call 2r> ; + +: gen-wrapped-a ( pars c-name fp-change1 sp-change1 -- fp-change sp-change ) + 2dup gen-par-n 2>r ." =(Cell)" gen-wrapped-call 2r> ; + +: gen-wrapped-d ( pars c-name fp-change1 sp-change1 -- fp-change sp-change ) + ." gforth_ll2d(" gen-wrapped-void + ." ," gen-par-n ." ," gen-par-n ." )" ; + +: gen-wrapped-r ( pars c-name fp-change1 sp-change1 -- fp-change sp-change ) + 2dup gen-par-r 2>r ." =" gen-wrapped-void 2r> ; + +: gen-wrapped-func ( pars c-name fp-change1 sp-change1 -- fp-change sp-change ) + gen-wrapped-a ; + create gen-wrapped-types ' gen-wrapped-n , -' gen-wrapped-p , +' gen-wrapped-a , ' gen-wrapped-d , ' gen-wrapped-r , ' gen-wrapped-func , ' gen-wrapped-void , : gen-wrapped-stmt ( pars c-name fp-change1 sp-change1 ret -- fp-change sp-change ) - cells gen-wrapped-types @ execute ; + cells gen-wrapped-types + @ execute ; -: gen-wrapper-function ( addr -- ) +: wrapper-function-name ( addr -- c-addr u ) \ addr points to the return type index of a c-function descriptor - c@+ { ret } count 2dup { d: pars } chars + count { d: c-name } - ." void gforth_c_" c-name type ." _" - pars 0 +do - i chars over + c@ type-letter emit + count { r-type } count { d: pars } + pars + count { d: c-name } + s" gforth_c_" { d: prefix } + prefix nip c-name nip + pars nip + 3 + { u } + u allocate throw { c-addr } + c-addr u + prefix front-string c-name front-string '_ front-char + pars bounds u+do + i c@ type-letter front-char loop - ." _" ret type-letter emit .\" (void)\n" - .\" {\n Cell *sp = gforth_SP;\n Float *fp = gforth_FP;" + '_ front-char r-type type-letter front-char assert( dup 0= ) + 2drop c-addr u ; + +: gen-wrapper-function ( addr -- ) + \ addr points to the return type index of a c-function descriptor + dup { descriptor } + count { ret } count 2dup { d: pars } chars + count { d: c-name } + ." void " descriptor wrapper-function-name 2dup type drop free throw + .\" (void)\n" + .\" {\n Cell MAYBE_UNUSED *sp = gforth_SP;\n Float MAYBE_UNUSED *fp = gforth_FP;\n " pars c-name 2over count-stacks ret gen-wrapped-stmt .\" ;\n" ?dup-if - ." gforth_SP = sp+" .n .\" ;\n" + ." gforth_SP = sp+" .nb .\" ;\n" endif ?dup-if - ." gforth_FP = fp+" .n .\" ;\n" + ." gforth_FP = fp+" .nb .\" ;\n" endif - ." }\n" ; + .\" }\n" ; -: c-function ( "forth-name" "c-name" "{libcc-type}" "--" "libcc-type" -- ) - create here >r 0 , \ place for the wrapper function pointer +: tempdir ( -- c-addr u ) + s" TMPDIR" getenv dup 0= if + 2drop s" /tmp" + then ; + +: gen-filename ( x -- c-addr u ) + \ generates a filename without extension for lib-handle-addr X + 0 <<# ['] #s $10 base-execute #> + tempdir s" /gforth-c-" s+ 2swap append #>> ; + +: init-c-source-file ( -- ) + c-source-file-id @ 0= if + here 0 , dup lib-handle-addr ! gen-filename 2dup lib-filename 2! + s" .c" s+ 2dup w/o create-file throw dup c-source-file-id ! + ['] print-c-prefix-lines swap outfile-execute + drop free throw + endif ; + +: c-source-file ( -- file-id ) + c-source-file-id @ assert( dup ) ; + +DEFER compile-wrapper-function +:NONAME ( -- ) + c-source-file close-file throw + 0 c-source-file-id ! + s" gcc -fPIC -shared -Wl,-soname," lib-filename 2@ s+ + s" .so.1 -Wl,-export_dynamic -o " append lib-filename 2@ append + [ s" .so.1 -O -I " s" includedir" getenv append s" " append ] sliteral + append lib-filename 2@ append s" .c" append ( c-addr u ) + 2dup system drop free throw + $? abort" compiler generated error" \ !! call dlerror + lib-filename 2@ s" .so.1" s+ + 2dup open-lib dup 0= abort" open-lib failed" \ !! call dlerror + ( lib-handle ) lib-handle-addr @ ! + 2dup delete-file throw drop free throw + lib-filename 2@ s" .c" s+ 2dup delete-file throw drop free throw + lib-filename 2@ drop free throw 0 0 lib-filename 2! ; IS compile-wrapper-function +\ s" ar rcs xxx.a xxx.o" system +\ $? abort" ar generated error" ; + +: link-wrapper-function { cff -- sym } + cff cff-rtype wrapper-function-name { d: wrapper-name } + wrapper-name cff cff-lha @ @ assert( dup ) lib-sym dup 0= -&32 and throw + wrapper-name drop free throw ; + +: c-function-ft ( xt-defr xt-cfr "c-name" "{libcc-type}" "--" "libcc-type" -- ) + \ build time/first time action for c-function + init-c-source-file + noname create 2, lib-handle-addr @ , parse-name { d: c-name } - parse-function-types c-name string, - r> cell+ gen-wrapper-function - compile-wrapper-function - link-wrapper-function - r> ! + here parse-function-types c-name string, + ['] gen-wrapper-function c-source-file outfile-execute + does> ( ... -- ... ) + dup 2@ { xt-defer xt-cfr } + dup cff-lha @ @ 0= if + compile-wrapper-function + endif + link-wrapper-function xt-cfr >body ! + xt-cfr xt-defer defer! + xt-cfr execute ; + +: c-function-rt ( -- ) + \ run-time definition for c function; addr is the address where + \ the sym should be stored + noname create 0 , does> ( ... -- ... ) @ call-c ; - - - - -s" Library not found" exception constant err-nolib - -: library ( "name" "file" -- ) \ gforth -\G Dynamically links the library specified by @i{file}. Defines a -\G word @i{name} ( -- lib ) that starts the declaration of a -\G function from that library. - create parse-name open-lib dup 0= err-nolib and throw , - does> ( -- lib ) - @ ; - - +: c-function ( "forth-name" "c-name" "@{type@}" "--" "type" -- ) \ gforth + \G Define a Forth word @i{forth-name}. @i{Forth-name} has the + \G specified stack effect and calls the C function @code{c-name}. + defer lastxt dup c-function-rt lastxt c-function-ft + lastxt swap defer! ;