MLCompiler/CodeTree/CODETREE_SIMPLIFIER.sml

166     |   simpGeneral context (Eval {function, argList, resultType}) =
167             SOME(specialToGeneral(simpFunctionCall(function, argList, resultType, context, RevList[])))
464        an inline function respectively if that's possible.  Getting that also involves
483     |   simpSpecial (Eval {function, argList, resultType}, context, tailDecs) =
484             simpFunctionCall(function, argList, resultType, context, tailDecs)
556                functions.  The main function body takes its arguments on
557                the stack (or in registers) and the auxiliary inline function,
559                calls it.  If the main function is recursive it will first
560                call the inline function which is why the pair are mutually
562                As far as possible we want to use the main function since that
563                uses the least memory.  Specifically, if the function recurses
567                 (* Reorder the function so the explicitly-inlined ones come first.
591                     (* Update the entry in the table to include any inlineable function. *)
610                 (* If we have inline expanded a function that sets the container
675             (* A new table for the new function. *)
760             (* Clean up the function body at this point if it could be inlined.
762                can be the result of creating both a general and special function
763                inside an inline function. *)
769             (* The optimiser checks the size of a function and decides whether it can be inlined.
795             (* The optimiser checks the size of a function and decides whether it can be inlined.
810     and simpFunctionCall(function, argList, resultType, context as { reprocess, maxInlineSize, ...}, tailDecs) =
812         (* Function call - This may involve inlining the function. *)
814         (* Get the function to be called and see if it is inline or
816         val (genFunct, decsFunct, specFunct) = simpSpecial(function, context, tailDecs)
817         (* We have to make a special check here that we are not passing in the function
821            or the closure of a function as well as passed directly. *)
823             case function of
845                 (* Expand a function inline, either one marked explicitly to be inlined or one detected as "small". *)
847                    The function is replaced with a block containing declarations
849                    we use to index it are the addresses which are local to the function.
850                    New addresses are created in the range of the surrounding function. *)
892         |   (_, gen as Constnt _, _) => (* Not inlinable - constant function. *)
896                     Eval {function = gen, argList = copiedArgs, resultType=resultType}
905                     Eval {function = gen, argList = copiedArgs, resultType=resultType}
959                    (or possibly a function) it can't be null. *)
1191                     |   _ => raise InternalError "simpArbitraryCompare: Unimplemented function"
1268                 |   _ => raise InternalError "simpArbitraryArith: Unimplemented function"
1331     (* A built-in function.  We can call certain built-ins immediately if
1342         (* If the function is an RTS call that is safe to evaluate immediately and all the
1356             (* Call the function.  If it raises an exception (e.g. divide
1614        functions that return tuples.  Without this the function will lose tail-recursion