I  want  to  show that different  optimisations   are  being
applied by ecl itself and its invocation of the cc.

In a nutshell  I'm pretty sure that quoted objects end up in
read-only     memory    when   seen    by    #'compile-file.
Reiterating from last time a little,

(defun foo () '(1 2 3))

(disassemble 'foo)

/*       function      definition      for      FOO       */
/*  optimize   speed  3, debug  0, space  0,  safety   2  */
static cl_object L1foo()
{
 cl_object env0 = ECL_NIL;
const    cl_env_ptr    cl_env_copy    =   ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 {
TTL:
 value0 = VV[1];
 cl_env_copy->nvalues = 1;
 return value0;
 }
}

And now I want to see how this ends up when compiling an ecl
source file. Which involves a little bit of undocumented ecl
features.

```foo.ecl
(defun foo () '(1 2 3))
```

(ext:install-compiler)
(setq c::*delete-files* nil)
(compile-file #p\"foo.ecl\")

Now        we       have       the        left        overs:
foo.c
foo.data
foo.ecl
foo.eclh
foo.fas
foo.o

Then, the foo.data include is

static const struct ecl_base_string compiler_data_text1[]  =
{      (int8_t)t_base_string,      0,     ecl_aet_bc,     0,
 ECL_NIL, (cl_index)100, (cl_index)100,
 (ecl_base_char*)
"common-lisp-user::foo      (1     2     3)     0     (defun
common-lisp-user::foo) (#P\"foo.ecl\" . 0)" };

static    const   cl_object   compiler_data_text[]     =   {
(cl_object)compiler_data_text1,
NULL};

So  I think the ecl compiler  does compilation  between  the
READ and invoking the cc.