freenode/#clasp - IRC Chatlog

15:46:51 drmeister Hello Liz_

15:47:11 Liz_ Hello

16:18:16 Bike signal handlers can be per thread, so that's nice, except since mps uses sigsegv we can't just control the handler ourselves, probably

16:19:51 Bike trying to understand what sbcl does,but simple itis not

16:26:08 Bike sbcl also makes it seem like posix systems are kind of all over the place with important details, so that's pretty unfortunate

16:26:24 Bike but i'd reeeeeally like it if sigsegv didn't core dump

16:43:05 Kevslinger Hello Steven__

16:50:32 Bike feel free to use a more ridiculous internet codename

17:36:33 Kevslinger ** NICK kEvSlInGeR

17:36:36 kEvSlInGeR Yeah, like this

17:36:40 kEvSlInGeR ** NICK Kevslinger

18:21:20 Liz_ ** NICK RickyRat

20:36:16 karlosz eesh, clisp doesn't expose anything about types at all on the bytecode level

20:36:25 karlosz no instructions for checking types etc...

20:36:40 karlosz i think typep is just implemented at the c level

20:36:54 karlosz that will make it harder to do type inference

20:38:44 Bike calling functions to do type checks is fine

20:38:46 Bike tho itll be slow

20:39:04 karlosz yeah ill have to make typeq just punt

20:39:20 karlosz actually

20:39:23 karlosz thats okay

20:39:28 karlosz i can still elide typechecks

20:39:54 karlosz whats the best way to inline function calls?

20:39:59 karlosz as in

20:40:08 karlosz right not HIR just compiles everything to fdefinition + funcall

20:40:11 karlosz computed funcall

20:40:29 karlosz but if the function is known, like #'+ or otherwise

20:40:59 karlosz wouild i have to resort to adding new instruction types on the MIR level to take advantage of specializing?

20:41:37 Bike typeq also won't be generated by the compiler

20:41:42 Bike you could just not implement it

20:42:20 Bike for cleavir to inline functions you have to let it know about ASTs

20:42:29 Bike the function-info objects can have an AST in them.

20:43:07 karlosz i don't exactly mean inline functions

20:43:15 Bike we have a lessthan operation defined on filesystem paths

20:43:19 karlosz from source

20:43:38 karlosz as in system provided functions don't need to go through fdefinition and computed funcall

20:44:15 karlosz ie. clisp compiles (lambda (x) (funcall (fdefinition '1+) x)) the same as cleavir compiles (llambda (x) (1+ x)) right now

20:44:44 karlosz whereas (lambda (x) (1+ x)) in clisp compiles to a shorter instruction sequence since 1+ is in a specialized 'funtab'

20:45:15 Bike the funtab being written in what, the vm language?

20:46:10 karlosz no, i think the functions in funtab are foregin functions implemented in c

20:46:22 karlosz for example, dissassemble on '1+ drops into gdb in clisp

20:46:51 karlosz the bytecode instruction is ex. (CALLS2 177) ; 1+

20:47:02 karlosz corresponding to calling (1+ x)

20:47:42 karlosz whereas what cleavir generates now is calling fdefinition on '1+

20:47:44 karlosz pushing it on the stack

20:47:50 karlosz then pushing all the args on the stack

20:47:53 karlosz and then calling (FUNCALL)

20:48:04 karlosz (this is the clisp instruction set)

20:48:50 Bike you could add a hir instruction for "system call" or the like

20:48:59 Bike clasp does that too, for C++ calls

20:49:09 Bike add an ast as well, have 1+ expand into it

20:49:11 karlosz okay, then that is the right approach

20:50:18 karlosz does clasp just lookup C++ functions in a table to determine whether to produce the C++ all ast node?

20:50:33 karlosz *call

20:51:06 Bike I don't understand what you mean.

20:51:30 karlosz how does clasp determine a priori whtehrt o compile a function to a c++ ast node

20:52:00 Bike it's part of the information about the function.

20:52:15 Bike Like, the function-info for 1+ or whatever has an AST, and that AST is the foreign call thing.

20:53:03 karlosz okay, that makes sense.

20:54:31 Bike So I guess you'd write a definition like (declaim (inline 1+)) (defun 1+ (n) (system-call 177 n))

20:54:40 Bike and then define a thing so system-call is a special operator.

20:56:22 karlosz clisp already has a function that queries whether a function is 'system'. so i could just ask the function and convert the appropriate ast node during cst to ast conversion, right?

20:57:54 karlosz i.e. convert function calls differently to ast depending on whether they are system or not during cst->ast

20:59:30 Bike Yes, in that case you'd do it as part of your method on function-info I would say

21:00:36 karlosz alright

21:00:45 karlosz and why doesn't typeq get generated?

21:00:58 karlosz arent those nodes needed for type inference?

21:01:13 karlosz im a little confused why HIR doesn't convert to half the instructions documented

21:01:39 Bike well, what would generate typeq?

21:01:43 karlosz are those introudced by later transformation?

21:01:49 karlosz typep x fixnum

21:02:00 Bike right, but typep is a function.

21:02:11 Bike if you want it to generate typeq you'll need to provide a definition for typep that uses typeq.

21:02:35 karlosz definition in what senese?

21:02:52 karlosz same with eq-instruction

21:03:07 Bike probably an inline definition

21:03:10 karlosz (if (eq x y) x y) converts to a function call to eq

21:03:13 karlosz and then produces eq instruction

21:03:28 Bike clasp has (defun eq (x y) (if (cleavir-primop:eq x y) t nil))

21:04:03 Bike so the ast doesn't have a function call, just the eq ast, which is converted into the eq instruction.

21:04:11 Bike cleavir is pretty heavily designed around inlining.

21:04:42 karlosz yeah, so it seems

21:04:55 karlosz then i would need to redefine clisp's CL functions

21:05:01 karlosz and declaim them inline

21:05:10 karlosz at least for things like eq and typep

21:05:22 karlosz if i want to take advantage of those primops

21:05:51 Bike yep.

21:05:57 Bike or just have function-info return an appropriate ast.

21:06:14 karlosz great, thanks for your help

21:06:33 Bike no problem.