view Changes @ 321:80beb03e5b73

ULL,ull, 0x0ull etc.
author kono
date Sat, 19 Jun 2004 07:11:12 +0900 (2004-06-18)
parents 9fe0b32a7d57
children 46ac55e8b14c
line wrap: on
line source

Thu Nov 25 17:27:12 JST 1999

subroutine call ���ʤ�
�ɽ��ѿ���ʤ�
�������ꡢ����ѿ���¿�Ѥ���
����ѿ��Υ������פ϶ɽ�Ū
Fortran ���Ѥ˶ɽ��ѿ�����Ū�˼��
recursion ������ˤϡ���ʬ����¸����
subroutine call���Υ쥸�����Υ����֤�ɽ�Ū�˹Ԥ�
����ϡ�����ä��Ѥ���ʤ�?
��äѤ�ǥե���ȤΥե졼��ϻ����⤯��?

recursive call �Ȥ����Ǥʤ��Τ���̤��뤫? 

fp ���Ѱդ��������ɤ�

�ؿ������Ʊ���ˡ��������Ѥ�fp�ι�¤�Τ��Ѱդ���

C ��compile������ˤϡ�stack������⤯
    fp = (struct func_state *)stack 
���äȡ��ɤ������������? ������������⤢��櫓�͡�
���㤢��fp������? ����ϵ�������ʤ��ʡ�static 
��fp�ˤ�����ɤ��櫓�͡�

func(void *stack) {
    static struct func_state {
	static struct func_state *fp;
	int local1;
	brahbrah...
    } func_state;     // �����ޤ� hidden
    func_state.fp = (stack -= sizeof(struct func_state));
}

func_state ��ȤäƤ���黻�Ҥ����ä������ɤ�? �����͡�
    func.state
���餤?

fp->local1 �ߤ����ʤ��Ȥ�������ʤ顢C ��Ʊ���ˤʤ롣

call �������arguemnt �⡢
    static �� func_state ���֤�
    stack ��� func_state ���֤�
�Ȥ������̤������褬���롣C�ȸߴ��ʤ顢��������ԡ�

Recursive �ʤ��Ԥ��������θ���Ͼ������ܤ򵭽Ҥ��뤫�顢static
�ʤ�ΤǤ��ɤ��Ϥ���

Internal function ��? ���äƤ⤤���������...

Recursive call ������ˤϡ� fp ��save����ɬ�פ�����͡�
    (--(struct func_state *)stack) = fp;
    call callee(&fp->arg,continuation,stack);
call ���Ƥ⡢��ä���ʤ�����... continuation �ϰ���Ū�ˤ�code
������... ����� Internal function �ˤ��뤫��

continuation �˰���Ū��compile������ˡ��ͤ��ʤ��Ȥ����ʤ�����
self ��ɬ�פʤ櫓��?

�����̾����ͤ��ʤ��Ȥ�����ʤ���

C ����Υ���ѥ����񤫤ʤ��Ȥ����ʤ��Τ�...

Mon Dec 13 18:53:04 JST 1999

compiler based �ǡ������� partial evaluation �Ǥ���?

func ��database�Ȥ��ư����ʤ��ʤ顢����ϤǤ��ʤ���

���������������ܤȤ��Ƥϼ�갷���롣

    func.state
    func.code

�ߤ����ʷ��ˤ���partial evaluation������ɤ�

�Ǥ�ߤޤ�Τ�?

textual �Ǥʤ������Ū�ʥ�����ɽ�������ä������ɤ�? <-> interpreter?

Prolog �ǤϤʤ�Ǥ����ʤ���? --> Unification ���Ť�����

Sat Nov 27 13:50:41 JST 1999

func.state �Ȥ����Τ��ä��顢
    struct {
	struct {
	    int i;
	} state;
	state *code = {
	    i = i+1;
	};
    } name;
�ߤ����ʷ��ǡ����켫�Τ�¤�������? �ǡ������������ʬɾ������롣
�������ǽ���ʤ�ۤɡ�
	*name.code;
�ͤϤ���櫓? �ͤ� &state �Ǥ��礦�͡�
self �������
    struct {
	struct {
	    int i;
	} state,
	*code = {
	    self->i = self->i+1;
	};
    } name;
���ʡ�self = state ����͡�

union �γ�ĥ�⤢�碌�Ƶ��������...

Partial evalutator �򥻥ޥ�ƥ�������¹ԷϤˤ���Ƥ������Ȥϲ�ǽ��?

byte code �Ȥ����ۥޥ�����ä����ǽ�������Ǥʤ�����?

������ˤ��衢��¤�ΤΥ�����unique���������ʤ��Ȥ�����ʡ�

�إå��ե�����Ϥɤ������?

Mon Dec 13 18:53:18 JST 1999

library �Ȥ���������?

exec sequence �Ǥϡ�
    (--(struct func_state *)stack) = fp;
    call callee(&fp->arg);
�Ȥ�������pointer�����Ϥ���? ������Ѥ���͡�

���Ϥ��ˤ���Ȥ���С�ʣ�����ͤ��Ϥ����ۤ����ɤ���

    func(void *stack) {
	static struct func_state {
	    static struct func_state *fp;
	    int local1;
	    brahbrah...
	} func_state;     // �����ޤ� hidden
	func_state.fp = (stack -= sizeof(struct func_state));
    }

�ΰ������Τ�����¤�ΤǤ���٤���

    func(
	struct void *stack
	) {
	static struct func_state {
	    static struct func_state *fp;
	    int local1;
	    brahbrah...
	} func_state;     // �����ޤ� hidden
	func_state.fp = (stack -= sizeof(struct func_state));
    }

�ǡ���¤�Τ� register storage �������

    func(
	static struct argment {
	    register void *stack;
	    register void *continuation;
	}
	) {
	static struct func_state {
	    static struct func_state *fp;
	    int local1;
	    brahbrah...
	} func_state;     // �����ޤ� hidden
	func_state.fp = (stack -= sizeof(struct func_state));
    }

����ȡ�caller �����⡢��¤�Τ�����Ȥ���Τ�������

    call caller(
	static struct argment {
	    register void *stack;
	    register void *continuation;
	} arg = {a,b};
    )

�ߤ����ʡ�������󡢤��ι�¤�Τϥ��󥿥ե������ȸƤФ�롣

argument �ϡ�callee �ˤ��ä������ɤ����ɡ�caller ¦�ˤ��äƤ�
�ɤ���register �ʤ󤫤ϡ�������

	caller(interface caller_arg = {a,b,c})
�ߤ�����syntax ���ʡ�
	caller->interface = {a,b,c};
	*caller->code;
��
	caller(a,b,c);
�ȾΤ��롣

function �ˤϡ�interface �� code �� state �����뤳�Ȥˤʤ롣

state �˥��������������lock��? protected state? synchonized state ����?
�������sequential implementatoin�Ǥϡ�����ʤ�ΤϤ���ʤ���

function {
    interface:
	register int a;
	register struct self self;
    state:
	int b;
	serialized int c;
    code:
	b  = a;
}

int ��void value ��������롣�����ϽŤ��ʤ뤱��...

serialzed �� semantics ��?

�⤦����micro-C�˶᤯! 

carring state �� static state��

Mon Dec 13 19:42:41 JST 1999

interface �� regsiter keyword ��Ȥ��Τϡ����ޤ��
������ꤹ���롣�Ǥ⡢�Ǥʤ��Ⱦ��֤ˤǤ��ʤ�?
����ʤ��ȤϤʤ�������äѤ�caller¦��static �ΰ��
ľ�ܽ񤭹���?

����C����٤������Ǥ⡢������40�ĤȤ������줿��...

Wed Dec 15 14:09:49 JST 1999

C �ȸߴ��ˤ���?
	goto function(argments);
	goto *continuation(argments);
�ߤ����ʴ����ǡ�

stack�δ�����? �ɤ�����library �Ȥθߴ��ϤȤ�ʤ���
�����ʤ��������...

local �ѿ���������� stack ��ư�������Ǥ⡢�᤹�ۤ����ʤ���
closure �����뤫?

return �������ε�ư��ʣ���ˤʤ롣���return����櫓���顣

argments ��static �ΰ�ˤ��������������ȸߴ������Ȥ�ʤ���
stack ��� frmae pointer ��ˤʤ��ȥ�������顣

ξΩ������Τ�̵����? �Ĥޤꡢ������ȡ��ƤӽФ��줿����
frame semantics �ϡ�C �ȸߴ��ˤʤ롣�����顢stack��ľ���
frame pointer ������ȻפäƤ��� (������? ) frame pointer
stack pointer �˱�äư�ư����ľ��ˡ����������offset
�ǰ��������뤳�Ȥˤʤ롣

�Ĥޤꡢ����Ϥ�����ä����Ȥ���ʤ�? �Ĥޤꡢgoto ���ȡ�
frame pointer �ϡ�stack ��ľ��Ȥϸ¤�ʤ����顣����
frmae pointer ���Ф˰����˥����������Ƥ������̤����ɤ͡�

stack �˰������Ѥ�Τ���ǧ���ơ�goto �ξ��ϡ�������¦��
stack �����äƤΤ�?  �Ȥ������Ȥϡ����̤δؿ��������
��ˡ���Ѥ���äƤ��Ȥ����ޡ������Ϥʤ�����

����ȡ�goto ��semantics �ϡ�C �ȸߴ��ˤʤ롣����������
�����ۤʤ뤳�Ȥ򤹤롣����ϡ��ʤ󤫤��������ʡ�����ˡ�
������ȴؿ��ƤӽФ����ڤ��ʤ�ʤ�...

�Ȥ������Ȥϡ���ϤꡢC ��call �ϡ�call funciton ��
�¸����ơ�����¾�θƤӽФ��ϡ����٤ơ�goto ������
����������������������

����ϡ����θ���δؿ���call���줿�����ʡ�dual entry �ˤ��ơ�
call �λ��ȡ�goto �λ�����̤��뤫��
	func:	stack processing
	func_goto: normal processing
         ...
�ߤ����ʴ������Ǥ⡢return �Ϥʤ�����...

���Τ�����⼫ʬ�ǵ��ҤǤ������Ǥ���٤�����͡������̤ꡣ
�ĤޤꡢC �Ȥ�stub �⼫ʬ�ǵ��Ҥ���ȸ������Ȥ���

protocol function {
    interface c {
	register "%esp" struct {
	    entry code ret(int);
	    void *fp;
	} *sp;
	register "%ebp" void *fp;
    };
    code function_code {
	fp = sp;
	sp += sizeof(struct local);
	struct local *local = sp;

	local->i = 1;
	goto *fp->ret(local->i),sp=fp;  // return(local->i);
    };
}

�ߤ����ʴ����Ǥ������ä�����������֥顣���ޤ���return���������ɡ�
�ޤ���return �Ϥ��Τޤ�return�Ǥ⤤�����ɤ���

����������ɤ������Τ�ʤ���code ��ʣ�������뤫�顣

state �ʳ��ϡ�consitent state �Ǥ��뤳�Ȥ��ݾڤ��ʤ����äƤΤ�?
local �ѿ��ϻȤäƤ��ɤ����ɡ�call/goto ������ǡ��ͤ��ݾڤ��ʤ���...

�����󡢤�������������Ƥ�ʤ���

�����顢�쥸�������Ф���ޥåԥ󥰤ε��Ҥȡ������Ǥʤ���ʬ��
���Ҥ�ʬΥ����٤��Ǥ��礦�͡�


�������դ˼�������櫓�ˤϤ����ʤ����餡...

Thu Dec 16 13:44:21 JST 1999

lock �Ͼ������ܥ�٥�Ǽ¸�����Τ����顢self �ʤɤ�
�Ȥä�lock����ɬ�פϤʤ��Ϥ���

���Τ�ľ�󲽤ϡ��������ܥ�٥�ǡ�
	lock(storage) -> transition
�ߤ����ʷ��ǵ��Ҥ�����ɤ�������������򡢤ɤΤ褦�˵��Ҥ��뤫��
�⤦���������ꤷ�褦��


�����ϥ쥸�����Ϥ��ˤ��褦��Ĺ�������ϡ��ƤӽФ�¦���ΰ�ؤ�
�ݥ��󥿤Ȥ��롣�������ꤷ�Ƥ��ɤ�����������С�varargs
�ߤ����ʤ�ΤϤʤ��ʤ롣�����������ʤ�ǡ�����ʤ�Τ�����������?
������Ϥ��Ф��������

�ʤΤǡ������ϰ��(or ���)�˸¤�Ȥ�����ˡ�⤢�롣

�Ȥ���ȡ���Ϥꡢ����ä���Ū�ΰ��ưŪ�ΰ����ݤ��뤳�Ȥ�
�Ǥ��ʤ���

���θ���Ǥ�ưŪ�ΰ�ϼ�ʬ�dz��ݤ���櫓�����顢������������ʤ���

Thu Dec 16 20:24:55 JST 1999

�Ȥ���ȴؿ��ƤӽФ��ϡ�
	# register save
	# set 1st argument in register %eax
	# set 2nd argument in register %ecx
	# set extra aguments in save area
	# set extra argument pointer in %edx
	    jmp function
�Ȥ��������ˤʤ�櫓�͡�second ���������ΤϤ��ɤ�����������
�ˤ��褦��

�����ȡ�frame pointer �Ϥʤ����ɡ�����ѥ���μ�礫�餹���
���ä������ɤ�����������frame pointer ���Τ�Τ�static
�ˤȤ�ΤϤޤ����������顢frame pointer ��first argment
�Ȥ������Ȥˤ����������������Ȥ���Ȱ����ϡ�����ˡ�����
��ȸ����櫓����
	f(fp,argment)
fp ���Ϥ��Τˤ����argment ��쥸�������Ϥ��ΤϤ��������������������ɡ�
�ޡ��ɤ�����

return ���ʤ��ʤ顢return type �������Ȥ�Τ��Ѥ��ʡ�

f(fp,arg1,arg2,arg3) �Ȥ���ȡ����줾�줬��ޤä��쥸���������äơ�
¿��ʬ������ˤ���Ȼפ��롣�դ�դ�...
    fp->xx 
�ǥ�����������С����Τޤ޶ɽ��ѿ��ˤʤ롣�����������
���äƤ��ɤ���

  .set label,value

�� as ���ͤ򥻥åȤ���褦�Ǥ��͡�

�ؿ�������θ����ä���ʤ����������ο��ۤϤ��ʤ��Ƥ褤��
frame pointer ��Ȥä��鼫ʬ�����ݤ򸫤뤳�ȡ�

����
	a = atoi(s);
�ߤ����ʤ��ȤϤǤ��ʤ�...

���̤�C������ȸ򤸤�ȴְ㤤�䤹����

�Ȥ���ȡ�struct ��Ʊ�ͤˡ�
	protocol
	code
	interface
	state
���Ѱդ���櫓�͡����֤���Τ���?

�Ȥꤢ������register �Ϥ���function �����gotoʸ��������롣

code name(register "%ebp" void *arg) {
    goto name(arg);
}
 
���餤����? �ǡ�first argment ��ɬ��register�ˤΤ�褦�ˤ��ʤ���
�����ʤ���register storage class ������ơ�
    register "%ebp" void *arg
�Ȥ�����櫓�͡�

�äƤ��Ȥϡ��ޤ����쥸������������ʤ��Ȥ����ʤ��櫓�͡�

�ǡ�stack ��Ȥä��黻�ϡ���������Τޤޤˤ���? ����Ǥ�ư���Ϥ���
���������goto�ϻȤ��ʤ�������顢����Ǥ����Ϥ���

�ǡ����줫�顢������ĥ���Ƥ�����

interface c {
    register "%ebp" void *arg;
}
code name(interface c) {
    goto name(c.arg);  // c. �Ͼ�ά��ǽ
}

�Ȥ��͡�����ˡ�

protocol name {
    interface c {
	register "%ebp" void *arg;
    }
    code name(interface c) {
	goto name(arg);
    }
    code name1(interface c) {
	goto name(arg);
    }
}

�ʤɤȤ���櫓�����ʤ�ȡ����줬 C �ȶ�¸����櫓�͡�������

Fri Dec 31 11:44:03 JST 1999

code �Ǥʤ��ơ��̤�̾���Τۤ����ɤ��ʤ�? segment? action?

�쥸����̾������Τϡ���äѤꤤ�䡣optional�ˤϵ�����

interface �Ϲ�¤�ΤΤ褦�ʤ�Τ�����... ��¤�ΤǤ����󤸤�ʤ�?
��¤�Τξ���... malloc ����? ����������malloc ����Ȥ��ơ�
����free �����?

��������Ȥ��ˤϡ�����ƤƤ����󤸤�ʤ�? multi-thread �Ǥʤ���Ф͡�
multi thread �Ǥϡ����֤ϡ��쥸������ͳ�ޤ��ϡ�thread local �˻���
ɬ�פ����롣static �ϡ������� thread local �˻����ʤ��ƤϤʤ�ʤ���
����ѿ��˳�꿶�ä�����ᡣ�Ǥ⡢���ޤϡ�����

interface �ϡ��Ȥꤢ��������ĤޤǤ����Ϥ��ˤ��褦��
	self �� arg
�Ǥ��͡�

�⤦������ĥ���䤹������ѥ��餬�����ʤ���

    code name (c,a)
    struct state *c; struct arg *a;
    {
	goto name(arg);
    }

local �ѿ���? ���θߴ��������꤫����

KL/1 ��ռ����ơ�interface �� heap ���֤����Ȥˤ��Ƥ��ɤ���
GC �ϸ��������Ƥ����٤�������interface�� machine independent
�Ǥ���٤������Ȥ���� use/forget �ߤ�����ΤϤ����������
�Ǥ⺣�ΤȤ����Ϲͤ���ɬ�פϤʤ���

�����ȡ�
    code name (c,a)
    struct state *c; struct arg *a;
    {
	int i;
	goto name(arg);
    }
�λ��ΰ���ѿ�i�Ϥɤ������? ����Ū�ˤϥ쥸����������Ƥ�����...
���Ѥ����ʤ�? �󡼡������ʸ�ո����ޤ�����äѤ�heap�˳�����Ƥ��㤦
�Τ���ñ�����Ǥ⡢�ɤ���ȴ������ˤϤ���ʤ��ʤ�櫓������...

�ۤ�餤�������ѿ��ϡ�����call�Ǥ�ɬ��̵���ʤ�Τ����̡�

�Ȥˤ������쥸�����ѿ���ɬ�פʤ�Ǥ��礦?

�����顢GC �ȹ�碌�Ƹ�����߷פ��٤�����͡�API ���ꤷ�ơ�
�ۤʤ�GC������Ǥ���褦�ˤ��롣

Sat Jan  1 22:40:22 JST 2000

�ȡ��ˤ����� storage class regisgter ��������褦��

    stmode=REGISTER

�ǡ�local storage �Ȥ��ʤ������Ȥ���
	static register? �ϡ��ʤ���

symbol table �� storage class �򤿤���? dsp==EXTRN ��Ƚ�ꤷ�Ƥ��뤫�顢
local �ѿ���36�ʾ夢��Ȥ��������ʤ뤾?

sc  �� GVAR/LVAR �����ɡ�regsiter �� LVAR ���ü���ۤ����顢
sc �������ۤ�����������...

Sun Jan  2 01:47:17 JST 2000

register �ѿ��ϤǤ��ޤ��������ɡ�regsiter ����ĻȤ��ȡ�
���դˤʤäƤ��ޤ��Τǡ�REGISTER6 �ǥ���ѥ��뤷�ʤ���
�빽�Ҥɤ�������register �ѿ���%esi,%edi �˳�����Ƥ��
��������

Sun Jan  2 04:43:04 JST 2000

�ǡ�
    code name (c,a)
    struct state *c; struct arg *a;
    {
	goto name(c);
    }
�ΰ���ѿ�̵���ϼ����Ǥ��ޤ�����������ĤޤǤ͡�

	.file "tmp.c"
	.version	"01.01"
gcc2_compiled.:
.text
# 
# code name(c,a)
	.align 2
.globl code
code:
	.type	code,@function
#    struct state *c; struct arg *a;
# {
#	goto name(c);
	movl %esi,%esi
	jmp	name
_5:
	.size	code,_5-code
	.ident "Micro-C compiled"

������������

goto ʸ�����ɤ�������stack �򤿤���ǡ�jmp �����
�褤��������..

Sun Jan  2 11:17:50 JST 2000

���̤�call��continuation base�ˤ��뤳�Ȥ��Ǥ���?

Sun Jan  2 20:28:45 JST 2000

goto ʸ�����ɡ���Ϥꡢ���١�expr ���������Ƥ��顢top level
�� jump code ���������褦��

Tue Jan  4 03:32:55 JST 2000

code ��type�ˤ��ʤ��ȡ�
	code *p;
�Ȥ��񤱤ʤ��͡�
	int *p();
��Ʊ�������ɤ���


    main(ac,av)
    int ac;
    char *av[];
    {
	goto code1(ac,av);
    }

    code code1(ac,av)
    int ac;
    char *av[];
    {
	if (ac)
	    goto code1(ac,av);
	else
	    goto ac(ac,av);
    }

Tue Jan  4 04:56:56 JST 2000

�����󡢤ʤ󤫥쥸�����ˤĤ������㤦
����ϡ�adecl ��reverse�ˤĤफ�顣

code ��retrun

��Ϥ�code��type�ˤ��ʤ��Ȥ��ᡣ

main()
{
    goto code1();
}

�Ȥ����ȡ�main ����ä����ʤ����������code1() �ʹߤǡ�
return ����櫓�ˤϤ����ʤ���(main �� disp ��code1 ���Τ����ʤ�)
goto label ��code1����������?

main()
{
    goto code1(ret);
ret:
}

������ȡ�ret ��forward label���ɤ���ʬ����ʤ�����?

code1 ��ǻȤ�����ѿ��� stack ��ˤȤ�Τϰ����ʤ����������������
%ebp ��ͳ�ǥ�����������Ȥ������Ȥϡ�main ������ѿ�������Ȥ������ȡ�
������ɤ��ˤϡ�main ���goto code�ǡ�%ebp �������Ƥ����ɤ���
(������ä���ʤ��Τ�����ʤ�)

code1 ��goto �Ǥϡ���ä���ʤ����顢����ɬ�פϤʤ�����������
label ��code1 ����Ϥ����ȡ�����äȵ��ޤ�����

�Ȥ���ȡ�����϶ػߤ��ơ�main() ���stack�򤿤���Ǥ���goto���뤫?
��������ȡ�̵�¸��ष�ơ���ɡ�����ʤ����Ȥˤʤ�... ������

main() ���local code ������С�����ϲ�褹�뤬..

main()
{
    goto code1(code2);
    code code2() {
	return;
    }
}

�ߤ����ʴ������Ǥ⡢���������scope rule ���Ѥ���ɬ�פ�����ΤǸ�������
�ޡ������Ϥʤ����ɤ͡�

continuation ������������ˡ�⤢�롣

main()
{
    goto code1(continuation);
}
code code1(ret) 
code (*ret)();
{
    goto *ret;
}

����? call/cc ?

label �ؤ�goto������Τ⤤�����ɡ�
�Ǥ⡢label ������ȡ�������spagetty�ˤʤ�ʤ�?


Tue Jan  4 11:47:24 JST 2000

contiunation ����ʤ��ơ�return keyword ��Ȥ�����
(�ºݡ�continuation �Ⱦ����㤦��)
type �������Ѥˤʤ뤱�ɡ��ޤ��ɤ���

int
main()
{
    goto code1(return);
}
code code1(ret) 
code (*ret)(int);
{
    goto *ret(3);
}

���ʡ�prototype ���դ��ʤ��Ȥ����ʤ�����

Tue Jan  4 12:21:44 JST 2000

�������method�����٤�static �ˤʤäƤ��ޤ���dynamic ��method
�ƤӽФ��ˤ���ˤ�? dipatcher ��ʬ�Ǻ�뤳�Ȥˤʤ롣���ʤ�
���ɤ�������...

code method(obj,arg)
{
}

�������뤤�ϡ�inline �ˤ��뤫... #define �Τ����� inline �ͤ���
����Ϥ��Ȥǹͤ����ɤ���

Tue Jan  4 14:22:19 JST 2000

main ���ѿ�����٤��Τȡ�gotgo (*reg)(123) �Ǥ��ͤϡ�
register �Ϥ��ǡ�current register �ˤΤ�ʤ��Τǡ�
��ɡ�return label �����Ѥ˺��ɬ�פ����롣

Tue Jan  4 18:14:07 JST 2000

stack ��Ѥ�­���ơ��ƤӽФ���������С�call by value
��register �Ϥ������¤���ɬ�פ�̵���ʤ롣

ʣ�����ͤ��֤����Ȥ��ưפ���

	.file "tmp.c"
	.version	"01.01"
gcc2_compiled.:
.text
# 
# code name(a,b,c,d,e,f)
	.align 2
.globl code
code:
	.type	code,@function
#    struct arg *a,*b,*c,*d,*e,*f;
# {
#	int g;
#	goto name(a,b,d,e,f);
	jmp	name
_5:
	.size	code,_5-code
	.ident "Micro-C compiled"

����?!
	%esp  new %esp = old %esp - 12 -4
	%ebp-4     = g
        %esi       = a
        %edi       = b
        %ebp = old %esp   0
        %ebp+4     = c       code_arg_offset=0
        %ebp+8     = d
        %ebp+12    = e
        %ebp+16    = f

interface ���դ��褦! �Ȥ�������
	goto name(struct {xxxx})
�ߤ����ʴ������ɤ��櫓�͡��ɤ��register�ˤ���뤫�ȸ�������Ϥ��뤬��

�ǡ��ɤ���ä�call����Ф����櫓? emit_push���뤫����push
����?

����������Ǥϡ����ᤫ��code argument �ο����Ѥ��ȡ�
ebp �򤤤�����ư�������Ȥˤʤ롣�����ˤ�old sp �����뤫��
�����Ĥ⥳�ԡ�����ɬ�פ����롣

	%esp  new %esp = old %esp - 20
	%ebp-20   = g
        %esi      = a
        %edi      = b
        %ebp-16   = c code_arg_offset= -16 ((nargs-max_reg)*int_size)
        %ebp-12   = d
        %ebp-8    = e
        %ebp-4    = f
        %ebp = old %esp   0

��������function ����call������ˤϡ�local �ѿ�����٤����ɤ���

#	goto name(a,b,d,e,f);

	%esp  new %esp = old %esp - 20
	%ebp-20   = g
        %esi      = a
        %edi      = b
        %ebp-16   = c code_arg_offset= -16 ((nargs-max_reg)*int_size)
        %ebp-12   = d
        %ebp-8    = e
        %ebp-4    = f
        %ebp = old %esp   0      disp=0 (*)
         local1 <----16 local variable      
        %edx        -12   <- disp_offset
        %ecx         -8
        %ebx         -4
        %ebp = %esp   0
        %eip          4   <- arg_offset

�Ȥʤ롣�Ȥ������Ȥϡ�pushl %ebp �ϡ��ְ㤤��

�����ɡ�%ebp �򤽤Τޤ޻Ȥ��Τ��ɤ��ʤ���disp_offset �������äƤ��뤫�顣
�����顢�⤦���� pushl %ebp �����ۤ����褤����������push ������ϡ�
���(*)��
	leave           movl %ebp,%esp
			popl %ebp
����ʤ��ä���?

Thu Jan  6 13:00:33 JST 2000

�Ǥ����͡�����ǤȤꤢ����ư���Ϥ���®�٤��������...
���Ȥϡ�
	ANSI-C prototype
	ANSI-C prototype check
	Interface Definietion
	GC support
	Direct handling of Frame
���͡���ñ�˽��褽��? ���֤�...

Fri Jan  7 09:42:53 JST 2000

goto ʸ��ư���Ƥʤ��ä������� peep hole optimization version ��
��뤫?

continuation �Ȥ��� label �������褦�ˤ���٤���?
��������������ʤ�����ɡ�����äȡ������ץ�����ब
�����褦�ˤʤ롣���ȡ�����¦�δĶ�(frame)��ݻ�����
ɬ�פ����롣�ޡ��Ǥ��ʤ��Ϥʤ���...

��������ȡ�label ���ͤ���Ĥ褦�ˤʤ롣
	a = label:;
�Ȥ���������label:(a,b,c) {}; �ߤ����ʷ��ǡ�parallel ����������ȸ���
��⤢��͡�

�����������C�Ȥ��������ɤ���... main() { label:(){ ... } }
�ߤ�����nest��������ɤ����ȸ������꤬���롣
�ѿ��λ��Ȥ�����ʤ���С��ä�����Ϥʤ���

a = label: �ϡ���Ťΰ�̣������ʤ���

�����̾����DinnerBell II �Ȥ�? join �������?
	code entry_a().entry_b() {}
�Ǥ���? parallel call ��?

Fri Jan  7 19:53:53 JST 2000

���ޤΤޤޤ��� return ���Ķ�����äƤʤ����顢���æ�ФǤ��ʤ���
�ޤ����Ķ�������Ƥ⤤��������ɡ��ɤ����֤����ȸ������꤬
����͡�

��������ʤ��ơ�return ¦��Ƚ�Ǥ��뤫? 
	retrun(ID)
�ߤ����ʷ���ID��Ƚ�Ǥ��롣��������С�return ¦��ID
�򸫤�Ƚ�ǤǤ��롣����...

�ޤ����Ϥ�ꡢ�Ķ�����ä��⤯�����������ʤ����Ǥ⡢
�����Ϥ��Ƥ��뤫�顢��İ����Ϥ��ơ�������Ȥ�줿�Ȥ��ˡ�
ȿ��¦���ä��Ƥ��ޤ��ΤϤ�������͡����Τޤޤʤ�С�
�����������Ȥϵ�����ʤ���

continuation ��ͭ��������򤱤�ʤ顢���ΤޤޤǤ⤤�������...
contrinuation ��Ķ��ϡ����Υ����ƥ�Ǥϼ�ʬ�Ǻ�뤳�Ȥ�
�Ǥ��뤫��͡�

�����ʤ������.... retlabel �� retcont �ϼ¤ϥ��֥�������
���Τ˰�Ĥ�����ɤ���

�������Ϥ��Ȥ��ˡ������˴Ķ��ؤΥݥ��󥿤򤤤�Ƥ����ɤ��Τǡ�
���ϳ�ȴ�ñ��������������ȡ���ι�¤�Τ�������Ϥ��ȸ���
������褹��ɬ�פ����롣

�Ǥ⡢���μ����ʤ�С��ޤä���Ʊ���ѿ��ι����ʤ�Х��ԡ���
�ºݤˤϵ�����ʤ��櫓����������ʤ��Ϥ����äˡ�������ݾڤ��뤿��ˡ�
interface ���������ɬ�פ����롣

return ->
	(void *)old bp
	return address

bp ��ľ�����Ǥ���褦�ˤ���Ȥ����������.... 

Sat Jan  8 08:49:59 JST 2000

���ϡ�code ��Ǥ�return�Ǥ��ʤ��櫓�����ɡ��¤ϡ�return �äơ�
	code return0(i) int i; { return(i); }
��? ���϶ػߤ��Ƥʤ�����񤱤��㤦��͡��ɤ�����code���Ф�������?

doreturn() �Ǥ� retpending �򥻥åȤ��Ƥ�����������顢control=1
�Τޤޡ��ǡ�code �ν���ˤ���Τǥ��顼�ˤʤ롣checkret �ϡ�
statement �ΰ�����Ƚ�Ǥ���褦�ˤ����ۤ�������Ū��������

���æ�ФϷ빽����������͡�����򥹥��åפ���Ƥ��줷����?
destructor ��Ʊ���ǡ������code�������ƤӤ����Τ����̤�������

bp ��Ʊ���ˤʤ�ޤ� return ������ɤ��櫓����͡�
return ��Ʊ���ǡ�����Ū�˴Ķ�������Ϥ��褦�ˤ��뤫��
type �� void * ���ɤ�?

return �������stack�ξ�¤�ۤ��Ƥ��뤫�ɤ�����ʬ�ǥ����å�����
ɬ�פ�����͡�ï��return���뤫��code������������ɤ��櫓�����ɡ�

	code return0(i) int i; { return(i); }

������ơ������ǡ�frame pointer ����褢�뤤���Ϥ���������
��Ӥ��ƽ�������?
	code return0(i,env) int i; env *env; { 
		if (env==self) return(i); 
	}
����? ����Ϥ���������͡�
	code return0(i,env) int i; env *env; { 
		if (env!=self) {
		    env->return();
		    return(i); 
		}
	}
�⡢�ʤ��Ѥ���ʤ����ƤӽФ��ȵս�˵��ꤿ���櫓����...
�ºݡ��ս�ˤϵ��äƤ���櫓����͡�

return ����Ǥ���������Ӥ���Ȥ������⤢�뤱�ɡ�

����ϡ�destructor ���Ϥ��������͡��������self ���ɤ��櫓������
���Τ�����ϡ����쳰������ǡ����������Ū�ˤ��������顢���θ����
��äƤ���櫓�ʤΤ����顢����������ǽ�������ΤϤ���������

	code return0(i) int i; { return(i); }

������ȡ�return �η������ʤ��ȸ������꤬������ʡ���ñ�ˤ�
�����å��Ǥ��ʤ���
	int
	main() {
	    code a() {
	    }
	    code b() {
		return(i);
	    }
	}
�ˤ���С�check �ϤǤ���褦�ˤʤ롣�Ǥ⡢������ȡ�
	int
	main() {
	    a: {
	    }
	    b: {
		return(i);
	    }
	}
�Ⱥ����ʤ���module ������쳰�Ǥ��Ȥ����Τ���ݤʤΤ����顢����Ǥ�
�ޤ���������Ϲ�饢����֥�ʤΤ����顣

����������return �ȡ����æ�л���abort�Ȥϡ��������㤦�������顢
�̤�code ��ƤӽФ��ʤ��Ȥ��ᡣ���뤤�ϡ��ͤǶ��̤��뤫������ϡ�
logic programming ��fail/success �Ȼ��Ƥ��롣
	main() { } abort { ... }
�Ǥ⤤������?
	main() {  code abort { ... }; code return { ... }}
����?

���衢subroutine call���Τ������ʤ�ξ�ά���ʤ櫓�����顢�����
�������ʤ������Τޤޤ��̾��subroutine call�򥷥ߥ�졼�ȤǤ���Τ�?
	code (struct arg {...},void *sp) {
	    struct env;
	    push(sp,arg);
	    push(env,arg);
	}
�Ǥ��뤱�ɡ�����äȽŤ�����Ϥꡢframe pointer ��ľ�����ʤ���
���ᡣ

goto ʸ�Τۤ��ˡ�env ����������Τ��ä��ۤ��������Τ��⡣
	goto (*ret)(),environment;
���ʡ�type ��? (void *)?
	goto ret(),environment;
�ˤϤʤ�ʤ���? ��������С���ʬ��thread������Ǥ��롣environment
����������ɾ�����ʤ����ɤ���? �ޤ����ͤ���

����ϼ������ưפ���... goto �Ȥ��������񤯤Τ������ˤ����Τ�?
env ���Ф���operation�����ä����������ʤ���push �Ȥ�?

	code return0(i) int i; { return(i); }

��ǧ���С�return ���ѿ��Ϥ���ʤ��ʤ롣

�Ǥ⡢�¤ϡ�return �ϡ�caller �ΰ����ο��Ȱ��פ��Ƥʤ��Ȥ����ʤ�
�櫓�����顢 code return0(i) int i; { return(i); } �Ϥ��ᡣenv
�Ȱ��פ��Ƥʤ��Ȥ����ʤ����Ȥ������Ȥ�ʬΥ����Ȥޤ����󤸤�ʤ�?
����? ����ʤϤ��ʤ��ʡ�

Sun Jan  9 01:15:56 JST 2000

��ϤꡢʬΥ���ƤϤޤ�������Ȥ�ȡ�
	goto func(arg);
������
	goto func(arg) with current.env
�ߤ����ʤ�Τ����Ĥޤꡢ����ϡ�DinnerBell �Ρ�
	self message: arg
��Ʊ����self->func(arg); �Ǥ��ɤ�������function call�ȶ��̤��դ��ʤ��Τ�
�ɤ��ʤ���

��������ȡ�type code ��size int �Ǥʤ��ʤ롣
	code *p = func;
�ǤϤ����ʤ��ơ�
	code p = {func,env};
�Ǥʤ��Ȥ����ʤ����ºݡ�
	goto func(arg)
�Ǥϡ�current environment �� pushl %ebp ��stack = current env
���Ѥ�Ǥ���櫓�����顣

������ˤ��衢
	struct p = q;
�ϼ�������ɬ�פ����롣local�ʡ�
	code p = {func,env};
��ư���Ϥ�����...

	code (*p)();
	goto (*p)(arg);

�Ϥ����龯����������������ϡ�goto ��env ����äƤ���ȹͤ���٤���

���Τ褦�ˤ���ȡ���ˡ�
	func,env
���Ȥ�code�Ȥߤʤ����Ȥˤʤ롣����ϡ�object �ȸƤ֤٤�����
��������¸��object�Ȥ��̤���ʡ�actor �������ɤ�?

�����󡢤����join�������С�������DinnerBell���ʡ����������Ϥʤ����ɡ�

Sun Jan  9 01:40:05 JST 2000

local �ѿ��ν������allocation �θ���٤餻��ɬ�פ����롣
nptr ���������Ϥ������? nptr �˽�����ե饰��­����?

ʸ����ǽи�����local�ѿ��ν������������ư���Ƥ����?

��¤�Τ�copy�ϡ�lcheck �������٤��Ǥʤ���

Sun Jan  9 08:49:43 JST 2000

�����󡢤ʤ󤫽�����¿���ʤ������ȡ��ؿ��ƤӽФ���goto ʸ��
��¤�Τؤ��б�����

	goto (*code)();

����self env ��Ȥ��Τ���code ������ͤ�Ȥ��Τ�����̤���
ɬ�פ����롣�⤷*��Ȥ�ʤ��Ȥ����label(FNAME)�Ȥζ��̤�
�Ĥ��ʤ����������Ǥ⡢�Ķ�������⤯���Ȥˤ������顢label
�ؤ�jump���褦�Ȼפ��ФǤ���͡�

���������Ϥʤ��Ƥ⡢���ι����ʤ��statementñ�̤��������򸡽Ф���Τ�
�ưפ�������

���ФǤ��뤱�ɡ����ν������̤���1�����㽪��ʤ����ʤ���
��ư�������������ΤǤ��礦?

Mon Jan 10 09:00:12 JST 2000

�����˹�¤�Τ�����ˤϡ�ɬ��ANSI-C�ˤ���ɬ�פ����롣�񤷤���
�ʤ���...

goto ʸ�ˤ� label, code, continuation ��3�Ĥ���롣
	continuation = code + env
			| label +env
�ʤΤ�����code/label �Ǥϡ�env �����Ƥ��ۤʤ롣�Ǥ�������򤤤���
���β��ͤϤ���Τ�?

��������code , env ��ʬΥ����Ȥ��ޤ�˴��������롣�ɤ���goto
�������ʤ�����餤����? ����������ñ����ñ�ʤ顢���ä�����ˡ��
�Ȥ�٤�����ʤ�? ������

return �δؿ���¸���Ϥʤ����������ɤ���
��Ĥˤ���Τϡ�pop �����꤬����Τ��ɤ��ʤ���...

��������ret ��env����ꤷ�����褦�ˤ������顢leave ����ɬ�פ�
�ʤ��ʤä��������ơ�push %ebp ������������ʬ�ϡ�lea -disp(%ebp),%sp
�Ǿõ��Ƥ��롣�Ȥ������Ȥϡ�jump ��function��¸��ʬ�Ϥ���ʤ�
�Ȥ������Ȥ��͡�

�Ǥ⡢�����ʤ���read only°����hardware support�Ǥ���Фʤ���

sched_yeilds() ������񤱤뤫��? lock ��?

������Ǥ������ɡ���äѤ������

Wed Jan 12 16:12:27 JST 2000

���ϡ�ANSI prototype �Ϥ��ɤ���
	bexpr()
�ǡ��ؿ��Ǥΰ����ν���ȡ����Τ��Ȥ�����ν�����Ѥ�뤳�Ȥ����롣
��������ȡ�������������ͥ�褵��Ƥ��ޤ�������ϡ����ޤ롣

��������code_arg_offset �Τ褦����ˡ���ȡ�ANSI style �Ǥϡ�
���äƤ��ޤ���

Thu Jan 13 04:46:12 JST 2000

#       goto name(a,b,d,e,f);
        code name { int g; ...

        %esp  new %esp = old %esp - 20
        %ebp-20   = g code's local variable
        %ebp-12   = f <- new_disp
        %ebp-8    = d
        %ebp-4    = d
        %ebp-0    = c
        %edi      = b
        %esi      = a
        %ebp = old %esp   0      disp=0 new env
         local1 <----16 old local variable       ( to be erased )
        %edx        -12   <- disp_offset
        %ecx         -8
        %ebx         -4
        %ebp = %esp   0   <- old env
        %eip          4   <- arg_offset


Thu Jan 13 13:38:24 JST 2000

���������Ǥ������ɡ�test/tmp7.c ��printf ��type mismatch ��
�ʤ�ʤ������?  ASNI �������Ѥ������ʤ���

������ȡ��ץ����������ؤ��ΤȤ��ˤϡ��빽���̤Υǡ�����
���ԡ����뤳�Ȥˤʤ롣����Ǥ⤤���������...

���줴�ȡ��ɤä��ˤȤä��֤���continuation�ؤλ��Ȥߤ����ʤ��
���Ǥ��ʤ����ʡ�

���ԡ����Ǥ���С�environment/return ���Ȥ�ư���櫓�����顢
����ؤλ��Ȥ����ؤ������äƤ��ɤ���͡�

Fri Jan 14 12:03:35 JST 2000

Libretto ��keyboard�����줿... control key �������ʤ�...

printf �λ��Ȥ�����ϲ�褷�ޤ�����list2 ��local��heap
�˳�����ƤƤ���Τ������ʤ��ä��͡�

return �ν����ϡ�goto ʸ�ǽ��������ꡢenvironment ��
returnto ���������ɤ��Ϥʤ���?

environment �ϼ¤�������Ǥ���ʤ�ν�����ɬ�ס�
new-environment() �ߤ�����library ������С�thread �ˤǤ��롣

join ��?

funcall ���Ѱդ�����ɤ��͡�

Mon Jan 17 15:23:34 JST 2000

    struct aa f1() {
	return bb;
    }

�ߤ����ʤΤ�? �ؿ��η��������η��򸫤ơ�crn ��pointer���Ϥ��ơ�
���Ȥ�copy���Ƥ��� stack ����ࡣ

    # 	bb=f1(aaa);
	    movl $bb,%eax
	    pushl %eax
	    movl $aaa,%eax
	    pushl %eax
	    call	main2
	    popl %edx
	    copy %eax,%edx,$400
	    addl $400,%esp
    #     return a1;

�����Ǥ⡢������ȡ�local�ѿ����֤����Ȥ��˺���͡�leave; ret;
���ƤϤ����ʤ���...

������äѤꡢ�����������ϥ��ԡ����main2�˰����Ϥ��Ƥ���ߤ����͡�
    void f1(struct aa *ret) {
	*ret = bb ;
	return;
    }
��Ʊ����������ϴ�ñ��
	f1().a[55]
�ߤ����ʾ��ϡ��ɽ��ѿ��˶���Ū�˼�äƤ��ޤ��ߤ����͡�����Ϥ�����...
���������μ������Ȥ���äȸ���������
	leal $-sizeof(struct),%esp
	pushl %esp
�ʤ�����ɡ��ؿ��ƤӽФ�������ǤϤǤ��ʤ�����....

    # main(ac,av)
    # int ac;
	    .align 2
    .globl main
    main:
	    .type	main,@function
	    pushl %ebp
	    movl %esp,%ebp
	    pushl %ebx
	    pushl %ecx
	    pushl %edx
    # char *av[];
    # {
    #     register int i;
    #     register char *p;
    #     int j = 3;
    #     struct { int b; void (*c)(struct aa); } q = {3,main1},r;
    # 
    #     j = 3;
	    subl $20,%esp

����subl��夫����ꤷ�Ƥ���Ok��

�Ǥ⡢������� jump �λ��ˤ���ʤ�? ����뤫? �����͡�������
�¹Ի��˥����å����Ƥ��Τ��Ѥ�����

�ޤ�������ۤ�ɬ�פʵ�ǽ�ǤϤʤ�������ɡ�

�����continuation���Ϥ��Ƥ��ȸ�����ˡ���Ȥ��ʤ����ȤϤʤ������...

�ؿ��ƤӽФ��κǽ�ˤ�äƤ��Ф�����������ǤǤ��뤫��?


Sun Feb 20 23:59:16 JST 2000

MIPS ��call frame

	$sp = $fp 
			local variables
        		saved register (including $31 = return address)

mask  �ϻ��Ѥ����쥸������bit pattern
 -4 �ϲ�?

  18                            .mask   0xc0000000,-4
  19                            .fmask  0x00000000,0
  20 0000 D0FFBD27              subu    $sp,$sp,48
  21 0004 2C00BFAF              sw      $31,44($sp)
  22 0008 2800BEAF              sw      $fp,40($sp)
  23 000c 0000000C              move    $fp,$sp
  24 0010 21F0A003              jal     __main
  25 0014 03000224              li      $2,0x00000003           # 3
  26 0018 000082AF              sw      $2,a
  27 001c 04000224              li      $2,0x00000004           # 4
  28 0020 00C082AF              sw      $2,b
  29 0024 05000224              li      $2,0x00000005           # 5
  30 0028 000082A3              sb      $2,c
  31 002c 06000224              li      $2,0x00000006           # 6
  32 0030 08C082A3              sb      $2,d
  33                    $L1:
  34 0034 21E8C003              move    $sp,$fp                 # sp not trusted
 here
  35 0038 2C00BF8F              lw      $31,44($sp)
  36 003c 2800BE8F              lw      $fp,40($sp)
  37 0040 0800E003              addu    $sp,$sp,48
  38 0044 3000BD27              j       $31
  39                            .end    main

�����Ʊ���褦�ˤ���ʤ�С�regiter�λ��ѿ���ǽ��Ĵ�٤�ɬ�פ�
����Τ����ɡ�one path compiler �Ǥ��� micro-C �Ǥϡ������
�Ǥ��ʤ����������äơ�enter �ϸ���Ǥ��������ɤ���

Mon Jan 20 18:25:27 JST 2003

3ǯ�֤���äƤʤ��Τ��衣����äƤ��?

goto ʸ�ΥХ���Ȥ�ʤ��Ȥ����ʤ���

�ޤ����ؿ������ι�¤�Τ�Ÿ��������ϡ��ɤ��äƤ��Ȥʤ��Ϥ���

   goto (*code)(i+1,j,...)

�ޤ���������ʤ��Ƥ����ѿ���Ŧ�Ф��롣

   foreach arg 
      compare

ñ��黻 ( op+const , pointer , const assign ) �ʤɤϡ������Ǹ��Ф��롣
��Ⱦ�ϡ����Τ褦�ˤʤ�Ϥ���
�쥸�����˾褻��ʬ�����뤫��... ����ˤϿ���ʤ��Ȥ���...

ʣ���ʤ�Τϡ�����äƷ׻����Ƥ�����(get_register ����)
�����å��夫�쥸������˺�롣

�Ĥ�����������Ȥʤ롣�Ƶ�Ū�˷׻����롣

�����ȡ��礭�ʽ�ˤ�����ä�? �����ʽ�ˤ�����ä�?
    code f( int a, int b, int c ) {
        goto g(b,c,a);
    }
�ߤ����ʤ�Ĥ���͡�

    ��ư�����Τ��ĸ��Ф��롣
    ���Τ���˰�ư��ɬ�פʤ�Τ��ư���Ƥ���(�Ƶ�)
    ��������

����ʤ�Ǥ����Τ�? �롼�פ��ʤ�? �����͡��롼�פ�����
get_register ���롣

��������ȡ�

    g(b,c,a) ��b�����ܤ��롣
    b���������륳���ɤ�Ф��ȡ�a ������롣
    a ��ɬ�פ��ɤ�����Ĵ�٤롣����ϡ������Υꥹ�Ȥ򸫤�Ф狼�롣
    �������ˡ�a ���ư���롣a �ΰ�ư��򸫤ơ�
       �����Ƥ���С���ư����Ok����������c 
    �ʤΤǡ� c �򸫤롣�� b �ˤʤ�Τǡ��롼�פ���Τ��狼��Τǡ�
    b �� get_register ���롣
    �ǡ�c ����ư�Ǥ��롣�ǡ�a���ư���ơ��ȤäƤ�����b��������

Tue Jan 21 22:45:09 JST 2003

�Ȥꤢ������jump ��ʣ�������롣��äȴ�ñ�ˤ��뤳�Ȥ�ͤ��롣
parser ¦�Ǥ������ٽ����Ǥ��ʤ�?

     goto f(a+3,b(),c);

�ʤɤ�

     a = a+3;
     b = b();
     goto f(a,b,c);

���٤˴�ά�����롣���λ���f(a,b,c) ��(�Ǥ������)������
�ؿ��ΰ����ꥹ�Ȥ˶��դ��롣�Τ�̵���ʤΤǡ�ñ���ѿ�
�ޤ����

���ޤ�ط��ʤ���������ѿ��Ϥɤ�������櫓�������äƤ���
�ߤ����͡�

���Ȥ���ȡ����Υ����ɤȡ������Ѥ���͡����Τ⡢����ʤ�
�����ʤ��äƤ��Ȥ���

Wed Jan 22 14:33:12 JST 2003

��äѤꡢ����Ƕɽ��ѿ������䤷������͡�

Fri Jan 31 20:30:36 JST 2003

�ʤ� #ifdef / #if ���ʤ��Ȥ�����ʡ���������?
���ޤ�����

Tue Feb  4 01:04:12 JST 2003

##      while ((*chptr++ = c = getc(filep->fcb)) != '\n') { 
_1120:
        movl $10,%eax
        movl $8,%ecx
        movl filep,%edx
        addl %ecx,%edx
        movl (%edx),%edx
        pushl %edx
        xchg %edx,%eax     .... edx ��$10������ (�ʤ��xchg?)
        call    getc
        addl $4,%esp
        movl %eax,-20(%ebp)  c ������
        movl $chptr,%ecx
        pushl %ecx
        popl %ebx
        movl (%ebx),%ecx      ecx ��chptr�����
        addl $1,(%ebx)
        movb %al,(%ecx)
        subl %edx,%eax         eax-edx ($10)
        je      _1119

���������ͳ�ʤ������...

edx,ecx ���˲�������㤦�ߤ����͡�

Tue Feb  4 12:17:07 JST 2003

�褦��ä�ľ������...

use_pointer �äơ��ʤˤ⤷�ʤ��Ƥ���������? eax,ebx ���򤱤�
�äƤ��Ȥ餷�����ɡ�

inline/�����դ� #define �ߤ����ʤ�? �֤������ϡ�local name stack ���Ѥ󤸤㤦��
Ÿ���� function  �ǹԤ���

getch ���פ���ɬ�פϤ��뤬���֤����������å���ɬ�ס�


Wed Feb  5 01:16:00 JST 2003

����������줿 struct field ������ѿ��ȽŤʤäƤ��������롣
����㤽�������ɡ��ɤ������? (ľ�������������������ɤʤ�...)
struct ��� field ̾��offset/type ���Ȥ���ƤФ��ɤ������͡�

�ʤ�����ɡ�����̵���ι�¤�Τ⤢�뤫�顢��̾�������դ���ɬ��
�⤢�롣�Ȥ����Τϡ���̾�Τʤ���¤�Τ⤢�뤫�顣����̾�ˤϡ�
������ꥹ�Ȥ��Ĥ��Ƥ��롣�ʤ󤫤˻Ȥ�ɬ�פ����ä���Ǥ��礦
�͡��������ɤ���̵���ˤ�äƤ�����ѿ�̾������Τ�ľ����
���񤷤���

����äȡ���������ɡ��ַ�̾.�ե������̾�פ���Ͽ���Ƥ��ޤ��ΤϤɤ�?
��̾����ǽФ����Ȥ��������ޤ�����...

def ����Ͽ����Ȥ��ˡ�nptr��disp�����������ˡ�struct field list
(����ѿ�) ������ơ�type �����ˡ�field list (list3(nptr,offset,
type)) ���������ɤ���

���Ȥϡ�strop ������type��list�򸫤�褦�ˤ�����ɤ��櫓����

����ʤ顢��ñ��ľ����Ϥ���LUSTR/GUSTR�ʤɤζ��̤�ʤ��ʤ뤷��

Wed Feb  5 02:10:14 JST 2003

��ư�������ͤ���������ANSI C�ˤ���Τ����ѡ��Ǥ⡢
��ư���������餤�ʤ��ȡ�

code generation part �򡢤����ʬ�䤷�ơ�
ʣ���Υ������б��ˤ��䤹���褦�ˤ��롣
�����餯������ۤɶ�ͭ������ʬ�Ϥʤ����ɤ͡�

Sample C code �򥳥�ѥ��뤷�ơ����η�̤���(Ⱦʬ��ư��)
Micro CbC code generation part ������������ˡ���Ѱդ��롣



Thu Feb  6 11:47:03 JST 2003

Code Segement ��ñ�̤Ȥ��ƻȤ��Ȥ��ˡ�����ѿ��Ϥɤ�����
�褦��ʬ�����? static �ʤ󤫤ϰ�̣�ʤ���͡�

������󡢼����˥��롼��ʬ�������櫓�����ɡ�

���ȥǡ����ե�������͡��ǡ����ե����˴ؤ��Ƥϡ�
����ޤ��äƤʤ��ʤ�

Fri Feb  7 14:36:15 JST 2003

inline �Ǥϡ�ɬ�餺���ɽ��ѿ������ä����롣�ޤ���inline
�����̤δؿ��Ȥ���Ÿ�����Ƥ���ɬ�פ⤢��餷����(����?)

#define �ͤ���

   #define c(a,b)  g(a+1,b+1)
   #define g(a,b)  printf("%d %d\n",a+1,b+1);

   main() {
       int a,b;
       a =1; b = 3;
       c(a,b);
   }

local #define ����������͡�g ����� a ���Ф��褿���ˤϡ�
c ��a ���֤������ϵ����äƤϤ����ʤ����Ȥ������Ȥϡ�c
���֤�������g ���Ϥޤ����˽��äƤ���ɬ�פ����롣dynamic
scope �ʤ�����顢assoc �ξ�褻���ɤ��Ϥ���
macro ��level��������ơ������٥�Ǥϡ����������Ÿ��
��Ԥ�ʤ��Ȥ�����ˡ���ɤ����ʡ�

   c(a,b) =>  a=>"a+1", b=>"b+1"
   g(a,b) =>  (a=>"a+1+1",a=>"a+1"), (b=>"b+1+1",a=>"a+1")

�ߤ����ʴ���?

��äѤ�ؿ����Ϥǥޥ����������餻��Τ�̵������? ���ɤߤ�����㤦����

Sat Feb  8 00:53:52 JST 2003

macro ������ޤǽ񤭤ޤ������֤�������ޥ������ƤӽФ��줿
������ cheap ���֤��ȡ�������ä��륿���ߥ󥰤��ʤ���
��������malloc���Ƥ��ɤ���..

chptrsave ��list�ˤ���ɬ�פ����롣list ���ɤ���

��äѤ�macro level�򸫤ơ���ʬ�Ȱ��פ���assoc value�ޤ�
�귫�ä��ִ������Ǥ��礦����������С��֤�������ɬ�פ�̵����
�Ȥ������Ȥϡ�local_define ��mflags���Ǽ����ɬ�פ����롣

   c(a,b) =>  a=>"a", b=>"b"
        a=>"a" .. mflag == 1
   g(a,b) =>  (a=>"a+1+1",a=>"a+1"), (b=>"b+1+1",a=>"a+1")
        a=>"a+1" .. mflag == 2
        
macro �Τ�Ȥ�nptr ���ĤäƤʤ��ȡ����ꥸ�ʥ���֤��ʤ�����
�ꥸ�ʥ�ϡ�sc �ʤɤ��˲�����Ƥ��ޤ����äƤ��Ȥϡ�local macro
�ϡ�local table ������ƤϤ����ʤ��äƤ��Ȥ���͡��äƤ��Ȥϡ�
macro table �ϡ���ȤΤȤ��̤��Ѱդ���ɬ�פ����롣

#define c(a,b)  g(a+1,b+1)
#define g(a,b)  printf("%d %d\n",a+2,b+2);

main() {
   int a,b;                  a ... local
   a =1; b = 3;
#ifndef a
   c(a,                 a = "a".. macro mflag==1
                        g(a,
                               a="a+1"  mflag==2
                                  ^  a = "a" mflag==1
                        While replacing a in g's body, a should not
                           be replaced to  (original) "a", should be c's a.
      b);                
   /* 3,5 expected */
#endif
}

�����ࡣ��䤳������

    main() 
	c(a,b)    mflag++
                         a=>"a" mflag ==1
           g(a,b) mflag++;
                         a=>"a+1" mflag ==2
                             ^ is replaced by c's "a" not g's a;
���ä��� mflag level n ��Ÿ�������顢����� mflag level n-1 �Ȥʤ롣

Sat Feb  8 18:13:43 JST 2003

����������mflag �ޤǤϥǥХå�������....  mflag ���ᤷ�Ƥʤ��󤸤�ʤ���?

     ---c(a,b)-----------------------  mflag ==1
          a=>hoge, b=>hoga (mflag==1)
        ----g(ac,bc)-----------------  mflag ==2
              ac=>goge, bc=>goga(mflag==2)
            ----printf(a,b)----------  mflag ==3
                a=>poge, b=>poga(mflag==3)

g ���ƤӽФ����ȡ�ac,bc �� mflag==1 �ǤΤ��ִ�����롣

����ƥ����Ȥ��֤�������ȡ�������֤��������ޥ�����mflag level
(�Ĥޤ��ľ��ʤ���٥�)�ˤʤ롣
�֤��������ä��顢����level���᤹��

mflag==2��level �Ǥϡ�mflag==2��local macro��Ÿ���������ʤ���

�֤�������ȡ�mflag level 1 �ˤʤ�Τǡ������� mflag==1 ��local
macro ��Ÿ�����롣mflag==0 �Ͼ��Ÿ����Ԥ���

Sun Feb  9 11:35:23 JST 2003

�����󡢤ʤ�type����list ��CHAR�ʤɤ��������äƤ��뤸���
    int save = chptrsave;
�ǡ�chptrsave ����$chptrsave �ˤʤäƤ��ޤ���

Sun Feb  9 22:33:36 JST 2003


#define car(e) (heap[(int)(e)])
#define cadr(e) (heap[((int)(e))+1])
    car(cadr(e))

������
    car ->  
       #define e cadr(e) (mleve=1)
    cadr ->  
       #define e e (mleve=2)

�थ�����졢���ޤ������ʤ��󤸤�󡣤��ޤä��ʤ���

#define c(a,b)  g(a+1,b+1)
#define g(a,b)  printf("%d %d\n",a+1,b+1);
   c(a, b);

���ä�����ᤸ��󡣤ա��ࡣlisp interpreter �Τ褦��
���Ф����Ϥ��ʤ�����ɡ�

Mon Feb 10 08:10:25 JST 2003

��ɡ�list base ��interpreter ��������ޤ�����������ʤ�����
������ˡ�Ǥ⡢��ĥ��ФǤ����Ǥ��礦���ɤ͡�

Tue Feb 11 13:50:03 JST 2003

struct copy ������... �ؿ���struct���֤��Ȥ��ˡ�����������ä�
�Ѥ�Ǥ����ΤǤϡ��������ͤ����ԡ�����Ƥ��ޤ��������Ȥǡ�
�����å��򤿤�����֤��Ȥ��ˤ��ޤ�����

function call �λ��ˡ������η��Υ����å��򤷤Ƥʤ�

type �� -1 ��heap�ΰ��������ߤ��Ƥ����Ĥ�����..
��äѤޤ����󤸤�ʤ���?

temproal struct �Ϻ����ѤǤ��������ɡ�disp���ѹ����Ǥ��ʤ��Τ�
��������뤷���ʤ����礭���Ȥ��������������ʤ�Ƥ���������
���Ϥ��뤱�ɡ�(��������ȡ����ä��褿�ͤؤΥݥ��󥿤�Ȥ��ʤ�
�ʤ뤬.... �̤ˤ�����͡�����ͤ��켫�Ȥ�ľ�� return ����
����������礦�֤ʤϤ�)

��ɡ��ƽ�¦�ǡ��ΰ����ݤ��ư����Ϥ����Ȥˤ��ޤ�����������ˡ���ȡ�
�����ΤȤ������٥��ԡ�����ɬ�פ�ʤ���

register  ����Ѥ��Ƥ��뤫��������ʤ��ơ��ºݤ�creg/dreg��
�ͤ����뤫�ɤ����򵭲�����ɬ�פ����롣

Wed Feb 12 11:09:22 JST 2003

��������ɤ�... ��äѤꥢ�ɥۥå��˼¸�����Τ��񤷤��󤸤�ʤ���?

�ޤ��ͤ���register �ξ��γ��ݤȡ���̿���̤����顢�����
����������ɡ�regs flag �����Ǥʤ�Ȥ��ʤ�ʤ��Τ��ʡ�
���������ѹ��ϤϤޤ뤬��������

Thu Feb 13 18:37:36 JST 2003

���ơ��������� jump  �ˤȤ꤫����ޤ�����

��¤�Τΰ����Ϥ��Υ��������󥹤˻Ȥ��ɽ��ѿ��ΰ��֤�gcc�Ȱ㤦...

�������� register �Ϲ�¤�Τˤ��٤����͡�
    struct register {
        int used;
        int valued;
        char *name;
        char *wname;
        char *bname;
        int type; /* register variable or not */
        int number;
    }
virtual/real �ϡ��ɤ����롣

Sat Feb 15 14:00:03 JST 2003

fdecl_struct ��ʸŪ�˰������и�����Ȥ��˹Ԥ��ȡ�int *f(int
a) �ʤɤǡ�* ��ɾ�����������ˡ�int a��ɾ�����줷�ޤ���*obj 
��obj ��ɾ��������ʤ���f�Υ����פ����ꤷ�ʤ���int*f()[] ��
�����ʾ�礬���뤫�顣(?) �ʤΤǡ�gcc �ȡ��������뤿��ˤϡ�
arg ����Ƭ�� fdecl_struct ��Ԥ���ˡ�ǤϤ���ǡ�fdecl ��Ǥ�
�Ȥ��齤�����������ɤ���

fix ���褦�ˤ�����ꥹ�Ȥʤ�ơ�¸�ߤ��ʤ������!

varargs ���������ΤϤ��ɤ���������...

rvalue(expr(),type) �Ǥϡ�expr() ��type��rvalue�˰����Ϥ���
�����Ǥ⡢type ������ѿ��ˤ���ȡ�rvalue��ۤʤ륿���פǸ�
�ӽФ��Ȥ���type���ѹ�����ɬ�פ����롣����rvalue��type �ΰ�
���ϡ����ʤ�Ϥޤä����Ȥ�����Τǡ�rvalue(int e,int type)��
�����ɤ����ȤϳΤ��ʤ����... 

struct_push ��register�ΰ�����ʣ���������ʤ󤫡���ä�
��ñ�ˤʤ�ʤ���?

Sun Feb 16 07:58:23 JST 2003

�������ʤ����ɤ�����ȸ��äơ�������
�Υꥹ�Ȥ�������Ƥϡ���񤭤��ɤ��ʤ���

Sun Feb 16 22:55:58 JST 2003

vdisp �äƤʤ���ä����?

Mon Feb 17 12:35:39 JST 2003

���������Ͻ��褿�ߤ����������Ͼ�������Τ���ˤ��٤��ʤΤ�?
�ޤ����Ǥ���㤤��������ɡ������򤱤��Τ��礭���ΤϤ���
����͡�

Tue Feb 18 11:56:10 JST 2003

overraped �Ѥ� emit_copy
float/double
long long

Tue Feb 18 19:34:31 JST 2003

code argument ������ȿž������ȡ�list2(LVAR,offset)
��offset�����ɥ쥹�������Ȱ��פ��Ƥ���Ȥ�������
����롣����ǡ���¤�Τγ�Ǽ���������Ƥ��ޤ�...

�Ȥ������Ȥ�... def(n) ��code�λ���argument�ϡ��ɽ��ѿ���Ʊ��
�����ǥޥ��ʥ����ǽ������������ɤ���

�Ǥ����ߤ������Ǥ⤵��
   
int main( int ac, char *av[])
{
    int n;
    goto arg1(0,1,2,3,4,return,environment);
}

�äơ����ä� return ʸ���ʤ��ȡ�ʸ���
�������͡����ࡣ

post processing �������overrap���Ƥʤ��Ȥ����ݾڤ��ʤ���

Wed Feb 19 15:38:55 JST 2003

��ʬ���ȤȤ�overrrap�򸫤Ƥʤ��Τǡ�
    struct a a,int i
    int i,struct a a
�ߤ����ʻ��˼�ʬ���Ȥ�����Ƥ��ޤ����ʤΤǡ�emit_copy
���������������򸫤Ʋ����ʤ��褦�˽�������ɬ�פ����롣

call bcopy �Ǥ�������󡣤ޤ͡�

Wed Feb 19 20:42:07 JST 2003

�̤���� C2CbC �� CbC2C ��micro C �˼����ࡣ�ƽ�ˡ�
conv->func(); �������ࡣconv �ϡ���¤�Ρ�

    conv:   original
            c2cbc
            cbc2c

�Ȥ��롣�ʤ�ۤɡ�

Thu Feb 20 05:34:58 JST 2003

�थ��code-ia32 �Ƿ빽�Ϥޤä������ȡ�stack �Υ��饤���Ȥ�
�����ߤ�����6809�Ǥ�����ˤʤ�ʤ��ä�������ɤ͡�
leave ��Ĵ������٤���


Thu Feb 20 14:42:46 JST 2003

c2cbc,cbc2c �ʤ�����ɡ����ä��󡢹�ʸ�ڤˤ��Ƥ����Ѵ�����ȡ�
�빽��������󤬤��뤱�ɡ�������? �ä˶ɽ��ѿ���̾���Ȥ���
�ξ���Ȥ���macro �⤽�������ɡ� indent ���餤��¸�Ǥ��ʤ���
�ʤ������������function call��������갷��ɬ�פ������
�ǡ���ʸ�ڤˤ��Ƥ���׻����뤷���ʤ����ʡ�gexpr ���������
������褦�ˤ��뤫����������ȡ���������Τϡ�statement �ȡ�
gexpr �ˤʤ롣�Ǥ⡢��ɡ���ʸ�ڤǷ�������⤯�����ʤ��󤸤�
�ʤ���? ��äѤ��Ѥ��衣���ξ��󤬤ʤ��Τϡ�

�����ǤϤʤ��ơ�exprN() ���Ѵ����Ƥ�����ˡ�⤢�롣��������
���󤬷���ʤ��Τdzڤ���������������ȡ���������Τϡ�
    exprN(),doXXXX()
�Ȥʤ롣����ϡ��̤�¿�������ɡ��ޤ��������������������
���ꥸ�ʥ����¸���䤹����

����ѿ���������ɲä���ȡ������������äƽ��ϤǤ��ʤ�
�ʤ롣{int a;...} ��ǧ�����ɤ��櫓���ɡ��������񤷤��ʤ���
���㡢����? �Ǥ⡢�����ʤ�ʤ������Ϥ򤤤ä���Хåե�
��������? �ɤ���? cheapp �Ǥ���? ����ѿ��Ϥ���ʤ���
����ʤ���?
     a = g(i)+a;
�Ǥ��硣
     goto g_1(i,f_1,save_a); }
     code g_1(i,f_1,save_a) { .... goto f_1(ret_value,save_a); }
     code f_1(ret_value,save_a) { a = ret_value+a; ...}
����󡣤���ʤ�����󡣡�


����ɽ������롼����ɬ�פ��͡�

���ɤ������ʤ���CbC��Prolog version �Ȥ��ۤ����ʤ�����������С�
�Ѵ��ϴ�ñ���Ǥ⡢������Ȥ��ƤǤ��ʤ��ä����ȤǤ⤢��ʡ�


Thu Feb 20 21:13:23 JST 2003

MC6809 �� mc-codegen.c version ��? (����äȵ���������?)
X �� D �ǡ�use_data_register, use_pointer ���Ƥ�롣
tosop �ǡ�X �� D �δ֤�­���������̰������롣
(�ʤ�ۤ�...) MAX_MAX=0�Ǥ��ޤ�ư���Τ�? ��äѤꡢ1��
�����͡��Ǥ���С�2����͡�

�빽����ư���������ñ���⡣

���Ѥν񤭴����ġ��������������

�Ǥ⡢Prolog version �äƤΤ����򤽤���
   code(name,interface(....)) :- 
     p()....,goto(name,interface(....)).
�ߤ����ʴ���? �빽����ñ��interpreter��񤱤뤫���Τ�ʤ���
����ϡ�������͡�thread diagram interpreter �Ȼ��Ƥ��롣

Fri Feb 21 13:34:17 JST 2003

��ʸ���ǤǤν񤭴��������ɡ��ɤ줯�餤��ǽ�Ϥ������?
���ξ�Ǥν񤭴����������ȡ�����ä��㤹���ʤ�? ����ǡ�
cbc2c,c2cbc �ϤǤ���Ȥϻפ���

�ޤ���������.. chk ��̵�뤷�Ƥ���Ȥ������빽�����Ǥ����ɡ�
jmp,enter,leave ...

Sat Feb 22 13:05:04 JST 2003

type �������...

conv �Ϥ���Ⱦ��default conv���ƤФ�롣�ʤΤǡ�c.c
�äƤ������ϡ�default.c����͡�ɬ�פʤȤ���������
��ʬ����������ȸ�����ˡ���ɤ�����������������
�إå����ĤǺѤष���������object �ظ��ʤ�
��ñ�ʤ����...


Sun Feb 23 19:47:41 JST 2003

struct ��type��������������ɡ������������顢���Ȥϰ���
���ʤ������ɤ����դ����񤯤ʤ顢tag̾type̾�ϡ�����ʤ���
����

�Ȥ����type�β��Ϥ���ndecl�ǽ�������? �����Ǥϡ������
�����櫓�����ɡ�

���Υ����פΰ������ȺƵ����ϰ�������λ���ʤ��󤸤�ʤ���?
���ʤ��͡�

Mon Feb 24 02:31:06 JST 2003

strings ��\n�ʤɤ򸵤��᤹ɬ�פ����롣

�ʤ󤫳�̤����ˤʤäƤ�ʡ�

Mon Feb 24 11:02:07 JST 2003

typedef ���줿�����פϡ��������Ȥ������ɤ������ɡ����󤬼�
���Ƥ��ޤäƤ���Τǡ��ɤ����ˤȤäƤ����ʤ��Ȥ�����͡�dsp
? 

�����ࡢ����Ϥʤ��ʤ��񤷤��������������Ƥ⤤���󤸤�ʤ���
�ʡ��٤����ɡ����ʤ��Ȥ�gnptr��������줿��Τϥ��������٤�
�Ǥ��礦��

indirect function type ��ɽ�����ʤ�....

sdecl �Ǥ�conv ��Ԥ��Τǡ�type_print �Ǥ�sdecl���ͳ������
���ɽ����ԤäƤϤ����ʤ���

�ʤ󤫴ؿ��ΰ����η����ͤ���̯���Ѥ���Ǥ�����... ����ʤ�...

�ޤ����ؿ������typedef��struct���Ѥ�äƤ��ޤ���gtypedefed
�����ޤ�ư���Ƥ��ʤ�?

Mon Feb 24 17:24:31 JST 2003

�ޤ��ͤ�����äѤ괰���˹�ʸ�ڤ���ƹ�����������
�����ǤϤ����͡��ä� getsym (����ʤ�)�� conv->x_()
�Ȥ�������ѤϤ��ɤ�������

���Τ���ˤϡ��ɽ��ѿ�̾��tree��ǻ����⤯ɬ�פ����롣
�ޤ�������������ɤ����������ɡ�

�ºݡ����Υ��åȤǽ���뤫�ɤ����ϡ�����äȲ�������
���֤�buffer �˽��Ϥ���äƤΤ򤤤��Ф����餯��
�Ѵ��Ǥ����������

��������ǤθƤӽФ��Ȥ���ͤ���ȡ���äѤ�
��ʸ�������������ʤ��Ȥ���������͡�
(�äƤ��Ȥϡ��ޤ������ʤ�κ�Ȥ�����äƤ���.... �थ...)
tmp2.c �ϡ��̤�ʤ���...

Fri Feb 28 20:32:46 JST 2003

�ǡ�c2cbc �ϡ������ float ��������ˤ��櫓?

Sat Mar  1 22:05:43 JST 2003

creg_destroy �ϡ����󤼤���ᡣ����ϴ���Ū�ʥ����ǥ������ᡣ

long long ��struct�Ǥ����󤸤�ʤ�? ����? �� struct �黻���̤�
������Ƥ�롣����ϡ������ˤ��뤫��

float,long long�ʤ�����ɡ�
    FRGVAR DRGVAR LRGVAR
�ʤɤ��롣����ˡ�
    FMUL DMUL LMUL
�ʤɤ⤤�롣�����Ѵ��� binop �Dz�᤹�롣�Ѵ���黻�ˤʤ롣
    D2F, D2I, F2D, F2I, I2D, I2F, U2D, U2F
���餤�Ǥ���?

emit_push�ϡ�����ɬ�פȤ��뤱��? �������ͤ���emit_fpush, emit_dpush
����?

creg ��float register(or stack) ���ͤ������Ф����󤸤�ʤ���?
����򸫤ơ�emit_push�η�����롣creg �ϡ����ä�����������
��Τ����Ƥ���Τǡ�������ʤ�������������ʤ����ʤ���
�����͡�FMUL�Ȥ�������ʤ顢�����Ƚ�ǤǤ�������

��ʸ�ڤˤϷ���ޤ�ʤ��äƤΤ����ء�����������? ��������С�
    RGVAR CRGVAR FRGVAR DRGVAR LRGVAR
�ǤϤʤ���
    RGVAR
�Ǥ��ष�����������ѷ���ڤ����͡����ϡ�
   CHAR,UNSIGNED, UNSIGNED CHAR, INT, FLOAT, DOUBLE, LONGLONG
���餤�Ǥ�����

emit_data

�Ȥ���ȡ��񤭴������빽���뤱�ɡ�

Sun Mar  2 12:58:38 JST 2003

���Ȥ�constant���͡�FCONT,DCONST���ʡ�binop�Ǥ�
�Ѵ��Ȥ���ɬ�פʤ櫓�����ɡ�

���������С�shot ��load/store��ʤ��͡�SRGVAR,SASS�Ȥ��Ǥ���? SASS
�ϡ����Ǥˤ���ʤ���

Sun Mar  2 22:01:58 JST 2003

����?
       conv->_sm();
       (*conv->_sm)();
�ξ��ϡ�
       *conv->_sm ���ͤ�call����
������ɡ�
       goto exit1();
       goto (*exit1)();
�ξ��ϡ�
       exit1
���ͤ�jump���������? ����? �ʤ󤫴��㤤���Ƥ�? �ʤ��exit1()
����indirect���Фơ�(*exit1)���ȽФʤ��������?

��������ϡ�
    void (*_sm)();
�Ǥ��äơ�
    void _sm();
�ϤǤ��ʤ�? �ʤ��?

�������ޤ����������������ɤ�������

��äѤꡢarglist �κƵ�Ū�����������Ȥ��Ƥʤ��Ȥ��ᡣ

�����ࡢ enum �ʤ�ƤΤ⤢��Τ͡��䤵�������ɡ�����Τ�?

code (code *) * �ߤ����ʤΤ�����Τǡ�conv �ϼ�ľ����ɬ�ס�

Mon Mar  3 12:38:08 JST 2003

float/duble �Ͻ�Ĵ�˿ʤ�Ǥ뤱�ɡ�3���Ϥ�����Ǥ��礦��

binop ��񤤤��㤦��mc-parse.c �ϡ��ۤȤ�ɽ���?!
�����ȴؿ��ƤӽФ����ĤäƤ��뤫������ single �⤢��͡�

emit_push base �ǽ񤯤�����ɡ�¾��CPU�ǤϤ��������꤬
�㤦��������ʡ�

dreg/creg ��floating version��ɬ�פǤ���( �Ǥ�? )

Tue Mar  4 14:56:28 JST 2003

double ��current register ��387�Υ����å���Ȥ���(?)
�ؿ��ƤӽФ�����387�Υ����å�����¸�����Ȥ���
�ݾڤ�̵���Τǡ�emit_dpush�Ǥϡ�%esp ����¸���롣

�Ǥ⡢��������ȡ������θ�ʤɤ�387�Υ����å���
��˻Ĥ뤳�Ȥˤʤ롣�����Ĥ򥯥ꥢ���륳���ɤ�
�ɤ��ˤ����? free_register �Ǥ⤤���������....
�������ࡢ�Ĥ������餤��ġ�ld ����ʤ��ơ�
stack top ���������륪�ڥ졼�����Ϥʤ���?

(�������Ǥ⡢�ʤ󤫡�float�ϡ��⤦�������ä��㤦��... �ʤ󤫡�
���Ӥ�...)

Tue Mar  4 23:58:07 JST 2003

fmulp �Ȥ��Ǥϡ�fpp ��stack�ΤĤ��ĤޤϤ�����fstl �Ȥ����ȡ�
���ʤ���fstpl ����Ф�������������������Ϣ³�����Ǥޤ����ʤ롣
�ͤ�Ȥ����ɤ��������������Τ뤳�Ȥ��Ǥ�����ɤ��������
(use flag ��Ƚ�Ǥ��뤳�Ȥˤ���)

��ɡ�freg �ϡ��Ȥ�ʤ��ä��͡�0�������äƤ���Τ�ľ���ʤ��Ȥޤ�������
freg�򸫤ơ�stack ��ľ���äƤΤϡ���äѤꡢ�ޤ������...

�Ǥ⡢��ư�������쥸���������CPU�ξ��Ϥ���󤸤�ʤ���?

Wed Mar  5 11:25:11 JST 2003

printf �Ǥ� ������double�����줹��ɬ�פ����롣goto() �Ǥϡ�
����򤹤�ΤϤޤ������ɽ��ѿ���Ʊ�������顣�äƤ��Ȥϡ�

�ؿ��ΰ�����double�ˤ��ʤ��Ȥ���ʤΤ͡��ץ��ȥ����פ�
������ϡ����θ¤�Ǥʤ���(������...)

   (�����������Ĥ������Ѥ��빽�Ф��...)

���ȡ�fpp �Υ����å�����äƤ���Τǡ�overflow��������
����ʤ���? �ۤȤ�ɤξ��Ǥ������礦�֤�����������ä�
����error���餤�Ф���? �Ǥ�¹Ի��ˤ����狼��ʤ���...

I2D �Ǥ���singned/unsigned �ζ��̤�����͡�

��äѤ� FCONST ����󤸤�ʤ���?

Wed Mar  5 19:51:59 JST 2003

�����Ѱʳ��Ͻ��ä�����.... ���ȡ�name space ���빽�ŤʤäƤ���
�����͡�
          struct tag, struct field
���ŤʤäƤ���ΤϷ빽���äȤ�������gsearc/lsearch �Τ������
��ľ���ʤ��Ȥ��ᤫ�⡣

���ȡ�list ��ʤ���mode �κ�����ˤ����Ǥ��礦���ɡ�

���ȡ��빽���������...

Wed Mar  5 21:15:34 JST 2003

�Ǥ����衣�ޤ����ƥ��Ȥ��Ƥʤ���ʬ�Ϥ��뤱�ɡ��ɽ��ѿ��ν�����Ȥ���
FCONST �Ȥ���3���ǽ��褿�͡�

(gcc �������ä������������ʤ�...)
 goto.c ���̤�ʤ��ʤäƤ�ʡ�

Thu Mar  6 14:00:13 JST 2003

PowerPC��non-lazy pointer�äơ��ơ��֥�����äƤ��Ƥ������
�߹�������ʤΤ͡����ä��󡢥쥸�������ɤ߹�����顢������
���Ѥ�������ɤ��餷�����Ȥ������Ȥϡ�code_gvar �˥���å���
����ʤ��Ȥ����ʤ��������� RLU �Ǥ���? (���ɤ�����)
�Ǥ⡢�������ʤ��ȡ�
   i = i+1;
�ʤ�ƤΤǤ⡢�Ҥɤ��ܤˤ��äƤ��ޤ���

local variable ��ǽ�� move mutilple register ����Ⱦ��
�쥸�������ɤ߹��󤸤㤦�ߤ����͡�pointer �ǻ��Ȥ�����
�����Ǥ��礦���ɡ��ޤ���31�Ĥ⤢��С������������Ȥ�
���Ƥ⤢�ޤ�����ʤ��Τ����Τ�ʤ����ɡ�

creg ���˲����ʤ������ˤ���С������Ϥޤ��ˤʤ�󤸤�ʤ�?
(IA32�Ǥϡ�������񤷤�����)

Thu Mar  6 20:50:24 JST 2003

��äѤꡢ�Ȥä�ʬ����register����¸����褦�ʥ����ɤ�
�ʤ�ߤ�����one path �ǡ�����򤹤뤿��ˤϡ�
        .align 2
_main0__:
        lwz r5,2136(r1)
        addi r1,r1,2128
        lmw r23,-36(r1)
        mtlr r5
        blr
        .align 2
        .globl _main0
_main0:
        mflr r2
        stmw r30,-8(r1)
        stw r2,8(r1)
        li r11,0
        stwu r1,-480(r1)
        li r2,100
        mtctr r2
        mr r30,r3
        addi r0,r1,64
        mr r9,r0
        b _main0__;
�Ȥ����������ˤ��뤷���ʤ��͡�

���Ȱ����ϡ��쥸�������Ѥ�褦�ˤʤäƤ���ߤ���������... r3 ����?

        mflr r31
        li r0,7
        stw r0,56(r1)

������8�ĤޤǤϥ쥸�������Ѥ�ߤ����͡�
r3-r10 ���͡�

��¤�Τ�register�˥��ԡ������Τ��������ơ�����¦�Ǽ����
���ԡ���Ԥ��櫓���͡���Ƭ��return struct�ؤΥݥ��󥿤�����Τ�
Ʊ����

(������memcpy���ޤ����...)

��ư��������쥸�����Ϥ���������f1���顣(�ʤ�ۤ�)

saveFP�äƤΤ�ƤӽФ��ơ� f24-f31��save����餷����
(31-24)*8 �����ʤ���?

pointer �Τ��Ȥ�ͤ���ȡ��쥸�������Ȥޤ�����Τ⤢��
�櫓�����ɡ����ɥ쥹�����Ƥ���Ǵ֤˹礦�󤸤�ʤ�?
����ʤɤϡ���Ȥ�Ȥ��������������(?)�ϳ��ݤ���Ȥ��ơ�

���������դˡ�r3-r10 �ϰ����Ǥʤ���в����Ƥ��ɤ��櫓����
(�����r9�Ȥ��ɤ��Ȥ��Ƥ���櫓��...)
�Ȥ������Ȥ�­��ʤ��ʤä��顢�����򥻡��֤�����ɤ��櫓�͡�
(�äƤ��Ȥϡ�LVAR ���� REGISTER �äƤ�������������󤸤��...
�ޤ������������ɤ�...)
����� get_register �����ɤ�������

�ɤ��⡢r11-r12  ������ϼ�ͳ�˻ȤäƤ���餷����

�������äƤ�������Ǵؿ��ƽФ�����Ȥ��ϡ��ɤ������?
r30�ʤɤ˰�ư����Τ�?

�ʤ��Τ�󤱤ɡ�in file call name �� out file call name ��
�㤦�ߤ����͡�(sigh...) ����ʤΤʤ�Ȥ��ʤ�Τ��ʤ���
������stub �ˤ��Ƥ����ơ�.set �ǽ񤭴�����Ȥ�����⤢�뤱�ɡ�

(�������˰����ǤϤǤ��ʤ���...)

�ʤ�����������ư�������ؤ��Ѵ��Ϥ��֤�Ǥ��ʤ��Ȥ���ʤΤ͡�
����ϥ��֥롼�����Ƥ�������ޤ�����

get_register �����м��Ԥ��ʤ��褦�ˤǤ���󤸤�ʤ���?

label ������ȡ�code_base cache ��clear���ʤ��Ȥ����ʤ���
�����Ƚ�Ǥ���ˤ� fwddef ��hook����ɬ�פ����뤱�ɡ�

Fri Mar  7 09:17:10 JST 2003

����ϡ�
       register allocation
��
       function call/goto call
�ι������ʡ�goto ������ machine dependent�ʤȤ�����
�ۤȤ�ɤʤ���register ��save����ɬ�פʤ����顣

register allocation �����ɡ�
     r0
     r1      frame pointer (or stack pointer )
     r30     jj
     r31     relocation register
     r0,r1,r2    �����ƥ�ǻȤ�
     r0-r10  ����
             �����Ǥʤ��Ȥ�����ͥ��Ū�˻Ȥ�
     r20-r29 �����֤��ƻȤ��ΰ�

r10-r19 �Ϥɤ��ʤ������? �����֤��ʤ��Τ�?

ia32 �����Ǥ�fpp�Υ����å���ؿ��ƤӽФ��ΤȤ����Ǥ��Ф�������
�ɤ���

r0 r1 r2 r3 r4 r5 r6 r7 r8 r9
r10 r11 r12 r13 r14 r15 r16
r28 r29 r30 r31

�ʤΤǡ���ΤΤߤ��Ȥˡ�17-27 �ޤǤ��Ȥ��Ƥʤ��͡�

�Ȥ������Ȥϡ��ؤ��ƽФ����ˤϡ���¸�����쥸�����Ϥʤ���
�פä������ɤ��äƤ���? ���뤤�ϡ�r17-r28 ����¸������
�פä��ɤ��Τ��ʡ�

Sat Mar  8 19:28:42 JST 2003

�ؿ��ƤӽФ����Υ쥸���������֤��򤱤뤿��ˤϡ��ؿ��ƤӽФ�
��ͥ�褷�Ƽ¹Ԥ��Ƥ����ɤ����ؿ��ƤӽФ��η�̤϶ɽ��ѿ���
�����֤��롣
     f(g(h(a)+1)+2)
�ϡ�
    a1=h(a)
    a2=g(a1+1)
    f(a1+2)
�Ȥʤ롣��������С��ؿ��ƤӽФ��ΤȤ��Υ����å��Ϥ��ʤ餺0�ˤʤ롣

�Ǥ⡢��ɡ������ϴؿ��ƤӽФ������˥����֤���Τ͡����ä��顢
����ʤ��Ȥ��ʤ��ǡ������֤�����ɤ��Τ���

Mon Mar 10 11:42:40 JST 2003

�ǡ��쥸�����Υ����֤ʤ�����ɡ�mc-codegen.c ���ѹ����ʤ�
�Ȥ���С������Υꥹ�Ȥ�Ȥä��ѹ����Ƥ����Τ��ɤ���
�ؿ��ƤӽФ��ϴ���Ū�ˤ����������ˤʤ롣���������Ǥ�
�Ƥ�Ǥ��ʤ��Ƥ⡢�����֤���ɬ�פϤ��롣������������
�롼����ΤǤ����ɤ��ʤ��Τǡ���Ʊ�����ɤ����פ���
Ƚ�Ǥ���Τ��ɤ��ΤǤϤʤ���?

�ؿ��ƤӽФ������˼��Ѥ˥쥸�������Ѥޤ줿�ͤϥ����֤���
�����ɤ��������֤������lvar�Ȥ��ƥ����������뤳�Ȥˤʤ롣
�����å��Ǥ⤤�����ɡ�
��������ȡ�stack ����ˤϡ�

     �쥸����   �쥸�����ֹ� (>0)
     �����å�   -1
     lvar       lvar�ֹ�

�λ����ब���뤳�Ȥˤʤ롣����˹�碌��tosop/assop���ľ
��ɬ�פ����롣emit_pop �����Ǥ������⡣�����å���ߤ���ޤ�
�Τ��ǤϤ��뤬��ia32�����Ǹ�Ψ����������äѤ껰���ॵ�ݡ�
�Ȥ���Τ��ɤ���������

(���ä���������������ʤ�... �ɤ��������դ��뤫...) 

Tue Mar 11 14:23:57 JST 2003

save_stacks ����ȡ��쥸�����ϤۤȤ�ɻȤ��ʤ��ʤä�
���ޤ������������ɤθ��̤����ɤ��ʤ롣

������դ˻��äƹԤ���save_stacks��save�����̤����롣����
���ˤ��ɤ������͡�ȿ��Χ������Ω���ʤ��黻�Ҥ˴ؤ��Ƥϡ�tosop
������ǤȤ���뤳�Ȥˤʤ�Τ�... ���ȥ����å����Ѥ�������
�ˤʤäƤ��ޤ����ޤ�����Ȥ��ǤǤϹԤ��Ƥ������Ȥ���... 
CMP�Ǥ�rexpr ��ȿž�����������ž������������ñ����SUB�Ǥϡ�
ADD + (-CONST) �ˤ��������ɤ��͡�

      je _xxx
�������ȡ�current register ��regv[]���ĤäƤ��ޤ�������ϡ�
�Ѥ���͡�gexpr_init �� regv ���Ĥ�Τϡ�case ʸ����Ӥ�����
���Ȥ�����0�ˤ����ɤ���(�ޤ�������̵���������)

(case ʸ��jump�ϡ�switch ʸ��������˽�������С�index jump
�ˤ��뤳�Ȥ��Ǥ����)

Wed Mar 12 12:58:47 JST 2003

��Ӥ����촹����Ȥ�����ϼ㴳�㤦��͡�

Thu Mar 13 19:39:48 JST 2003

���������С�doif �Ǿ�郎������ä��Ȥ��Ȥ��κ�Ŭ����
���Ƥʤ�����͡��䤵�������ɡ�chk ��Ȥ����ɤ��Τǡ�

   f(g(1,2,3),g(1,2,3),g(1,2,3))

�Ȥ����ȡ���ɡ�g ���֤��ͤϰ�ö���������ʤ��Ȥ��ᤸ���
�ʤ�����ɡ��ºݤϡ�r29-r22 ��ȤäƤ���褦�Ǥ��͡�

�äƤ��Ȥϡ�function call �λ��ˡ�r3-r10 �����ΰ������ɤ�����
�����å����ơ��������ä���r29-r22�˰ܤ���Ȥ�����櫓����͡�
���ä���r3�Ȥ�������Ƥ��ޤä�����ȡ���ʣ���Ƥ��ޤ���...
����äƴؿ��ƽФ������뤫�ɤ����ϡ�Ĵ�٤뤳�Ȥ��Ǥ��뤫�顢
�ؿ��ƤӽФ������ä��顢��������褦�ˤ���?

�����������ɤ������ʤ�... (���ä��������Ĥʤä���Ǥ�����?)

Fri Mar 14 10:38:25 JST 2003

function �� dsp ����arglist �� extern flag ��ξ��������Ƥ��ޤäƤ��롣
����� sc �Ƕ��̤���٤�ʪ����͡�

�ʤ󤫡�emit_pop_free ��xreg��LVAR�λ��ΥХ�����Τ˶�ϫ����...
gdb �� top level �Ǥ�while ������դ��ʤ��ơ�define ���Ƥ�ʤ�ʤ���
����ߤ����͡�

Fri Mar 14 15:50:28 JST 2003

�ʤ�... �񤤤Ƥ�񤤤Ƥ�񤤤Ƥ⡢�����!

Fri Mar 14 19:43:44 JST 2003

jump ����� input register ���꿶��Ȥ��� floating point register ��
���Ȥ�ͤ��Ƥʤ��ä��������  register_var �Ȥϰۤʤ�Τǰۤʤ�
���Ȥߤdz�꿶��ɬ�פ����롣�äƤ��Ȥϡ�get_input_register_var
���פ�äƤ���?


0x9001a544 <saveFP+4>:  stfd    f15,-136(r1)
0x9001a548 <saveFP+8>:  stfd    f16,-128(r1)
0x9001a54c <saveFP+12>: stfd    f17,-120(r1)
0x9001a550 <saveFP+16>: stfd    f18,-112(r1)
0x9001a554 <saveFP+20>: stfd    f19,-104(r1)
0x9001a558 <saveFP+24>: stfd    f20,-96(r1)
0x9001a55c <saveFP+28>: stfd    f21,-88(r1)
0x9001a560 <saveFP+32>: stfd    f22,-80(r1)
0x9001a564 <saveFP+36>: stfd    f23,-72(r1)
0x9001a568 <saveFP+40>: stfd    f24,-64(r1)
0x9001a56c <saveFP+44>: stfd    f25,-56(r1)
0x9001a570 <saveFP+48>: stfd    f26,-48(r1)
0x9001a574 <saveFP+52>: stfd    f27,-40(r1)
0x9001a578 <saveFP+56>: stfd    f28,-32(r1)
0x9001a57c <saveFP+60>: stfd    f29,-24(r1)
0x9001a580 <saveFP+64>: stfd    f30,-16(r1)
0x9001a584 <saveFP+68>: stfd    f31,-8(r1)
0x9001a588 <saveFP+72>: stw     r0,8(r1)
0x9001a58c <saveFP+76>: blr

�ʤΤ����Ȥ������Ȥϡ�
      f%d ���Ф��ơ�"saveFP+%d",68-(31-f)*4
����?

�����󡢤���ǡ������񤤤��������롣�Ǥ⡢�ۤȤ��������
�ؿ��˥Х�������������ʤ�����İ�ļ�äƤ��������ʤ�����

Sat Mar 15 16:04:09 JST 2003

�䤡...  �ޤ�.... �Х����餱���ʡ�

function call �Υ쥸�����ν������Ǥ���ᡣRISC�ξ��ϡ�parallel_assing
�������������󤸤�ʤ���?

Sun Mar 16 20:59:10 JST 2003

�������ޤ��ޤ��������ꤽ����....

�������Ƥʤ��ؿ�/�����extern�����ˤ���ɬ�פ����롣(�ʤ�ǡ�PIC�ʤ�?)

function �� c0(n->ty)==FUNCTION �Ǽ��̤��롣n->sc �ˤϡ�FUNCTION/EXTRN[1]
�����롣����͡�(CODE)�⡣�����ɡ�n->ty ����귿�����äƤ����礬
���ä�������餷����

(������������ϡ��빽�������...)

Mon Mar 17 12:02:22 JST 2003

function ��nptr�����ɡ�
    nptr->ty  function �� return type
         list3(FUNCTION,return_type,arg_type_list);
    nptr->sc  �����FUNCTION/CODE (EXTRN/EXTRN1)
    nptr->dsp �����Υꥹ��
�ȸ��������ʤ櫓����͡��ǡ������Υꥹ�Ȥ�type�Ͻ�ʣ���Ƥ��롣

¾��nptr�Ȥ���������ͤ���ȡ�
    nptr->ty  return type
    nptr->sc  FUNCTION/CODE
    nptr->dsp �����Υꥹ��
���ɤ����ǡ������Υꥹ�Ȥ�EXTRN�ξ������������������󤸤�ʤ���?
(�ɤä��ˤ�������...)

�ץ��ȥ����פȼºݤΰ����ꥹ�Ȥ��������ϥ����å����ʤ�����
�����ʤ��櫓�����顢�̤����������󤸤�ʤ���? �Ȥ���ȡ�
��äѤ����Ԥ�...


extern �ȡ������Ǥʤ���ΤȤθƽФ��򡢸ƽФ��λ�����
���̤��ʤ��Ȥ����ʤ�����������prototype ���������Ƥ���
��Τ� default extern �ζ��̤ϡ��ǽ��λ����Ǥ���Ƚ�̤Ǥ��ʤ���
�Ǥ��ʤ���͡��������Ƥʤ���Τ� default extern �ʤ�����顣
�äƤ��Ȥϡ��Ǹ�ˡ�.set ��������뤷���ʤ�����(sigh...)

Mon Mar 17 14:34:12 JST 2003

�����ȡ�input register �� regv/regs �򥻥åȤ��ʤ��Ȥ��ᡣ
�ؿ��ƤӽФ��ΰ�����ɾ���������� save ����ɬ�פ����롣
����ˡ�������ɾ���θ�ˡ�save ���줿�ѿ���ƤӽФ�ɬ�פ�
���롣(�äƤ��Ȥϡ����ޤޤǤΤϡ��ޤä����ΤǤ���ᤫ..)

register �ѿ��ξ��ϡ�����ʤ����äƤ��Ȥϡ�ia32 ¦��
�ѹ����Ƥ��ޤä��Τǡ����������ʤäƤ���͡���äȤ⡢
code �ξ��ϡ���������save�Ȥ���ɬ�פʤ������ɤ��Τ���

(11���ܤ�...)

    mr creg,hoge
    mr hoge2,creg 

�Ȥ��ϡ�g_expr_u �Ǻ�Ŭ������٤���set_freg/set_creg �ǥ쥸
�����ѿ��˳�꿶��ȡ�set_freg ��free����Ƥ��ޤ���

��ư����������ζ�ͭ�Ϥ�ä������ɤ�?

input register ��save��˺��Ƥ��롣
input register �γ������ս硣

Mon Mar 17 23:38:14 JST 2003

��������������input-register �Υ��ɥ쥹���ä��Ȥ��ϡ�
�����LVAR���Ѥ��ʤ��Ȥ��ᡣ

�ʤ�����ɡ������ʬ���äƤ⡢loop ��������뤳�Ȥ�����Τǡ�
���٤�Ǥ����Ȥ������Ȥϡ�one path �ǤϤǤ��ʤ��͡�

�थ... function call �� save_input_register ��Ʊ���ּ��٤��
�����꤬����Τ͡�function argument �ϡ����Ǥ� parse �����
���ơ����ΰ����ϡ�register �˸��ꤵ��Ƥ��ޤäƤ��롣
save_input_register �ǡ�save ���륳���ɤ�Ф��Ƥ⡢
������򸫤�褦�ˤϽ���Ƥʤ���(�ɤ�����Ф������?)

function call����Ƭ�ǡ�����������stack��save���Ƥ��ޤ��С�
���Τ����������ϲ�褹�롣���ɡ�����ޤ�ʵ��⤹��͡�
�Ǥ⡢stmw ��Ȥ��뤷��...

��ɡ�input_register �ϡ�LVAR �Τޤ޽������ơ���ǽ�ʤ��
register ��Ȥ��ä����������󤸤�ʤ����ʤ�.... �Ǥ⡢
��������ȡ����ޤǽ񤤤������ɤϡ��ۤȤ��̵�̤���...

������ˤ��衢����ޤ��ñ�ʲ��Ϥʤ��͡�

Tue Mar 18 10:46:48 JST 2003

��ɡ����� stack ��save ���ޤ�������������С��ѹ���1�ԡ�

��äѤꡢ�ؿ����Τ�ʸ�ڤ���Ƥ���gexpr����٤�����͡�
���켫�Τϡ�����ʤ��񤷤��ʤ�����

Tue Mar 18 12:41:42 JST 2003

COND(����黻��)�ǻȤ��쥸�������ؿ��ΰ������˲����Ƥ��ޤ���
input register �ˤʤ�ʤ��ͤ�Ȥ����ɤ�������ɡ�r15
��ȤäƤ��������ɡ�����Ǥ�����?

virtual ��ȤäƤ����Ȥ��ϡ�use_register �Dz����˲�����ʤ��ä�
������ɡ��Ȥ�ʤ��Ȥ���ȡ��빽�˲�����Ƥ��ޤ����ʤΤǡ�
����äȱ��ο������꤫��͡�����黻�Ҥη��ϥ����å����Ƥʤ��ä�����

�ޤ�������ϡ�����쥸������Ȥ����ɤ��Ȥ���...

�����ƤӽФ���u2d �Ȥ� bcopy �Ȥ����˲������input �쥸����
�Ϥɤ�����? ����ϡ�ͽ¬�Ϻ������͡��Ȥ�ʬ����save����ä�
������⤢�뤱�ɡ��������ɤ����褦... ���ФǤ���褦�ˤ����
�Ƥ�����⤢�롣(�ȡ��פä��顢get_register_var ���ְ�äƤ�
��ߤ�����) ���ФϤ���äȽŤ��������Υ��르�ꥺ��ϡ�����
��Ȥ������ʤ����Ȥ��äƤ⡢�����ˤʤ���������ƽ�¦��save
����? bcopy ���ɤ줯�餤�Ȥ�������ۣ�档

��ä��Ѷ�Ū��get_register_var ����äƤ�����⤢���͡���
������С����ޤ굤�ˤ��뤳��̵�� library call �Ǥ��롣(����
�äȡ��񤭴�����¿����...) ���������ڤ��ʡ��Ȥ��쥸������
�餽���Ȼפ��ȡ�����ϸ��Ф���Τȡ�����ۤɺ��Ϥʤ��櫓����

���Τ�����⹽ʸ�ڤ��������äƤ���в��Ǥ�������ʡ�

�����󡢤ޤ��ޤ������ʡ�

�ؿ����ؿ��ƤӽФ��Ƿ�ޤ���� input register ���˲���ͤ���
�ޤ���Ǥ���������⡢�ɤ�����Ф������... �ޤ���get_register_var
����Τ���ñ����͡�

save register �����äƤ���褦���͡�max_register_var ������?

Wed Mar 19 02:22:51 JST 2003

�ʤ������struct ��tag list����int a,b,c; �Τ褦�ˤʤäƤ���Τ�
��Ĥȿ����Ƥ���餷�������ä���Τ������˸��ä��Τ������
�������褦��

macro �ΥХ��⸫�Ĥ�����ä���... �थ��

�Ǥ⡢�Ȥꤢ������a.out ��ư���ޤ�����

Wed Mar 19 12:59:01 JST 2003

�ʤ󤫡���ư��������printf�˰����Ϥ��Ȥ��ϡ�rn�쥸�����ˤ�
�ͤ򤤤�Ƥ��ơ������⡢���ä��򸫤�ߤ����͡�����ϡ�
���ɤ�����....
   r4,r5   ... f1
   r6,r7   ... f2
   r8,r9   ... f3
   f4 �����ñ��
(�������ʤ󤫡�����ϰ۾�ˤ��ɤ�������... ����ʤ��Ȥ���ʤ�
f0 ���� r0 �˥��ԡ������Ƥ�...)

40(r1)�Ȥ���printf�ϡ��ɼ�ˤ֤ä��魯�褦�Ǥ��͡����ä���
�ɤ���������ɤ��������?

-112 ���餤? ����-72���٤���

(�ʤ����٤Ҥ���... ���⤬����Ȥ����Τ�...)

��ư�������ΥХ����Ĵ�˼��Ƥ��ޤ���

�ʤ󤫡�save_stack ��;�פ�save���Ƥʤ�?
�ޤ�������ѿ����ɤ��Ȥ��Τ�free list���ä������ɤ�����͡�

�������������黻�Υ����å���ɬ�פ��ʡ�

Thu Mar 20 12:06:27 JST 2003

�ޤ���save �����쥸�������˲����Ƥ���ʡ�
    set L_98,244
    stw r15,lo16(-44+L_98)(r1)
���餤�ǡ��⤦������㤦�ߤ������äƤ��Ȥϡ�L_98 ����ä�
�礭���ʤ��ȥ���ʤΤ���

 
Thu Mar 20 23:43:42 JST 2003

�褦��äȡ�self compile ���̤ꤽ����register save �Ϥ�
��äѤ��񤷤��ߤ������͡�dynamic loader ��������ꤹ�뤷��

����mod�����������ߤ����ǡ�hash���ͤ��㤦�餷�����ޥ��ʥ�����
�ˤʤ�unsigned�Τ������ͤ���int.c ��recursion���̤�ʤ���
�ޤ���offset �����������餷����

macro �ΥХ���Ȥ줿����

����ϡ�self compile ���̤�ޤ�����

Fri Mar 21 03:18:26 JST 2003

��äѤꡢr1 �� x(r30) �η׻������ʤ������äȡ�
�ƽ�¦�ǡ�������ʬ��offset ���Ѱդ��Ƥ���Τ�������
�����顢�ɤ줯�餤�ΰ����δؿ���ƤӽФ������Ȥ���
�ͤ�����ΤǤϤʤ���?


Fri Mar 21 12:22:11 JST 2003

                       <------r1_offset------------------------------>
                                      <------------lvar_offset------->
 r+  +------------+---+---------------+----------+--------------+----+    -
      caller arg   xx   register save   local      callee arg     xx
                          reg_save      disp       max_func_args*size_of_int

�Ȥ������Ȥ��ä��ߤ����͡��褦��ä� self compile ���̤�ޤ�����

free_glist ���뤫....

Sat Mar 22 11:17:41 JST 2003

creg/freg �� g_expr �ΰ����ˤ����������쥸�����ޥ���ϤǤϡ���ľ��
�ߤ�������������С�
##              conv->static_();
        addis r15,r31,ha16(_conv-L_242)
        la r15,lo16(_conv-L_242)(r15)
        lwz r3,0(r15)
        lwz r3,244(r3)
        mr r29,r3
        mtctr r29
�ߤ����� mr �ϸ���͡���äȤ��̿������ɤ���3% �⤢��ߤ�����
����ä�¿����... 386 �Ǥ� use_register ��ʤ��ʤ뤷�ʤ���
(�������Ǥ���Ⱦ�ϥݥ��󥿥���å�����ʡ����ä���ľ������
��ñ��)

�ޤ�������������Ŭ���򤷤ʤ��äƤ����Τ������Υ���ѥ����Ω��
�ʤ櫓�����ɡ�


��¤�Τΰ����Ϥ��Ǥϡ���¤�Τ��Τ�Τ�쥸�����˺ܤ���
�����Ϥ��Ƥ���ߤ������͡��ޤä���... ����ǡ�����Ƥ�
������������Ƥ���櫓����

�ʤ�  mtctr r2; bdn Lxx �Ȥ������Τ�����Τ͡�main frame �äݤ�!
����ϥ٥���ޡ����Ѥäƴ������͡�


Sun Mar 23 16:06:29 JST 2003

Breakpoint 3, get_register () at mc-code-powerpc.c:235
235         for(i=MAX_TMP_REG;i>MIN_TMP_REG;i--) {
(gdb) c 9999
Will ignore next 9998 crossings of breakpoint 3.  Continuing.
test/basic.c:67:Bug of compiler

Breakpoint 2, errmsg () at mc-parse.c:214
214         if(lineno==0) return;
(gdb) info b
Number Type           Disposition Enabled Address    WhatStackFrame Condition IgnoreCount Commands 
2      breakpoint     keep        y   0x0000ca08 in errmsg at mc-parse.c :214       
        breakpoint already hit 1            time
3      breakpoint     keep        y   0x000028e4 in get_register at mc-code-powerpc.c :235       
        breakpoint already hit 69           times
        ignore next 9930      hits
(gdb) run
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /Users/kono/src/device/mc -s test/basic.c
[Switching to process 24650 thread 0x2307]
test/basic.c:67:Bug of compiler

Breakpoint 2, errmsg () at mc-parse.c:214
214         if(lineno==0) return;
(gdb) c 69

���ޤ�������͡�

a+a+a....a ������Ƥ��ޤ����ޤ��ͤ���

��ɡ�stack frame �����꤫��

Mon Mar 24 03:06:32 JST 2003

Intel ¦�ˤ������ embug ���Ƥ��ޤä��褦����

basic�Ȥ�float������٤�夲��������?

mc-code-power.c ��lvar �ϡ�
     input arg > 0
     local var < 0
     output arg > ARG_OFF
�Ȥ���٤����͡�

Mon Mar 24 12:08:43 JST 2003

        addi r27,r1,56
        addi r29,r28,28
        mr r3,r27
        mr r4,r29
        li r5,372
        bl L_memcpy$stub
        lwz r4,0(r28)
        lwz r5,4(r28)
        lwz r6,8(r28)
        lwz r7,12(r28)
        lwz r8,16(r28)
        lwz r9,20(r28)
        lwz r10,24(r28)
        mr r3,r28
        bl _main3


�����ࡢ������ۡ��ǽ��28byte�����쥸�����Ϥ��ʤΤ������ɥ쥹
���Ѥ��ʤ���Ǥ��礦���ɡ��ޤ�����碌�ʤ��ƤⳲ��̵�����ɤ���
���Τ����͡�(����ʤ��񤷤���̵����... �ޤ���function ��ʣ��
����ˤʤ��) ��������ư�������쥸������Ȥ��Ȥ�����ʤ󤸤�ʤ���
�ɤ��ä����⡣


        stwu r1,lo16(-L_9)(r1)
�Ȥ����Ƥ��뤫�顢�ɽ��ѿ���64k����äƤ��Ȥ��͡�ha���Ƥ⤤��������ɤ���

Mon Mar 24 17:07:59 JST 2003

���ơ��褦��ä� fact-a.c �˼��ݤ����櫓�����ɡ����Τޤޤ��ȡ�
    input register -> ����ؤ�save
�äƤΤ���������͡�����Ϥ��������ʤ���sub routine call ����ȡ�
r0-r10 ���˲�������㤦�����Ȥ������Ȥϡ�code segment �ΰ����ϡ�
r29-r20 ���ɤ��󤸤�ʤ���? ��ư������f31-f20��ޤ�ơ�

����ϡ��ɤ���input register ����ꤹ�뤫�����ɡ�get_input_register_var
�� code �Ѥ��ɤ�������ꤹ��Τ��ɤ����ʡ�fnptr �Ǥϥ���ʤΤ���������
�����ɤ���������

r31, r1 �����꤬����ΤϤ������ޤ���r1=r30�Ǥ��ä������ɤ��Τ�������?
��������function calll �λ����ѹ������ʤ���������

�����input register (���ξ���r29-r20,f21-f20������)���б���
�ɤ�����? �̾���ȸƽ�¦�����ݤ���櫓�����ɡ������Ϥ����ʤ��͡�
�쥸������save����ɬ�פ�̵�����顢����������ñ�Ǥ��������

���Ȥϡ�return/environment �ΰ��������ɡ�ia32 �����Ǥ⤤������
ư���ʤ��ʤäƤ���褦���ʡ�

Mon Mar 24 21:56:47 JST 2003

�������̤˥ե졼����Ѥ��ʤ��ǡ����ΤޤޤǤ�������
���������ڤ���͡�return ���褦�Ȼפ��Ȥ�������
frame �򤦤������ʤ��Ȥ����ʤ����ɡ�return ��
�̽������������顢����ʤ�����

Wed Mar 26 14:29:21 JST 2003

�ǡ��ե졼����Ѥ��ʤ��Ȥ���ȡ�
    
                       <------r1_offset------------------------------>
                      *               <------------lvar_offset------->
 r+  +------------+---+---------------+----------+--------------+----+    -
      callee arg   xx   register save ! local      caller arg     xx
                          reg_save      disp       max_func_args*size_of_int
        lvar>0                         lvar<0       lvar>0x1000 0000

�ʤΤǡ�r1/r30 ���˰�ư������ɬ�פ����롣����code segement/
function ���ɤ���r1/r30����äƤ��������Τ���ʤϤʤ��Τǡ�
jump �����������Ȥ��᤹ɬ�פ����롣r30������ʤ��r1�Τߤ�
�������ɤ��������᤹ɬ�פϤʤ���

�Ǥ⡢r1_offset ʬ���᤻���ɤ������ʤ�����顢r30�� * �˸���
���Ƥ��ɤ��󤸤�ʤ���? ! �Ǥ⤤��������ɡ����ä���������ñ
����? code �ξ��� register_save �� 0 (�Ĥޤꡢ�ޥ��ʥ�)��
�櫓�����顣(�ޤ�����򳫤��Ƥ����Ƥ��ɤ�����) 

Intel �ξ��Ϥɤ����ơ��������ʤ��ä��Τ�? (�Ǥ⡢�Ǹ�˥����å�
�������ˤ�core dump���Ƥ�����...)

                      ebp                        <-----esp----------->
                       <------r1_offset------------------------------>
                      *               <------------lvar_offset------->
 r+  +------------+---+---------------+----------+--------------+----+    -
      callee arg   xx   register save ! local      caller arg     xx
                          reg_save      disp       max_func_args*size_of_int
        lvar>0                         lvar<0       lvar>0x1000 0000

�Ȥ����櫓�ʤΤǡ�* �ˤ����������� intel �ǤȤ���פ��롣
�äƤ��Ȥϡ�ebp �ΰ�ư�� intel �Ǥ��äƤ����äƤ���?
����function�ǤϤ����ʤäƤ��������ɡ�code �Ǥϰ㤦��


     ebp                                         <-----esp----------->
                       <------r1_offset------------------------------>
                      *               <------------lvar_offset------->
 r+  +------------+---+---------------+----------+--------------+----+    -
      callee arg   xx   register save ! local      caller arg     xx
                          reg_save      disp       max_func_args*size_of_int
        lvar>0                         lvar<0       lvar>0x1000 0000

�äƤ櫓�����Ȥ���� powerpc �Ǥϡ�

     r30               <------r1_offset------------------------------> r1
     #                *               <------------lvar_offset------->
 r+  +------------+---+---------------+----------+--------------+----+    -
  xx  callee arg   zz   register save ! local      caller arg     zz
                          reg_save      disp       max_func_args*size_of_int
        lvar>0                         lvar<0       lvar>0x1000 0000

��#��r30����ꤷ��r1�򤺤餹���Ȥˤʤ롣��äѡ����ä�����͡�
zz �Ϥ��顣xx �ˡ�base  �Ȥʤ�ؿ��ƤӽФ�����롣���顢
calle arg ���˲�����롣

�ɤä����ǽ���ʡ�ξ����������? ��äѤ��Ԥ��餫�ʡ�gcc ��
���Ԥ�������ñ��������

�����ѿ���쥸�����˳�꿶�äƤ��ޤ��ȡ������ϰϤǤ�
��ñ��ư���Ƥ��ޤ���(����㡢������...)

goto with environment �ǹ�¤�Τ��֤��Τˤ����դ�ɬ�ס�
�ɤ��ǥ��ԡ�����? goto �������? return-continuation?
�����ͤ���return-continuation ¦�����̤Ǥ��礦��������
�Ǥ��֤���ϸ��δؿ��ƤӽФ��ΰ����������������ä�
���뤫��͡������顢�ȤäƤ��������������ɤ��櫓�͡�

(�ʤ� -O3 �ˤ���ȡ�mc1 ��������...)

Sat Mar 29 16:35:18 JST 2003

     r30               <------r1_offset------------------------------> r1
     #                *               <------------lvar_offset------->
 r+  +------------+---+---------------+----------+--------------+----+    -
  xx  callee arg   zz   register save ! local      caller arg     zz
                          reg_save      disp       max_func_args*size_of_int
        lvar>0                         lvar<0       lvar>0x1000 0000

���Τޤޤ��ȡ�* �� previous r1/r30 �ˤʤ�Τǡ�function ����
goto �������������Ϥ�zz�ˤ���Ϥ���saved r31/r30���˲������
���ޤ�������ϡ�����äȺ���Ȥ������Ȥϡ���ö��dummy subroutine
(���̤�stub �äƤ�����)��ƤӽФ������ɤ�? ������Ϥ�previous r1/r30
�ϻ����⤤�Ƥ���櫓������... �ޤ���r20-r29�ϤĤ֤���Ƥ��ޤ�
�Τǡ�����ä�save����ɬ�פ⤢�롣f31-f20�⡣(�빽¿����...)

   #  *          r30 <--------------r1_offset-----------> r1
r+ +--+----------+----------+-----------+----------+----+
xx  zz  reg save !callee arg!code local  caller arg  xx
         r20-r29 

������� environment �ϻ�������ɬ�פϤʤ�? ���䡢����?
�դ�������Ϥ��������ɬ�פϤʤ��ʤ�櫓�͡����ä���
�������줤���ʡ�goto-cotinuation �ߤ����ʴ�������

�֤�¦�ϡ�

  lwz r1,continuation
  lwz r1,0(r1)
  lwz r0,8(r1)
  mtlr r0
  lmw r30,-8(r1)
  blr

���٤��ɤ�? ����r30�äƤΤ�goto��Ǥ��Τ����ʤ������䡢�ԤƤ衢
���ξ��ϡ�r20-r29�äƷ�ޤäƤ���櫓����

  lwz r1,continuation
  set r3/f1 as a return value
  lwz r1,0(r1)
  lwz r0,8(r1)
  mtlr r0
  lmw r20,-148(r1) (?!)
  blr

���ɤ��櫓������ʸ��Ʊ����return address��̵�뤹�뤳�Ȥˤ��뤫��
�ƽ�¦�ϡ�

  �̾�δؿ��ƤӽФ� (����0) (�ϡ����0������..)
  bl L_stub_NN
L_return:        (���̤�retrun�⤢�뤫�顢ɬ�פʾ�礬����)
  lwz r1,0(r1)
  lwz r0,8(r1)
  mtlr r0
  lmw r20,-8(r1)
  blr
L_stub_NN:
  mflr r0
  bl L_61
L_65:
  lwz r1,0(r1)
  lmw r23,-108(r1)
  b restFP+36 ; restore f23-f31
L_61:
  stmw r23,-108(r1)
  stw r0,8(r1)
  b saveFP+36 ; save f23-f31

����ä�ʣ�������뤫�ʡ��ä� gcc �Ǥϡ��������������񤷤����⡣

������������register save�ϡ�����y�ؿ����ƤӽФ��줿������
��äƤ��ޤ����ɤ������������ɬ�פʤ���������Ϥ���� xx
�����äƤ��롣����͡�

                 * goto��ƤӽФ����ؿ���r1 ! r1(goto����r1)
   #             *                           r30<--r1_offset-------------> r1
r+ +----------+--+----------+----------------+-----------+----------+----+
    cousin arg xx  reg save !callee arg      !code local  caller arg  xx
                   r20-r29     lvar>0         lvar<0      lvar>0x1000 000
                   f20-f31  <-my_func_args--><--disp-----><-max_func_arg->
                              *size_of_int                  *size_of_int

�Ȥ���� stub ��ɬ�פʤ���cousin arg ����¸����Ƥ��롣goto ��
�����Τߤ�local�ѿ����񤭤�����dz�Ǽ����롣����ǡ�original
��IA32�����Ȱ��פ��뤳�Ȥˤʤ롣(��������¸������ơ����䡢
���Τ���¸����Ƥ���󤸤�ʤ���?)

����ǡ�code segment ����ؿ��ƽФ�����Ȥ���? (�äƤ��Ȥϡ�
����褦�Υƥ��Ȥ�ɬ�פʤ櫓��...)

Wed Apr  2 17:40:32 JST 2003

register �ѿ������˻Ȥ��Ƥ��Ƥ⡢�虜�虜save����ɬ�פϤʤ���
��ä���ʤ����顣register ��Ȥä����Ȥˤ���ˤϡ�used_max_register_var
�����ꤷ�Ƥ����ɤ���

Interl�Ǥ� goto ��ư���ʤ��ʤä��Τϡ�arg_offset ����register �ѿ�ʬ
����褦�ˤʤä����顣save ���뤳�Ȥ�ͤ���ȡ����������ɤ����ºݡ�
function call �������save����Ƥ��ޤ����Ȥ������Ȥϡ��̤� r20-r29
�Ǥ���ɬ�פϤʤ��äƤ��Ȥ����̾��input register var���ɤ����Ȥ���ȡ�
register�ѿ���save����ɬ�פ�ʤ��͡�
������input regsiter var �ϡ�function call�����ˤ� save����ɬ�פ�
���롣�Ǥ⡢����ϡ���äѤ���٤줫���äƤ��Ȥϡ���äѤꡢ
r20-r29���ɤ��äƤ��Ȥ���

jump() �Ǥϡ��ƽФ������ϡ�-arg_size �Ĥޤꡢ�ɽ��ѿ���
Ʊ�������ˤʤäƤ��롣�äƤ��Ȥϡ�

                 * goto��ƤӽФ����ؿ���r1 ! r1(goto����r1)
   #             *                           r30<----r1_offset---------> r1
r+ +----------+--+----------+----------------+-----------+----------+----+
    cousin arg xx  reg save !callee arg      !code local  caller arg  xx
                   r20-r29     lvar >0        lvar<0      lvar>0x1000 000
                   f20-f31  <-my_func_args--><--disp-----><-max_func_arg->
                              *size_of_int                  *size_of_int

                  r1 <----------------------r30 (return continuation)

�ǡ�callee arg ����¸���줿�ޤޡ�code local �����Ѥ��äƤ��Ȥ��͡�

return continuation �ǡ���¤�Τ��֤����Ȼפ����񤷤������⤽�⡢
��ư�����������������֤�Τ�?

Thu Apr  3 13:47:23 JST 2003

r1 �� stack top ����¸���Ƥ����Τ򡢤��Τޤ�environment
�Ȥ����Ϥ��Τ��ɤ���

stack ��Υǡ�����64kbyte�ʤΤ����¤��������򤨤ޤ���

�Ȥ����櫓�ǡ�powerpc �Ǥ� CwC �ϤǤ������ꡣ

    return continuation �Ǥι�¤�Τΰ��Ϥ�
    function ��prototype�Ǥν�ʣ���������ξ�ά

�����꤬���ޤ����ƥ��Ȥ��Ƥ��ʤ������ȡ�

    �ؿ�ñ�̤Ǥι�ʸ�ڤκ���
    ����Υե졼�๽¤�κ����ѥС������

�����ǤϤ��롣


Fri Apr  4 10:41:22 JST 2003

����������-O3 �ˤ���ȡ�mc-codegen.c �� arg_register ��
r14 �ޤǻȤ��衣����ϡ��ޤ�����Ǥʤ�����? ���ä��ʤ���

Mon Apr  7 14:29:51 JST 2003

���������С�unsigned char �Ͻ������Ƥ��? crgvar �Ϥ��뤱�ɡ�
curgvar �Ȥ��Ϥʤ��ߤ��������ɡ�

���ȡ�-1.0 �Ȥ��� d2i �Ȥ�����������Τ�ľ���Ƥʤ���Ǥʤ�����?

MIPS �����̿��ϡ�

        beq     $2,$3,$L18

        slt     $2,$2,$3
        bne     $2,$0,$L17

�Ȥ��������ʤ櫓�͡�(signed less than ��?)

���Ȥ���Ⱥ�����ˡ�ǤϤ��ޤ��ʤ����⡣

PS2Linux�Υ�����֥餬��ǽ�����ơ�forward reference ������
��褷�Ƥ���ʤ����ɤ�����㤤�����?

.include ��Ȥ����ɤ��餷����(����ʤ�Ǥ����Τ�?!)

csvalue() �Ǽ�ä��褿regiser��ï��free�����?

Tue Apr  8 14:52:06 JST 2003

MIPS�ˤ� bgez �Ȥ� bgtz �Ȥ�����̿�᤬����Τ͡��ʤ󤫤�
�Ȥ����? �Ȥ��뤱�ɤ������Υ���ѥ���ǻȤ���ˡ��?

gcc����ư�������쥸�������򤱤�褦�˥���ѥ��뤷�Ƥ���
�Τϲ��Τ�����? �٤�����? jal dcmp �Ȥ��ϡ���äѤ��ѡ�

double �� float �κ����ɤ��狼��ʤ���

Wed Apr  9 16:20:00 JST 2003

LOR LAND ������ΰ������ɲ�

����ν��������뤫�顢�ѿ�*������餤��h��Ŭ����
���줿�����ɤ����⡣���������쥸�����⾯�ʤ��Ȥ�����
(�ޤ�?)

���ȤǻȤ��褦�ˡ��ޤ�����Ŭ���������Τ�ɬ�פ��ʡ�

MIPS����ư�������äƤ���single precision ����������̿�᤬
�ʤ�? dpsub �Ȥ���ƤӽФ��ΤäƤ��������ʤ�? (�ޤ���
����������ɤ�)

Fri Apr 11 14:36:33 JST 2003

(�������...)

�פ���ˡ�
     ��ư�������쥸������ single float �����Ȥ��ʤ�
     double �ϡ����٤ơ����ѥ쥸�������֤����׻��Ϥ��٤ơ� subroutine 
�äƤ��Ȥ���͡�(������������)

single float �����Ǥα黻��Ƴ�����뤿��ˤϡ�DSUB��¾��FSUB 
�ʤɤ�Ƴ������ɬ�פ����롣����ϡ֤������ס��Բ�ǽ����ʤ���
�ɡ����ʤ���ɤ������͡���ư����������������⤢�뤷������
double ���Ѵ����Ƥ���׻����������ʤ����ȸ����ȡ�����ʤ�
�ȤϤʤ��櫓����������ơ���ư�������쥸������Ǥα黻�򤪤�
�ʤ�subroutine�Ϥʤ���? (���뤫���Τ�ʤ�) 

�ޤ��ʤ���FCOMP�Ȥ����Ф��������ʤ�����ɡ�

Sat Apr 12 13:30:07 JST 2003

jal dpadd �ϡ���äѤꡢ���ʤ�ʣ������ư�������黻���Ȥ�����
�狼�ä���IEEE�η����ȹ��ʤ��Ȥ��Ȥ��Ǥ����ʤä��󤸤�ʤ�
������? ��äȤ⡢PlayStation �˹�碌�Ƥ���Τ����Τ�ʤ���
�ɡ�

�Ȥ������Ȥǡ�single float �׻�������ʤ��ȡ���Ȥ�gcc �Ȥ�
�����礭������������Ȼפ����äƤ��Ȥϡ�fmachineop �Ȥ� FSUB
������ʤ��Ȥ���äƤ��Ȥ����ޤ������С����������ʤ�����ɡ�
¾��CPU�Ȥ�Ĵ�᤬�ʤ�... 

���ϡ�float �α黻��pipeline��Ǥ�1clock�ʤ���������顢
�Ǥ����double �Ǥ�ä��ߤ������ɤ͡��ȤϤ�����double/float
���Ѵ������פˤʤ�Τǡ�float base ����MIPS������®��
�äƤ��ȤˤϤʤ뤫���Τ�ʤ���

gdb ��disass �򸫤�ȡ�jal bpadd �Ȥ�������쥸����
��Ȥä����������ˤʤäƤ���餷�����ޤ���disass ��
�쥸����ɽ������

    $a0 $a2 $a3 $at $f0 $gp $ra $s0 $s1 $sp $t9 $zero $v1 $f12 $at

�Ȥ��ʤΤǡ��褯�狼��󡣤��ޤä���Τ�������⡢
����äȻ��֤�����Τ���?


�ޤ����ʤ�... ANSI-C �˽������Ȼפ��ȡ����Τ������float/double
�Ϥ��äȤ�������͡��Ǥ⡢�Ȥꤢ����ư�����ɤ�?

expr �ΰ����Ȥ��ơ�output type�פ�����뤫? ����Ū�ˤ� assign
�Ƿ�ޤ�type���׵᤹�롣��äѤꡢC �ε��ʽ񤬤����������ʤ���
(����Ϸ�����...) CbC �Ȥ��ơ�����������Τ������Τ�������
��������? (�����ͤ�...)
    float  = float op float
���ɤ�������ɡ�
    double = float op float
�λ��ˡ�ɬ�פ����٤���ݤǤ��ʤ���cast ������ɤ�������ɡ������
ANSI-C �Ȥϰۤʤ��ư�ˤʤäƤ��ޤ����ޡ���������

MIPS��double=float �Ȥ������Ȥˤ���äƤ�����⤢��͡�
�����������줤�����Ǥ⡢�ɤ�����¾��CPU�⤢�뤳�Ȥ�ͤ���ȡ�
fbinop ����󤸤�ʤ���? lbinop ��Ф��ʤ��Ȥ������������
short �Ȥ�unsigned char �ΰ�����͡�(sigh...)

�ޤ������֤���������顢�����ɤ������ʤ�����ɡ����ɤ�!

(�����double�Υ롼������ư�������쥸������ȤäƤ�����
�ڤ��ä��Τˡ�)

Mon Apr 14 23:29:37 JST 2003

��äѤꡢ����ä��ѹ��礭���ʤ���

Fri May  2 14:53:16 JST 2003

�ʤ�Ǥ⤤�����ɡ�power-pc �� test/basic ���̤�ʤ��ʤäƤ롣
(�ޡ����������....) struct-push�� args-works �������
ư���ʤ��ʤä��餷����

���ȡ������ΰ��Ϥ������ɡ�printf (...) �������̰���������?
�ץ��ȥ����פ�����Τ����̰�������ɬ�פϤʤ��󤸤�ʤ�?

Sat May  3 18:38:57 JST 2003

�狼��ޤ�����contains_in_list ��������Τ�˺��Ƥ���͡�
���ȡ�get_register �ϡ��ɤ���­��ʤ��ʤ�櫓����? ����
���Ϥɤ������? ­��ʤ��ʤ�Τϴؿ��ƤӽФ��λ�����?
(����?)

���Ȥ���С��ؿ��ƤӽФ���save���ѿ���ɽ��ѿ���Ȥ���褦��
������ɤ��������͡�

Sun May  4 09:18:32 JST 2003

�ؿ��ƤӽФ�������ư���������Ǽ���롢r8,r9 �ΰ�����
����������

emit_push / tosop �Ƕɽ��ѿ����������̰���
�������������󤸤�ʤ�? register full ���ȡ�

     register ��load (emit_push)
     register full �Ǥ����ɽ��ѿ������� (*)
     �黻����register�˺�����

�ޤ��ͤ���������ȡ�mc-code-386.c �λ�������櫓
�����ɡ��ޤ����������������Τ��ʡ���äȤ⡢(*)
��������ʤ���С��ä�����Ϥʤ�������ɤ͡�

�ɽ��ѿ�������ѿ��������­�����Ȥ��Ͻ����������������Τ��ʤ���

Sun May  4 15:10:48 JST 2003

���֤�oprt �Ȥ��ϡ�����ۤɸ��̤�̵���衣�����Τϡ�
register full ���������?

MIPS version �ϡ��ޤ��ޤ������ȸ�����������ä���
���դ��ƹԤ������ʤ��͡�

Sun May  4 18:29:26 JST 2003

d50 �Ǥϡ������ϥ쥸������ $4,$5,$6,$7 �� double ��Ĥ����Τ�ʤ���

f50 �Ǥϡ�������
        $f12,$f14,$6,$7
�Ȥ����褦��4�ľ��餷����(���ޤä�����...)

i50�Ǥϡ�$4,$5,$6,$7 ���͡�

���Ȥ�stack���Ѥ�ߤ����͡�

������ get_input_register_var �ǽ�������櫓����

Mon May  5 15:28:07 JST 2003

code_fconst/code_dconst �� code_drgvar(e4,d,reg) �ߤ����ʤΤ�
�������äƤ�ʡ��ޡ�����������ɡ�

��äѤꡢ��Ԥ����졣(���ɤ���) free �� d ����ꤹ��ΤϤޤ�����

Thu May  8 11:02:42 JST 2003

regs/fregs ��ʣ����ɬ�פʤ��󤸤�ʤ���? ��Ĥ��ɤ�? ������
�ϸ����ʤ����顢mc-code-mips �����Ǥ�������Τ��ɤ���

register �Τ�������פ��ʤ��Ȥ��ᤫ��

�������ɤ�.... ������ư���Τ�?

double �Υ饤�֥��ƤӽФ���$3,$4,$5,$6 ��Ȥ��櫓�����ɡ�
������ɬ�������Ƥ����ʤ���Ф����ʤ��櫓����͡��Ǥ⡢�ºݤ�
�ϡ��饤�֥��θƤӽФ���ˤ�$3,$4 ���Ȥ��Ƥ��ޤ��������ǡ�
emit_push �����ȵ��ޤ�����... 

������function call��Ʊ�������Ǥ⤤��������ɡ��������
����äȤ��Ĥ��ʤ�?

�ʤ���ư�������쥸�����ѿ��ؤ�dpreinc/dpostinc ���������
�ʤ��󤸤�ʤ�? ����ϡ��ޤ����󤸤�ʤ���? dassop �⤽����?
����? �ʤ󤫲��⤷�Ƥʤ��ߤ������ʡ�Intel �Ǥˤϥ쥸�����ѿ�
���ʤ����顢�ƥ��Ȥ��ʤ��ä��Τ���code �ΰ����ϥ쥸�����˳�
�����Ƥ��뤫�顢���Τ�����ǥƥ��Ȥ��뤳�Ȥϲ�ǽ�������͡�
�ޤ������켫�Τ��񤷤��Ϥʤ���... 

code segment �Ǥ���ư�������쥸�����˳�꿶���Ƥ��ޤ��Τǡ�
�¤ϥ��顼���ФƤ����󤸤�ʤ����ʡ�����ϥƥ��ȥץ������
��񤯤٤��Ǥ��礦�͡�

���뤤��#define REG register �ǥƥ��Ȥ���ɬ�פ�����櫓�͡�

MIPS�Ǥϡ�$4,$5,$6,$7 �ϡ����������̰������ʤ��Ȥ�����͡�

Thu May 15 21:25:45 JST 2003

fregv �ϡ���äѤꥵ�֥롼���󡦥�����ˤ�������?
(�������˼��Ȥ��ϤޤäƤ��ޤ��ȡ��ʤ��ʤ��ʤޤʤ�...)

Sat May 17 13:57:12 JST 2003

$4,$5 ���� creg �ޤ��ϡ�double ��freg�Ȥ��ƻȤ���
$f12 ��floating �ѡ�

�������emit_push����Ф�����㤦���ɤ͡�rename ����٤���?
���⤽��rename��ɬ�פʤ��󤸤�ʤ���?

���Ȥ⤦�����ʤ�����ɤͤ�����뵤���Ǥ�...

Tue May 20 11:08:44 JST 2003

freg ��Ʊ���褦�� dreg ����? (��������� ia32
�ν�ľ�������뤬��������ɤ��Ȥ���...)

�Ǥ⡢mc-codegen.c �� creg/freg �˰�¸���Ƥ��뤫�顢
������ľ���Τ��빽���ɤ���������ľ����
����פʤΤ�? ��������...

�դ�creg/dreg/freg ��̵�����äƤΤ�? ������creg ��
���櫓���ʡ�����äȽ�ľ����¿�����ɡ�����Ū�ˤ�
����Ǥ����Ϥ������ɡ����ܤ��Ƥ���current register
�ϰ�ĤΤϤ������顣
(1)
   creg int
   freg double/float

�äƤʤäƤ��뤫�餪�������ΤǤ��äơ�
(2)
   creg int/double/float
����
(3)
   creg int
   freg double
   greg float
����ͤ���

��äѤ�(2)���ʤ���long long �Τ��Ȥ�Ȥ���ͤ���ȡ�
�Ǥ⡢�Ȥꤢ����(1)�Ǥ�뤫��

������ˤ��衢fregv ���������뤳�Ȥ���Ϥ����󤸤�ʤ�?

����ϤǤ��ޤ�����

Thu May 22 23:40:13 JST 2003

3808                macro = (char *)car(nptrm->dsp);
3809                if (nptrm->sc==MACRO) {
3810                    while((*macropp++ = *macro++));
3811                    macropp[-1]=c;
(gdb) 
3812                } else if (nptrm->sc==FMACRO) {
3813                    if(c!='(') error(MCERR);
3814                    *macropp++=0;
3815                    macrop = macro_function(macrop,&body,nptrm,
3816                            list2((int)macro,history));

MACRO �ξ���recursive �ʽ�����˺�줤�Ƥ���ߤ��������ɡ�
����Ǥ��ɤ��ä��Ϥ��ʤ�����ɡ�macro_buf ��static �ʤΤ�
���Թ礬�ФƤ���ߤ����͡�

recursive �˽�������ȡ�
   #deifne car(e) heap[e]
   car(e)
�ߤ����ʻ��ˤޤ���������ϡ��ɤ��������ä�?

LMACRO �äƤΤ����ä��ߤ����͡�

Sun May 25 21:48:46 JST 2003

macro_eval ���ޤ����������Τ��֤��Ȥ���...

ñ���creg/freg�����줷�Ƥ��ޤ��ȡ�
     fdecl �� creg �򥻥å�
�������ˡ�float/double/int �ˤɤ줫�˸��ꤵ��롣���Τޤޡ�
coce_rlvar(creg) �Ȥ���ƤФ�Ƥ��ޤ��Τǡ�����äȺ��롣
code_rlvar �ǡ�if(!is_int_reg(creg)) creg = ireg;
�Ȥ�����Ф���������ɡ�����ϡ�����ä��Ѥ����?

���⤽�⡢mc-codgen.c ��creg������⤤�Ƥ�����ͳ��?
�ʤ󤫤��ä��褦�ʵ������뤬...

��������
   use_int_reg()
�Ȥ����Ƥ����ɤ��櫓�͡�(rname ��Ȥ����ɤ����ϤȤ⤫��)

code_rlvar �Ȥ������ꤹ��register�򾡼���Ѥ������
���줷���ʤ���(���?) codegen ¦�� use_int_reg()�Ȥ�
�Ǥ���Ф����󤸤�ʤ���?

Mon May 26 21:06:14 JST 2003

code_* ¦�Ǥ�뤫��mc-codegen ¦�ǹԤ���? �ɤä����ʤ���
code_* ¦�������ɤ��褦�ʵ��⤹�뤱�ɡ�

Thu May 29 10:30:09 JST 2003

freg/creg �ζ��̤� mc-codegen ¦�Ǥ�äƤ���������顢
mc-codegen ¦�Ǥ��ʤ��ȡ�mc-cdoe-* ¦�Ǥ�ưŪ
�����å������������Ƥ��ޤ���

creg/freg ��ͭ����Τ��ɤ��Τ��������������
mc-codegen ¦�Ǥ��٤��ʤ󤸤�ʤ���?

mc-code-* ¦��������ȥХ�������ڤ�ʤ�...
(�Ȥ����Ĥġ��⤦�������ʤ����������... �Ǥ⡢�ʤ�)

cast ��ʬ������Ǥ������ʤ��ñ�ʤ���������ɡ�

Tue Jun  3 13:03:41 JST 2003

�������ʤ󤫾���ڤ�ʤ���CONV ��ľ����creg���������
�ɤä��� use_float ��˺��Ƥ����������ʡ�

Wed Jun 11 12:27:58 JST 2003

�ʤ󤫡��褦��ä� creg/ireg/freg �����դ����衣
creg ���ѹ������Ȥ��ˡ�ireg ���ѹ���˺��뤳�Ȥ�¿���ä�
�ߤ�����set_creg ��ɬ���Ȥ��褦�ˤ�����ɤ��������Ȼפ�
������

Thu Jun 12 19:34:48 JST 2003

�ޤ���MIPS�ѤΥ쥸����������Ƥ�񤫤ʤ��Ȥ�����͡�
�����Ƚ񤤤Ƥ⤤��������ɤ����ʤ� one path ��
����Τ����򤤤�Ǥ���?

Sun Jul 13 18:26:29 JST 2003

�ޤ����쥫��ʤˤ�񤫤ʤ��ä��Τ��� mips �ϡ�mc-code-power.c
�����ľ���������ɤ��������͡�

   regs/regv �ϡ�i/f/d �Τ��٤ƤΥ쥸�����˴ؤ��ư��

�Ǥʤ��� stack ���Ѥ�Τ�����Ǥ��ʤ����顣����������̣�Ǥϡ�
reg_stack �� freg_stack ����̤����̣�Ϥʤ��櫓�͡��Ǥ�stack
�Ϸ��դ����������ɤ����顣�Ǥ⡢���̤��Ƥ����ȡ�long ������
�������ˤ⡢stack �����䤵�ʤ��Ȥ���ʤ󤸤�ʤ�? �ʤΤǶ���
���ʤ������ɤ����Ǥ⡢����˼��Ĥ���ȡ��ޤ����֤������
��ʤ���? ���Τ���ˤϥ����å����Τ�Τ˷��դ����ʤ��Ȥ����
������Ʊ������

mips �� double ���Ǽ���뤿���register pair�ϡ�regs ��
��Ǽ���롣regs �˥��������ˤ�ɬ�����������ؿ����̤���
�ʤ�ۤɡ�

get_input_dregister_var �ʤ�����ɡ�dregister pair ��
���ϡ����pair����ޤä��ͤˤʤ�ɬ�פ������͡�
����ʬ�Ϥɤ�����? ����äƤȤäƤ�����?

������������Ǥ�դ�register pair������ʤ��Ƥ��ɤ��衣input register
���б�����Ϣ³����register pair ���������������������С���
�ޤ굤�ˤ��ʤ��Ƥ��ɤ��ʤ뤫�顣�Ǥ⡢gcc �����pair�������
�����鵤�ޤ����ʤ�? 

regv �ϡ�register rename ���ʤ���Ф���ʤ��󤸤�ʤ�?

Mon Jul 14 10:54:46 JST 2003

�ʤ󤫤ʤ�... creg/ireg/freg/dreg �ϡ�����ޤ��ɤ������ǥ�
�Ǥϡ��ʤ��ä��ߤ�����creg �ϡ����Τ����Τɤ줫�Ǥʤ��Ƥ�
�ʤ�ʤ��������������ݾڤǤ��ʤ���

����Ʊ���ǡ�creg ���ѻߤ��ơ�ireg/freg/dreg/lreg �Ȥ��뤫?

Mon Jul 14 14:25:23 JST 2003

�ʤ� unsigned ���̤�ʤ��ʤäƤ���ߤ�����

Sun Jul 20 17:37:34 JST 2003

��äѤ� dictionary �ϡ���ľ���ʤ��Ȥ������ʡ�
����˴ؤ��ơ�heap �⽤�����������ɤ������Υ�����
�Ϥ���ޤ����Τʤ���

���ơ����Ȥϡ����ե��åȤ�����... ����...

Mon Jul 21 15:12:56 JST 2003

Frame pointer �ϻȤ���? �Ȥä����������󤸤�ʤ�?
PowerPC �ϻȤ�ʤ��ä����ɡ�

Tue Jul 22 08:12:48 JST 2003

switch ʸ��table�˥���ѥ��뤹��ˤ�...

�ǽ����ӤιԤ�����ǻ��ꤹ��褦�ˤ���
        cmp reg,case_value
        bne L_NEXT
   ....
   L_NEXT:
��
        cmp reg,case_value
        bne L_CASE
   ....
   L_NEXT:
      ....
   L_CASE 
�ǡ�case ʸ�����ä���table���롣table ������ʤ��褦���ä��顢
   L_CASE = L_NEXT

��case�������ϳФ��Ƥ�����
      (list of (value, label))

table �ϡ��ɤ���äƺ�뤫�ȸ����ȡ�

   �ޤ����ͤ�ʬ�ۤ�����å�����
   ̩�٤ι⤤ɽ����(ü�Τ����Ĥ��������Ϣ³���Ƥ��뤳��)
   �Ȥ�������(�꺹ʬ��)Ϣ³���Ƥ�����ʬ�ˤ���ɽ������ɤ�����
   table ��8entry�ʾ塣����ʲ��ϡ�2ʬˡ���餱�롣
       (list of (number of entry, diff, (list of (value,label))))

512 or 128kbyte �ޤ���ǧ���롣���٤Ϥʤ��Ƥ��ɤ�����Ϣ³���Ƥ���
��ʬ�ˤ���ɽ�Ϻ��ʤ���

Ϣ³���Ƥʤ���ʬ�ϡ�2ʬˡ�ˤ��롣

2 ʬˡ�Ǥ⤤�����ɡ�2ʬˡ�ˤ���? ����������ñ���ʡ��Ǹ�Υ�
�ơ����ϡ�(��������פ��Ƥ����...) ���Υ����ɤ��Ȥ��뤷����
������ȡ�sort ���ơ����椫������Ӥ��ƹԤ����ɤ�����������
��ɽ��ʬ�ۤȤ��ͤ��ʤ��Ƥ��ɤ����餤������͡�

�����

�ޤ�����äѤꡢ��ʸ�ڤ����ɤߤ򤹤�󤸤�ʤ���? ���������
reference �ΤȤ��Ƥʤ��ѿ���狼�뤷��

Wed Jul 23 16:21:12 JST 2003

��äѤ깽¤�ΤΥ�����̾����name table�ˤ�����������͡�
�ޤ�������ʤ��㤤���ʤ�������ɤ����ɤ�����?
�ɤ�����äƤ��äƤ�...

Thu Jul 31 15:07:08 JST 2003

C �����Ѵ����������ɤ�ư�������ɡ��ޤ���cast ��ư���Τ�
�ɤ�������ɡ����������Τ���ʤ��ơ�link ��Ȥä��Ѵ�
�Ǥ⤤���󤸤�ʤ�? ��������С�spagety stack �Ǥ�Ok
���ʡ�������GC ���ʤ��ȻȤ�ʪ�ˤʤ�ʤ�����������

Link �ˤ���С�������Τ����Ѵ����ǽ����͡�������union
�ϰ�̣�ʤ�����record ����ľ���ʤ��Ȥ͡�

recursion �� loop ��detect �����static ��compile
�Ǥ��롣���뤤�ϡ�recursion ����ʬ��������ˤǤ���
�󤸤�ʤ����ʡ�

���줾��������ȷ�����ͻ������CW���̤�󤸤�ʤ�?
(�ܵ�?)

Mon Aug  4 12:48:40 JST 2003

converted call
480
8.070u 0.010s 0:08.22 98.2%     0+0k 0+2io 0pf+0w
call
480
6.590u 0.000s 0:06.67 98.8%     0+0k 0+0io 0pf+0w

��������10%���餤�٤��ʤ���(�ʤ��?) ����-O6 ���Ƚ��ܰ㤦...

����powerpc �� subroutine ���static���̤�󤸤��

���֥롼������ʤ�ľ���ޤ�����

% time ./a.out 0
720
9.590u 0.010s 0:09.64 99.5%     0+0k 0+0io 0pf+0w
% time ./a.out 1
719
12.610u 0.020s 0:12.71 99.3%    0+0k 0+0io 0pf+0w
% time ./a.out 2
720
6.310u 0.020s 0:06.41 98.7%     0+0k 0+0io 0pf+0w
% vi test/conv1.c
% gcc -O6 test/conv1.c
% ./a.out 0
720
% time ./a.out 0
720
1.990u 0.020s 0:02.03 99.0%     0+0k 0+2io 0pf+0w
% gcc  test/conv1.c
% time ./a.out 0
720
7.530u 0.000s 0:07.64 98.5%     0+0k 0+0io 0pf+0w
% gcc -O2 test/conv1.c
% time ./a.out 0
720
3.520u 0.010s 0:03.55 99.4%     0+0k 0+0io 0pf+0w
% 

�ޡ�����ʤ�Τ��ʡ�-O2 ���餱��ʤ�äƵ��⤹�뤬��

��40Mbps

Intel PC (on PowerPC) ��

[root@localhost ~/device]# time ./a.out 2                                       
470                                                                             
0.660u 0.010s 0:02.37 28.2%     0+0k 0+0io 92pf+0w                              
[root@localhost ~/device]# time ./a.out 3                                       
720                                                                             
0.920u 0.020s 0:01.74 54.0%     0+0k 0+0io 92pf+0w                              
[root@localhost ~/device]# gcc test/conv1.c                                     
[root@localhost ~/device]# ./a.out 0                                            
                                                                                
[root@localhost ~/device]# time ./a.out 0                                       
720                                                                             
1.310u 0.030s 0:01.39 96.4%     0+0k 0+0io 92pf+0w                              
[root@localhost ~/device]# gcc -O test/conv1.c                                  
[root@localhost ~/device]# time ./a.out 0                                       
720                                                                             
1.130u 0.030s 0:01.16 100.0%    0+0k 0+0io 92pf+0w                              
[root@localhost ~/device]# gcc -O4 test/conv1.c                                 
[root@localhost ~/device]# time ./a.out 0                                       
720                                                                             
0.870u 0.000s 0:00.87 100.0%    0+0k 0+0io 92pf+0w                              
[root@localhost ~/device]# gcc -O6 test/conv1.c                                 
[root@localhost ~/device]# time ./a.out 0                                       
720                                                                             
0.850u 0.020s 0:00.88 98.8%     0+0k 0+0io 92pf+0w                              
[root@localhost ~/device]#                                                      

PowerPC �ξ��ϡ�PIC symbol ����äѤ��٤��͡�
�����Ĥ�ʤ�Ȥ���������Ǥ����ְ㤦�����Τ�ʤ���

Tue Aug  5 13:53:43 JST 2003

�ࡢ�ʤ󤫡��⤦�������ʤäƤ뤸���

�ؿ�scope ��� static�ν�������̤�ʤ���Ǥ����ɡ�

ľ��ޤ������б����Ƥʤ��ä��ߤ����͡�

Wed Aug  6 12:07:07 JST 2003

[kono@pw001 ~/device]% ./mc -s test/conv1.c
[kono@pw001 ~/device]% gcc test/conv1.s
[kono@pw001 ~/device]% time ./a.out 1
�������ȥ��顼 (core����Ϥ��ޤ���)
0.000u 0.000s 0:00.00 0.0%      0+0k 0+0io 73pf+0w
[kono@pw001 ~/device]% time ./a.out 2
470
0.350u 0.000s 0:00.35 100.0%    0+0k 0+0io 88pf+0w
[kono@pw001 ~/device]% time ./a.out 0
720
0.650u 0.010s 0:00.65 101.5%    0+0k 0+0io 88pf+0w
[kono@pw001 ~/device]% time ./a.out 1
�������ȥ��顼 (core����Ϥ��ޤ���)
0.000u 0.000s 0:00.00 0.0%      0+0k 0+0io 73pf+0w
[kono@pw001 ~/device]% time ./a.out 2
470
0.350u 0.000s 0:00.35 100.0%    0+0k 0+0io 88pf+0w
[kono@pw001 ~/device]% time ./a.out 3
720
0.380u 0.000s 0:00.38 100.0%    0+0k 0+0io 88pf+0w
[kono@pw001 ~/device]% time ./a.out 4
0.000u 0.000s 0:00.00 0.0%      0+0k 0+0io 77pf+0w
[kono@pw001 ~/device]% time ./a.out 0
720
0.660u 0.000s 0:00.65 101.5%    0+0k 0+0io 88pf+0w
[kono@pw001 ~/device]% time ./a.out 1
�������ȥ��顼 (core����Ϥ��ޤ���)
0.010u 0.000s 0:00.00 0.0%      0+0k 0+0io 73pf+0w
[kono@pw001 ~/device]% time ./a.out 2
470
0.350u 0.010s 0:00.35 102.8%    0+0k 0+0io 88pf+0w
[kono@pw001 ~/device]% time ./a.out 3
720
0.390u 0.000s 0:00.38 102.6%    0+0k 0+0io 88pf+0w
[kono@pw001 ~/device]% time ./a.out 4
0.000u 0.000s 0:00.00 0.0%      0+0k 0+0io 77pf+0w
[kono@pw001 ~/device]% gcc test/conv1.c
[kono@pw001 ~/device]% time ./a.out 1
0.000u 0.000s 0:00.00 0.0%      0+0k 0+0io 77pf+0w
[kono@pw001 ~/device]% time ./a.out 0
720
0.430u 0.000s 0:00.42 102.3%    0+0k 0+0io 88pf+0w
[kono@pw001 ~/device]% gcc -O test/conv1.c
[kono@pw001 ~/device]% time ./a.out 0
720
0.370u 0.000s 0:00.36 102.7%    0+0k 0+0io 88pf+0w
[kono@pw001 ~/device]% gcc -O2 test/conv1.c
[kono@pw001 ~/device]% time ./a.out 0
720
0.370u 0.000s 0:00.37 100.0%    0+0k 0+0io 88pf+0w
[kono@pw001 ~/device]% gcc -O6 test/conv1.c
[kono@pw001 ~/device]% time ./a.out 0
720
0.240u 0.010s 0:00.25 100.0%    0+0k 0+0io 88pf+0w

Reading specs from /usr/lib/gcc-lib/i386-redhat-linux/2.95.3/specs
gcc version 2.95.3 20010315 (release)
Intel Architecture ���ȡ��빽���ɤ������äƤ���ߤ�����

Thu Aug 14 02:39:29 JST 2003

done
[kono@pw001 ~/device]% time ./a.out 0
720
0.640u 0.000s 0:00.63 101.5%    0+0k 0+0io 88pf+0w
[kono@pw001 ~/device]% time ./a.out 1
719
0.720u 0.000s 0:00.71 101.4%    0+0k 0+0io 88pf+0w
[kono@pw001 ~/device]% time ./a.out 2
470
0.330u 0.000s 0:00.33 100.0%    0+0k 0+0io 88pf+0w
[kono@pw001 ~/device]% time ./a.out 3
720
0.370u 0.010s 0:00.37 102.7%    0+0k 0+0io 88pf+0w


+jessica+kono time ./a.out 0
720
1.190u 0.010s 0:01.51 79.4%     0+0k 0+0io 0pf+0w
+jessica+kono time ./a.out 1
719
1.700u 0.000s 0:01.78 95.5%     0+0k 0+0io 0pf+0w
+jessica+kono time ./a.out 2
470
0.630u 0.000s 0:00.66 95.4%     0+0k 0+0io 0pf+0w
+jessica+kono time ./a.out 3
720
0.790u 0.000s 0:00.81 97.5%     0+0k 0+0io 0pf+0w
+jessica+kono time ./a.out 4
0.000u 0.000s 0:00.00 0.0%      0+0k 0+0io 0pf+0w

+jessica+kono gcc test/conv1.c
+jessica+kono time ./a.out 0
720
0.960u 0.000s 0:00.97 98.9%     0+0k 0+2io 0pf+0w
+jessica+kono gcc -O test/conv1.c
+jessica+kono time ./a.out 0
720
0.470u 0.000s 0:00.48 97.9%     0+0k 0+0io 0pf+0w
+jessica+kono gcc -O6 test/conv1.c
+jessica+kono time ./a.out 0
720
0.260u 0.000s 0:00.26 100.0%    0+0k 0+0io 0pf+0w

Mon Sep  1 13:49:43 JST 2003

short ����äѤ��ߤ�����͡�long long �ϤȤ⤫��...
�����ޤǤ����ȡ�ANSI-C �б��ˤǤ���������long long
���񤷤�?

short �ϡ�����ʤ��񤷤��ʤ��Ϥ������Ȥϡ�
    statement ��ޤ᤿tree�ν���
    �Ѵ��Ϥδ���
������Ĥ��ʡ�GCC ���Ȥ߹���Τ�̵����������

°��ʸˡ�ߤ����ʼ�ˡ���Ȥ���Ф͡�

���ȡ�struct ��tag����äѤ�word table ����ľ���ʤ��ȡ�

Wed Sep 10 21:53:16 JST 2003

short �� unsigned short �����ˡ�
�ʤ� unsigned char ��ʤ���Ǥ����ɡ�

Wed Oct  8 22:43:17 JST 2003

(�ޤ����쥫����äƤʤ��Τ�...)

̵̾ code �Ϥ��ä����������󤸤�ʤ�?

   code *a(int i);
   a  = code(int j) { } 

�ߤ����ʴ���? C �ˤϤʤ����ɤ͡���Ȥ�ȡ�̾������񤹤�
�������餢�ä������������⡣�Ǥ⡢�¹Ի��˺����櫓����ʤ���
����ˡ�����������Τ���� closure ���Ȼפ���褦��
���⤹�롣closure �ߤ����ʤ�Τϡּ�ʬ�Ǵ�������פäƤΤ�
CbC �λ��ۤ���?

���������С�static ��code�Ϥ��ä����������󤸤�ʤ�?

    static code func() { .... }

��������Ϥ������ʡ�

Fri Oct 10 13:08:01 JST 2003

link register �򤦤ޤ��Ȥ��ˤ�continuation��
���ꤹ������Ǥϥ���ǡ�
     goto hoge(....,next);
code next..
�ߤ����ʤΤ����ä����������󤸤�ʤ�?

goto �θ�Υ��ơ��ȥ��Ȥ�̵̾code�ˤʤ�Ф��������͡�

stack ��Ȥ�ʤ����֥롼����ߤ����ʤ�Τ���ñ�ʤ�call
�ˤʤ�櫓�͡�����⤤�����⡣

Sat Nov 22 15:51:36 JST 2003

��¤�Τ�field�������nptr�ϡ�����̾���ơ��֥뤫��
�������ʤ��Ȥ����ʤ����Ǥ⡢�������Ƥ����ޤ��ȡ�
��¤�Τ���Υݥ��󥿤�������㤦�Τǡ��ޤ�����

filed���Ѥ��ΰ����Τ��ȡ�ʣ���ι�¤�Τ�Ʊ��
field̾����ĤȤ��ˤ���äȺ��롣��¤�ΤΥ����פ�
������������������...

��������ȡ���¤�Τ�filed���ɤ�����getsym�������å�
����Ȥ��ˤ���äȺ��롣

filed ��linear search����ΤϷ������ɡ��������ʤ�����

�ʤ󤫡�struct ����ˡ�
    void (*case_)(int cases,int def);
�Ȥ�������ȡ�
    void (*case_)();
    int cases;
    int def;
�Ȥ���������;�פ�field���������Ƥ�ߤ�����

adecl �� nptr �������κǸ��ؤ��Ƥ��ޤ��Τ��ޤ����ä���

Mon Nov 24 00:52:31 JST 2003

signed char �ϼ������ޤ�����... test routine ���ʤ���

���ȡ�short �ϡ�code_crxxxx �����byte���礭���˽��ä�
��������Τ��������ʡ�

Mon Nov 24 10:53:31 JST 2003

short ������������ɡ��ޤ�������ѥ�����̤�ʤ���

�������� stdio.h ���̤��ʤ��ȥ�����͡�(������������������ʤ�...)
�Ȥꤢ������#include <> ��ʤ�Ȥ����ʤ��ȡ�

long long �α黻�ϤȤ⤫�� long long �������ϤǤ�����������
�����Ǥ⡢����ʤ顢��¤�Τ�����Ǥ����󤸤�ʤ�?
   typedef struct { char a[4]; } long long
�ߤ����ʴ���? ����ϤǤ��ʤ���������ѥ��������ǤϤ�������Ȥ���
��⤢�롣

Mon Nov 24 18:59:30 JST 2003

�����󡢤���ʥ��顼�ĤäƤ���Τ���code_cpostint �Ȥ�
�Ϥ��󤼤�Ȥ��ʤ��櫓?

struct { char a[4],a; } ��ľ���ޤ�����

short �ΰ����ΰ����⽤����

Mon Nov 24 22:20:29 JST 2003

Ʊ���쥸�����򤺡��äȻȤ鷺��statement���Ȥ�
���餹�ȡ�����ä�®���ʤ뤫��͡��ɤ��ʤ������?
rename ������㤨�Ф���ޤ�ط��ʤ��Τ����Τ�ʤ����ɡ�

��ĤΥ쥸�������ߤ˻Ȥ��Ȥ����ȡ��ޤ��������Ǥ��͡�

Wed Nov 26 13:27:00 JST 2003

include path ����¢�Τ�Τȡ������Τ�Τ���Ĥ���櫓�͡�

predefined ���빽̵���Ȥ����ʤ��ߤ�����

�ˤ��  inline ��ɬ�ܤʤ�? macro �Ǽ�������Τ��񤷤��󤸤�ʤ����ʤ���
inline �ˤϡ��빽����������Ѥ���ʬ����������ʡ���ö�ϥ���ѥ���
���ʤ��Ȥ����ʤ��Ϥ�������
    inline int f(int a,int b) {
	int c;
        c = a+b;
        return c;
    }
����͡�
    f(3,4)
�����ä����ˤϡ�
    int _c,int _a,int _b; ��local�ѿ����դ��ä���
    _a = 3;
    _b = 4;
    _c = _a+_b;
�򥳥�ѥ��롣
    current register = _c
�Ȥ��롣���ʤ���

�ष����
    c = { decl; statements* return value; }
��������ơ�#define ���ĥ����
������ñ����ʤ�? ���Τ���ˤ� nest ����decl �򰷤�ʤ���
���������...

���䡢��äѤꡢ����ڤ�ʤ�Ȥ�����Τ��ʤ���

�Ȥꤢ������̵�롣���̤δؿ�(static)�Ȥ���compile���롣

��äѤꡢlong long �Ϥ���Τ͡�

��äѤꡢenum �⤤���͡�

�ʤ󤫡��Τ�ʤ����ɡ���äѤ������������ʤ��Ȥ���ʤΤ͡�

���ȡ�const int ���ʡ�

Fri Nov 28 14:01:25 JST 2003

volatile ... (�ʤˤ���Ф����������?)

�ʤ󤫡�*.c �ʳ����ȥ��������񤭤����㤦�󤸤�...
  (�����ľ���ޤ���)

������struct ��tag��type̾����ˤ�����㤦�Τ�...
�����������Ȥ򤵤����ѿ��ơ��֥��ľ���ʤ���ư�����ʤ�...
TYPE_TAG �ߤ����ʥ��ɥۥå��ʤɤ���ľ���ʤ���
�ʤ�Ȥ��ʤ�ʤ����ʤ���

���ȡ�struct ��forward definition �äƤΤ�����ߤ����͡�

#if defined(A) && A �ǡ������ɾ��������㤦�ߤ��������ɡ���
������ȸ����̾����define����Ƥ��ޤ����ա��ࡣ����ʤΤɤ�
��ä��ɤ��Ф������? 

��äѤ�long long ��64bit �ˤ��ʤ��ȥե����륵������
���ʤ���

��äѤ� include �ϡ����Υե�����Τ����꤫���ɤ߹���
�������������

Sat Nov 29 19:01:26 JST 2003

typedef enum {
  ...
        REGS_SAVED_ALL                  /* All registers */
} regs_saved_t;

��äѤꡢ����Τ͡�


void    (*signal ()) (int);

��ư���ʤ��ʤäƤޤ���

Sun Nov 30 05:30:56 JST 2003

�褦��ä� <stdlib.h> ���̤ä���

nkf.c �� while() { int hoge;... } ��ȤäƤ���Τϡ��ѡ�
�ʤ�ǡ������������Ȥ��뤫�ʤ�������򥵥ݡ��Ȥ���Τ�
�Բ�ǽ�ǤϤʤ����ɡ�����������ľ�������롣

�ʤ󤫡��������� n->sc ������������äơ��Ѥ�
���Ȥ������Ƥ���ߤ������͡�

stat �δؿ�̾��tag̾���ŤʤäƤ���ߤ�������äѤ�
tag̾��̾�����֤�櫓�ʤ��Ȥ��ᤫ��...

Sun Nov 30 17:41:04 JST 2003

�ޥ�������Ͽ����Ȥ��ˤϡ������Ȥ�Ȥ�ʤ��Ȥ��ᡣ

while ��slfree �ǥޥ�����chptrsave ���˲�����Ƥ��ޤ���

��äѤꡢnkf.c �ϡ���ȯ�Ǥ�ư���ʤ��ߤ����͡�compile ��
�Ǥ������ɤ���

   >> ������¸ �ƥ��ȥ롼�������äƤʤ��ä�

������K&R�ΰ����ν�����ؿ��ΰ����Ȥ���Ƥ���Ȥ��ϡ�
�ؿ��ν��������ͥ�褷�ʤ��Ȥ����ʤ�... ����������

{
   extern hoge...
}

int
h_conv(f, c2, c1)
    FILE  *f; int    c1, c2;

�ޤ���������������ͤ���

#define hex(c)   (('0'<=c&&c<='9')?(c-'0'):\
     ('A'<=c&&c<='F')?(c-'A'+10):('a'<=c&&c<='f')?(c-'a'+10):0)
fprintf(stderr,"mime_getc h: %d c2 %d c3 %d\n",((hex(c2)<<4) + hex(c3)),c2,c3);
        return ((hex(c2)<<4) + hex(c3));

�դࡣ(?::)+(?::) �ߤ����ʻ��ˤϡ�code-set-fixed-register ��registger
����Ĥ���櫓�͡�push �Ǥ��ʤ���?

    case COND:        /* a?0:1 should consider non-brach instruction */
    case DCOND:
    case FCOND:
        d = (car(e1)==COND?INT:car(e1)==DCOND?DOUBLE:FLOAT);
        e2=fwdlabel();
        if(d==INT) emit_push(); else emit_dpush(d);
        b_expr(cadr(e1),0,e2,0);
        g_expr_u(assign_expr0(stack_top(d),caddr(e1),d,d));
        jmp(e3=fwdlabel());
        fwddef(e2);
        g_expr_u(assign_expr0(stack_top(d),cadddr(e1),d,d));
        fwddef(e3);
        if (d==INT) emit_pop_free(emit_pop(0));
        else emit_dpop_free(emit_dpop(d),d);
        return t;

�ϡ�����ޤ��ɤ��ʤ���register machine �ʤ餤��������ɡ�
�빽���������Ѥ�뤫�顢code-$(ARCH) �˰ܤ��������������ʡ�


�ʤ󤫡�arg_reording() ����
    PowerPC
	   fnptr->dsp = arg_reorder(reverse0(sarg),reverse0(fnptr->dsp));
    IA32
	   fnptr->dsp = arg_reorder(sarg,fnptr->dsp);
�Ȥ������ȤˤʤäƤ���ߤ���������ʤ��������ʤ��Τ͡��ɤ����褦���ʡ�
����ϡ��狼��ޤ�����

    case COND:        /* a?0:1 should consider non-brach instruction */
    case DCOND:
    case FCOND:
        d = (car(e1)==COND?INT:car(e1)==DCOND?DOUBLE:FLOAT);
        e2=fwdlabel();
        b_expr(cadr(e1),0,e2,0);
        g_expr0(caddr(e1));
        t = creg;
        jmp(e3=fwdlabel());
        fwddef(e2);
        g_expr0(cadddr(e1));
        code_set_fixed_creg(t,1,d);
        fwddef(e3);
        return d;

�ʤ�����ɡ�t ��creg����ia32 �Ǥ�virtual register �ʤΤǡ��ѹ������
���Ȥ����롣(���ޤä�������)

COND�ˤ� type �򤤤줿���������ߤ����͡�a?b:c type ��list5����


 void    (*signal ()) (int);

������� signal ����� function ���Ȼפ��롣

   recursive macro
#define stdout stdout

main()
{
   register double d;
   int i = stdout;
   d *= i;           register float �ؤ� assop
   return (int)d;
}

�Ȥ����櫓�ǡ�nkf �� system ��/usr/include/stdio.h ��ư���ޤ�����
�ʤ󤫡����줷����

ptr_cache ��mr �ϳΤ���̵�̤�����... ��α���ƤޤǼ�����
���ͤϤʤ��󤸤�ʤ����ʡ��Ǥ�32bit�ȤäƤ뤫�ʤ�ʤ���
lvar cache �ߤ����ʤ�Τ����򤤤��ɡ��ޤ��������ޤ�
���ʤ顢�쥸�����μ�̿�Ȥ�����Ф��������ʡ�����

Wed Dec  3 13:11:15 JST 2003

����åɤȤ�����
�äƤ������������Ĥ�thread library�Ȥ��ƻȤ��ˤϤɤ�����Ф�����?
    env �� return ����������?

��ʸŪ���̤ˤ����������������ɡ�

Sun Dec 14 16:26:19 JST 2003

long long ����? �任�ϥ��֥롼����ƤӽФ��ߤ�����

float/double ���� long long, unsigned long long �ؤ��Ѵ��⤤��Τ���
    F2LL
    D2LL
    F2ULL
    D2ULL
    LL2F
    LL2D
    ULL2F
    ULL2D
������(���ɤ����������ɤ�)

(�ܵ�? �ɤ줯�餤������? 2-3�����ʤ�...)
     (�ºݤˤ�Ⱦǯ�����ä�...)

getsym �ο����ΰ�����unsinged�Ǥ���٤�����͡�
�ǡ�- �����ä�����overflow �򸡽Ф���Τ��ɤ���ʡ�

���ȡ�strol �Ȥ���overflow�θ��Ф򤵤ܤäƤ�ʡ�

Fri Jan  2 09:53:53 JST 2004

     goto hoge(...,next);
     fuagua....;

�ߤ����ʹ�ʸ�򤤤��? Fortran �ߤ���....
(���)

Sat Jan  3 17:12:46 JST 2004

FEATURE_LONGLONG 
FEATURE_FLOAT

�ߤ����ʴ����� feature ����������ɤ�? ��ǽ�����䤹���� 
�Ȥ��������ɤ��ʤ���������顣

LE�Ȥ�LT�ϡ�GE,GT���֤��������������ɡ�����������ΤȤ��ˤ�
dual_op �����촹�������㤦�Τǡ���äѤ�ɬ�פʤߤ�����

Mon Jan  5 15:55:37 JST 2004

byte code format �Ȥ������ϡ���äѤ�byte code encode
���줿��ʸ�ڤ��ߤ��������͡�

�Ĥ��Ǥ� interpreter ���뤫��byte code interpreter �ǤϤʤ��ơ�
(�ǤϤʤ���?) code ������®��������顢code�������ʤ���¹Ԥ���
�����ɤ��͡���äѤꡢincore compiler ����

inline �ʤ������... #define ���֤���������?
    inline int hoge(int hoga1) { hoge2 }
�ϡ�
    #define hoge(hoga1_0) { 
    #define hoga1 ((int) hoga1_0)
    int hoga1 = hoga1_0; hoge2 }
�Ǥ����櫓����͡��ǡ������ return ������...

�����󡢤���6�Ǥ��ʡ�

inline �ϡ����Τޤ�string�Хåե��ˤ�����ǡ��ؿ��ƤӽФ�����
����������������������

    �����ϡ�#define hoga1 ((int) hoga1_0) ���Ƥ�����
    Ÿ����λ���˸����᤹

�������Ǥ⡢����ѿ����ޤ�������

�Ȥ������Ȥϡ���äѤꡢ���ξ�ǹ�ʸ���Ϥ��Ƥ��ޤ��Τ��ɤ���
    inlined LVAR (ARG)
��ξ����ɬ�ס�tree �Υ��ԡ��ʤ���Ÿ�����뤳�Ȥϲ�ǽ? (�Ǥ�����������...)

�Ȥ������Ȥϡ���äѤꡢ���湽¤�ˤ�node���꿶��٤�����͡�

order 1 compiler  + JIT + intensive optimizer

�Ǥ����͡�

Wed Jan 14 10:21:49 CET 2004

function call�� compiler �γ��˽Ф��ʤ����ʤ���
     code function_interface(args) {
          .....
          push(args); (in asm)
          push(next);
          goto function...
     }
     code function_continuation(args) {
     }
�ߤ����ʴ�����... �ޡ��٤��ʤ����������...

�Ǥ⡢��������С�����ѥ���ΰܿ������Ū��ñ�ˤʤ롣

Thu Jan 15 11:52:03 CET 2004

stack �ϡ�
    system wide �˰�� ( classical environment)
    code �˰�� ( fortran type )
    object �˰�� (like message buffer in ABCL)
�äƤ�������⤢��͡�

Sun Jan 18 11:08:13 JST 2004

(�ʤ󤫡��٤����ʤ�����... CPS �Ѵ���...)

shift/reset ��C�Ǽ�������Τϴ�ñ����...
     reset{
                 shfit();
     }
�ߤ����ʴ���?

stack / data structure ���ݸ����ˡ�ˡ���äȲ���������󤸤�
�ʤ����ʡ�

�ؿ��ƤӽФ��ʤ������...

apply �ߤ����ʤΤ�����Ф���?
    goto apply(function_name,continuation(return_type),args....);
���ʡ��ǡ�������ʬ��C/asm �ǽ񤯤Ȥ����櫓�͡�
�ޡ�����ʤ��褦�ʤ�Τ���(����?) ������ʬ���� interpreter Ū��
�ʤä��㤦�ʡ�varargs �Ǥ⤤���������...

����ѥ����CbC�ǽ񤯤ȸ�����Ȥ��ĤäƤ��������...

������äѤꡢlong long �ϡ���... �Ǥ����?


Mon Apr  5 00:20:13 JST 2004

�ְ㤨��3��ʬ�ä�����ä�����

int �Ǥ� RLVAR �Ȥ��� unsigned/singned �ζ��̤��ʤ��Ȥޤ�����͡�

���Ū�ʥƥ��ȥ롼���󤬤��ä�����������long.c ��ä�����ä�����

Fri Apr  9 02:11:42 JST 2004

��äѤ� incore compiler �ȡ�non textural syntax ���ߤ�����
�ޡ���������͡�

���ȡ�#include �� search path �Υ��ޥ�ƥ�������ľ���ʤ��ȡ�

Mon Apr 12 12:19:35 JST 2004

3461        if (!integral(t=cadr(type))&&
3462                    !(t==FLOAT||t==DOUBLE) &&
3463                    !(t==LONGLONG||t==ULONGLONG) &&
3464                    (car(t)==STRUCT||car(t)==UNION)) {

����ʤ��ơ�t>0 && (car(t)==STRUCT||car(t)==UNION)) {
����ʤ���?


Wed Apr 14 14:26:04 JST 2004

creg �ʤ�����ɡ�ľ�ܥ쥸�����������Τ��ȡ�ʣ���쥸������
�Ȥä� double / long �򰷤��פäƤΤ���ꤺ�餤�������顢
register �ѿ��������Τ������󤸤�ʤ�? �Ǥ⡢���������
�ѹ���¿���ʤ뤱��...

free_register �δط������뤫�顢��äѤꡢ�����Ѥ��ʤ���
������͡�

creg/freg ��ߤ᤿�Τϡ�MIPS�� float/double ����̤���
ɬ�פ����뤿�ᡣ���λ��ˡ�creg ��¤�β�����٤����ä�
�ߤ������͡�
      creg = { ireg, freg, dreg }
�ߤ����ˤ��Ƥ��ɤ��ä��櫓����

�⤷�����ơ�regv �äƻȤäƤʤ���? (��������...)

register �� list �ǻ���? ����ˤ����?
      regs[0] = glist4(LREGISTER,use,r1,r2)
      regs[0] = glist3(REGISTER,use,r1)
�ߤ����ʴ���? ������... ������ϡ�
      ireg_list
      dreg_list
      freg_list
      lreg_list
���ʡ��Ǥ���? �ճ��ˤ��ɤ�������ptr cache �Υ����ɤ⤢�뤷��

�ޤ���conservative �ˤ�������

lreg �ϡ��Ѷ�Ū�˲������ʤ��Ȥޤ������ɡ��ɤΥ����ߥ󥰤�?
�Ȥ�������creg �⤽�Υ����ߥ󥰤Dz��������ɤ��󤸤�ʤ�?
�ա���

gexpr_init() �Υ����ߥ󥰤Dz������Ƥ⤤��������ɡ�������ȡ�
gexpr_0 �Dz��äƤ���Ȥ��˲�������ʤ����ɡ�
     g[long long hoge]
�ߤ����ʾ��Ǥϡ�����Dz��������ߤ������?

use_int �Ȥ��� lreg �ϲ��������ɤ��󤸤�ʤ�?

creg =0 �� free_register(creg) ���ƤФ�Ƥ���͡����ä��ʡ�

Sat Apr 17 17:01:02 JST 2004

long long register �ǡ�regs�� regv �򤽤�����
ɬ�פϤʤ���regs �����̤��Ѱդ��ơ�regv �ǤϤʤ��ơ�
lreg_h��lreg_l�ߤ����ʴ����ˤ��롣

������register full ����������������������ä����ʤ���

Wed Apr 21 17:32:40 JST 2004

unsigned ��cosnt�׻������������󤸤�ʤ�?

Thu Apr 22 12:33:04 JST 2004

�褦��äȡ�int/float ���������ޤ�����

lrexpr �ϡ�codegen �ǡ�long �η׻����֤���������������?
�Ǥ⡢������ȡ�64bit �黻�򥵥ݡ��Ȥ��Ƥ���CPU�����줷��
�ʤ�����

���ȡ��⤦����! �Ǥ⡢2,3�������ꤽ����
loprtc �⡢���ä����������󤸤�ʤ�?  (�ޤ�....)

Fri Apr 23 14:40:02 JST 2004

���Ȥϡ�switch, inline, stdargs, alloca ���ʡ� asm �⤢�뤫��
asm �ϡ�����äȼ�ݤ��鳰��뤫�餤������

PowerPC ��alloca �ϡ���������������������ʡ�

join ������?

a?a,b:a,b �äƵ�������?

"" ����Υޥ�����Ÿ������Ƥ��ޤ���Ǥ����ɡ�(�ޡ������ʤ������)

#hoge ��̵�뤹�뤫�����Τޤޤˤ��뤫...

Sat Apr 24 14:39:14 JST 2004

long long op int, unsigned long long op int/unsigned

�äƤΤ�����Τ�.... ������...

Sun Apr 25 17:20:40 JST 2004

�������ʤ��Τ˥ƥ��ȥ롼���������ʤ衣���� register lassop

compiler ��񤯤ˤ�...
   (1) parser ���
   (2) code ���������
   (3) compiler ��compile ���顼����
   (4) compiler �Υ�����������ǥХå�����
   (5) �������������ɤ�������֥���̤뤫�ɤ�����ľ��
   (6) �������������ɤ����������ɤ�����Ĵ�٤� 
�ǡ�(4) �ޤǤǤ��ޤ�����


��äѤꡢuse_int �Ȥ��äơ��ʤ�Ȥʤ����ᡣ�����
��ͳ�������������ʤ����ۤȤ�ɥХ��Ϥ�������
�������Τ͡�

use_int �Ȥ��ϡ�codegen �Ǥ�ä��󤸤㤤���ʤ��ơ�
��äȤⲼ��code������ʬ�Ǥ��ʤ��Ȥ����ʤ��󤸤�ʤ�?
����Ǥ����Τ�?

������������

creg ���Ф������Фä��ꤸ��ʤ��Τǡ�code_xxxx(xxxx,creg)
�Ȥ����褦�ˤʤäƤ��롣��������ȡ�creg �򤽤γ���
creg = use_int(creg) ����ɬ�פ����롣���͡�

    void
    code_lvar(int e2,int reg) {
	creg = use_int(creg);
	lvar_intro(e2);
	printf("\tla %s,",register_name(reg));
	lvar(e2);
    }

���ȡ�reg ���֤˹��ʤ������٤졣

reg ��creg �ʳ�������Τϡ�����Ū�ˤ� assign_opt �ϤǤ��͡�
����� creg ��ľ���С�������

    void
    code_lvar(int e2,int reg) {
	if (reg==-1) {
	    creg = use_int(creg);
	    reg = creg;
	}
	lvar_intro(e2);
	printf("\tla %s,",register_name(reg));
	lvar(e2);
    }

�ߤ�����?

    #define use_int(reg) if (reg==-1) reg = use_int0(reg)
    void
    code_lvar(int e2,int reg) {
	use_int(reg);
	lvar_intro(e2);
	printf("\tla %s,",register_name(reg));
	lvar(e2);
    }
    use_int0(int reg) {
	creg = ireg;
	return creg;
    }

���ʡ� #define ��? �ޡ��ɤä��Ǥ⤪��ʤ��褦�ʤ�Τ���

�Ǥ⡢������ѹ�¿���ʤ���

Mon Apr 26 05:35:24 JST 2004

�����no long long ���̤ä��ߤ�����������

��¤�Τ����ͤ���ľ��ˡ��������ʤ��Ȥ��ޤ������ʤ���

#include "" �ϡ����ɤ�Ǥ���ե������current directry ��õ����

�ޤ���ia32 �ϡ�eax,edx ��long,long ���Ѥ�ǡ����Ȥϡ�
�Х���Ƿ׻�����櫓�͡������������ʡ��ष����
�䤵�������⡣

��������������long �ΰ������Ϥ����ϡ�
r10 �ϥ쥸�������Ĥ�ϥ��������櫓�͡�

Wed Apr 28 13:01:13 JST 2004

�����֡��̤�ޤ�����ltosop �ϡ����ꡣ

drexpr, lrexpr �� cond ��������Ƥʤ��ä���

��ư�������θ����Ϥɤ����褦��ʤ���? printf ������?

�������ʤ󤫡��ޤ���printf ���ɽ��ѿ�������Ƥ���͡�

���������С��ɽ��ѿ��Υ��饤���ȤϹ�碌�Ƥʤ����ɤ�����?

unsigned �äơ��⤷�����ơ��⤦�����롼�뤬ʣ��?
              /   %   <<   >
    I op I    I   I   I    I 
    I op U    I   I   I    I
    U op I    I   I   U    I
    U op U    U   U   U    U
�Ǥ�ʤ�����

�ʤ󤫡���������ľ������ˡ��ʤ�Ǥʤ��ʡ�

code_bool ��jmp��Ȥ��ΤϤ����ˤ�ޤ�����͡������ͤ���

��������float/double printf("%d",f0>f1) �ο����ͤ�����ȿž����
�Х������ʤ���

code-gen.c ������ư��������float.c ���������ᡣ
�ʤ󤫡��ޤ�ǤǤ�����ư���Ƥ���ߤ���....

function() ����ǡ�lreg ��input register�ȽŤʤäƤ��ޤ���

Thu Apr 29 19:40:08 JST 2004

�ɤ��狼��ʤ������̤ä���

Sun May  2 09:40:21 JST 2004

��äѤ� LREGISTER �ʤ�ƺ��󤸤�ʤ��ä���code_lconst
�Ȥ��� edx,eda �� dsi,edi pair �����ؤ�����ʤ��ȡ�

Thu May  6 08:33:23 JST 2004

ia32, powerpc �Ȥ� long long �ޤǡ��̤�ޤ�����ia32 ��콵��
�����ä��������ϡ�MIPS, ARM �Ǥ��ʡ�

����ѿ�+���ե��å� ( heap[3] �ߤ����ʤ�) �ǡ�
heap+24  �Ȥ��Фʤ�����Ȥ�Ȥ� offset,y ���ä�����
����ʤ��ä�������ɤ͡�

�ߴ�����ΤƤƤ��ޤ��С�����ѿ��ݥ��󥿤�Ƴ�����Ƥ�
����������ɡ�������32bit �ʾ�Υ��ե��åȤ���RISC
̿����Ȥޤ�����
 
���֥������Ȼظ����Ȥ��Τ�����ϲ�褹�������ɤ͡�

longlong/float ��regression�Ϥ���������ɡ��⤦����
�����������ä�������������͡�

�ʤ󤫡�Linux ��include directory �äơ��ɤ��ˤ��ʤ�ʤ���?

assop �ǡ�
    calc left exp
    move creg,dreg
    move const,creg
    op  creg,(dreg)
�äơ���äƤ���Τʤ��Ѥ���ʤ�?

a && b �ǡ�b ��bool��׻����Ƥ���Τ��ѡ�use �Υե饰
�򸫤�Τ��ɲä����顣


Sat May  8 21:29:32 JST 2004

��ư��������long long��������Ʊ���ͤϰ�ĤˤޤȤ��٤�����͡�
Ϣ�� list ���Ļ��Ƥ��ɤ�����������

string ��ޤȤ�뤫�ɤ����ϡ�const ���ɤ����ˤ��櫓����...

RETURN register ������ν��������������ޡ����礦���ʤ�����

MIPS ��debug�ˤ����������ɡ����ϻ�����������ʡ��ʤ�ǡ�
��ä��᤯�Ǥ��ʤ��ä��Τ���gcc modification �Ϥɤ�����?

������ register �� 0 �����äƤʤ��Ȥ���ΤϤޤ����ä�
���äƤ���Τ�...

float �� normal register ���Ѥ�Τ���

        s.s     $f4,16($sp)
        mov.s   $f12,$f0
        mov.s   $f14,$f1
        mfc1    $6,$f2
        mfc1    $7,$f3
        jal     f

�ޡ�����������ɤ���(�Ǥ⡢�ʤ��$4,$5 ��Ȥ�ʤ����?)

long long ��4,5,6,7 �����쥸�������Ѥޤʤ����ޡ���������ɡ�

�����쥸�����Υ����֤äƼ�ʬ�Ǥ��Τ���(���㡢mask �äƤʤ�
����...) �äƤ��Ȥ�entry �Ϥ��Ȥǽ��Ϥ��ʤ��Ȥ�����͡�

�ޤ������������ä��ʤ�����... �٤������顼���ĤäƤ���ʡ�

��äѤ� codegen �γ�ĥˡ���äƤ����ʤ��ȥ�����͡�

�ؿ��ƤӽФ��ѡ��Ȥ�CbC���Ȥǽ񤱤ʤ��Τ��ʤ���
���ޤ�ˤ��ɤ���������

cpload �ϡ�gp �쥸�����ν����˴ط�����餷����gp �쥸�����äƲ�?
cploat $25 �� $25 �ϡ�stack offset �ߤ����͡�$sp ���ѹ�����Ȥ��ˡ�
�ʤ󤫤Υե饰������ʤ��褦�ˤ��뤿��ν����ߤ�����

���Ȥ���С�code segement ¦��stack�����ˤ˰�ư����ΤϤޤ���?

float/double �Υե����� mc-parse �Ǥϡ�����������������ߤ�����

�ϡ��ɤ��Ȥ���....

    cprestore, mask �η׻�
    offset �ι�碌

�������ư����? �������?

������ 
    int endian;
    extern int endian;
���̤�ɬ�פ�����Τ͡��ޤ����ե饰�ΰ�������������....

Thu May 13 12:58:58 JST 2004

 .frame �ο����ˤ� input variable ��saveʬ������󤸤�ʤ���?

   code_l1 ��  ll0 �����������ʤ�Τϡ�strtoll ��int���������Ƥ뤫�顣

function ��argument��ʣ���ʤ�Τ���׻����ƹԤ��Τ��롼��ʤΤ͡�
�ޡ���������ʡ��Ǥ��ʤ����ȤϤʤ�....

�����ʤΤ����ǽ�˥롼�פ������ʣ���ʤ�Τ�쥸�����ʤ��ѿ��ʤ�
���������ơ������ꥹ�Ȥ��֤������Ƥ��ޤ����ɤ����Ĥ��Ǥˡ�
��������٤��ѿ��Ϥ����Ƿ׻����Ƥ�����... (�äơ�����äơ�
parallel_assignment �Ǥ�äƤ��뤳�Ȥ�Ʊ����)

������ʬ��codegen �Ǥ�äƤ⤤���������... ia32 �Τ褦�ʾ���
�ष�����פʤΤ���

�Ǥ⡢��äѤꡢ�ճ���ʣ�����衣struct ��ɤ����뤫�Ȥ�����

struct �ϡ�call memmove ���������ɡ������Ĥ���ˤ��櫓�ˤ�
�����ʤ�����ˤ��ȡ����δ֤�function call�������Ƥ��ޤ���
��˻��ä��ɤ��ȡ�input register �������Τǡ���äѤꡢ
���̰�������ɬ�פ����롣�äƤ��Ȥ�...
    complex function argument
    struct copy
    simple arguments
�äƤ������֤Ǥ����ɤ��äƤ��Ȥ�.... ������

(�����󡢤Ǥ�ʤ�������?)

function argument �η׻��ǡ�long long register ���˲������Τϡ�
�ʤ���ˡ�������󤸤�ʤ���? ���衢lreg �����Ϥ��Ǥ���٤�����͡�
�ޤ��ͤ���

ʣ���ʤ�Τ���׻����������ɤ��äƤ��Ȥϡ������å����Ѥ�
��������׻����������ɤ��äƤ��Ȥ���

�ޡ�����ϤǤ����Ȥ���...

Sat May 15 22:45:30 JST 2004

��ɡ�.cprestore �ϡ��ǽ�ˤʤ��Ȥ����ʤ��Τǡ�include ��
�Ȥ������ʤ��餷����

add.s ����ư�������쥸��������������ʤ����ɡ�

Sun May 16 13:58:42 JST 2004

����ϥ쥸������save���͡��Ȥä��쥸�����ϥ����������θ��
�����狼��ʤ��Τǡ�������jmp ����Ф���������ɡ��ɤ��
����?

	subu    $sp,$sp,$L_r1_offset
        .cprestroe
        sw      $fp,$L_r1_offset-16($sp)
        sw      $31,$L_r1_offset-160($sp)
	addu    $fp,$sp,$L_r1_offset
	jal    $L_save-$L_save_label*4
	addu    $fp,$fp,$L_fregister_save
	jal    $L_fsave-$L_fsave_label*4
        move   $fp,$sp

 ...
        sw      $17,-12($fp)
        sw      $16,-8($fp)
$L_save:
        j       $31
...
        s.s      $f22,-16($fp)
        s.s      $f21,-12($fp)
        s.s      $f20,-8($fp)
$L_fsave:
        j       $31

�ߤ����ʴ����ˤ���? ����ȡ�ɬ��$31��save���뤳�Ȥˤʤ뤱�ɡ�
noreorder ���ʤ��Ȥ��ᤫ�⡣

������������ѥ��Ȥ����ɡ�
	subu    $sp,$sp,$L_r1_offset
        .cprestroe
        sw      $fp,$_Lr1_offset-16($sp)
        sw      $31,$_Lr1_offset-160($sp)
	j      $L_save
$L_fsave_0:
        move   $fp,$sp

 ...
$L_save:
       ...
        sw      $17,-12($sp)
        sw      $16,-8($sp)
        s.s      $f22,-16($sp)
        s.s      $f21,-12($sp)
        s.s      $f20,-8($sp)
        j       $L_save_0

�������������ʡ�save ����ɬ�פ��ʤ���С�
	j      $L_save
$L_save_0:
        move   $fp,$sp

$L_save = $L_fsave_0

�ȤǤ��뤷��

ξ����äơ����ַפ�?

�ޤ������Ԥ������ŤäƤ��뤷��̿���Ū�ˤ��Ѥ��ʤ����顢
space factor Ū�����Ԥ�����®���󤸤�ʤ���?

�Ǥ��Ԥ�������ñ����ʡ�

Mon May 17 01:09:02 JST 2004

���ơ�������֥���̤�褦�ˤʤ�ޤ�����...

�ɤ��⡢$0,$1���ФƤ��ޤ���礬����ߤ���������򸡽Ф���
���ʤ��ä������ɤ��͡�

���ȡ�int �θ��double/longlong �ϡ�$3 �Τ��ȡ�$5,$6 ��
���ߤ����Ǥ��͡�

���ơ����褤�衢���ե��åȹ�碌����

Tue May 18 13:05:24 JST 2004

�ʤ󤫥쥸���������֤��ܤ��ܤ������max_reg_var �Ȥ�����
�����ȥ쥸�����θĿ���ɽ���褦�ˤ����衣

Wed May 19 13:49:40 JST 2004

endian �˴ؤ��륳���ɤϡ������ȥ������ˤ����񤤤������ɤ��͡�

�䤡���ʤ�Endian�����ʤ��衣���󤼤�

printf �� $6,$7 ��Ʊ���ͤ��Ϥ��Ƥ���Τˡ�

    diff test/code-gen-all.gcc.out test/code-gen-all.mc-mips.out
    53,54c53,54
    < code_lrindirect ffffffffffffffc9 37 c8 80
    < code_lrindirect -55 55 200 128
    ---
    > code_lrindirect 37ffffffc9 37 c8 80
    > code_lrindirect 240518168521 55 200 128

�Ȥʤ�ΤϤʤ�Ǥ�����? 37 �� overwrite ����Ƥ���Τ���
�Ǥ⡢37�Υݥ������������������ʡ�37���Τϥ쥸�����ˤ�
��äƤʤ�����

Wed May 19 22:15:33 JST 2004

�����������󤬤�Х��ϼ��Ƥ����櫓�����ɡ��ʤ󤫡�
��̯�ˤ櫓�狼��ʤ��Х����ĤäƤ���ʡ�

MIPS�ä�const �Τ������ʤ������͡����ä��顢*4���餤
��shift���������ɤ����⡣

Thu May 20 21:46:17 JST 2004

register_dassop ��ƥ��Ȥ��Ƥʤ��ơ������ɤ�ְ�äƤ롣

chptrsave �ʤ�����ɡ�
     case hoge:
     macro_replace()
�ǡ�case hoge: ����λ����ȡ�getsym�����ɤߤǡ�macro_replace
��Ÿ�����ơ������� lfree ( chptrsave = list2(hoge,chptrsave) )�˾�äƤ��ޤ���
docase �ǡ�lfree = slfree ����ȡ�����list2 ���˲�����Ƥ��ޤ���
�Ĥޤꡢslfree=lfree;.... getsym  ...; lfree=slfree �ϡ��������ʤ���
�ʤΤǡ�list2 ����ʤ��ơ�glist2 ���ơ�free_glist2 ���Ƥ��褦�ˤ��롣

�Ǥ⡢���⤽�⡢macro_buffer �ϡ��ɤ��ʤ�? �����ΰ�Ϻ����Ѥ����Τ�?
�����Ǥʤ��ȵ����macro��񤫤줿�Ȥ��˵��ޤ�����cheap �ϡ�malloc
���Ƥ⤤���󤸤�ʤ����ʤ���

code-gen-all.c �� simp1.c ���̤ä�������ɡ�basic.c ����̯��
�̤�ʤ����ʤ�Ǥ��ʡ�diff ��͡�

Fri May 21 13:09:10 JST 2004

switch �ʤ�����ɡ�long long ���̤��������͡�

�ʤ��ʤ�self compile���̤�ʤ��ʡ����٤ϡ�getsym ������äѤꡢ$gp
��Ϣ?

����ʸ�η��������ͤη��ˤʤäƤ���������ʥХ������ޤ���
�ĤäƤ����Ȥϡ�

double register �ν������ʤ���dead lock ����ʡ�

�����ȡ�double register ��conflict ���ޤ���ʤ���
�������� function �Ǥϵ����ʤ��餷����...
�Ȥ������Ȥϡ�set_[dl]operand �����꤫��

��äѤ� register parallel assign ��񤯤Τ���ñ����͡�

slt/beq �äƤΤ������ޤ�ư���Ƥʤ��ߤ����͡�


Sat May 22 12:49:55 JST 2004

�ʤ󤫹�¤�Τ���Ƭ�ϥ쥸�������֤��ߤ�����... �������ɡ�
$5,$6,$7 ����

continuation frame �ϡ�$sp=$fp �ˤ����? �ؿ�������
$fp���Ѥ�Ǥ��뤫�顢��������ɬ�פ�����櫓�����ɡ�
���������$fp �����ư�����ʤ��Ȥ����ʤ������͡�
�ޤ���PowerPC�Ǥ⡢�������Ƥ���櫓�����ɡ�

jal ��� $gp ����᤹�櫓�����ɡ����Υ��ɥ쥹��
��ޤäƤ��뤷����󥻡��֤���ɬ�פ�ʤ����ɡ�
$sp ���Ф��Ȥޤ����ʤ���

fmask,mask �Ȥ����פ�ʤ��󤸤�ʤ���? ���⤽��
�ʤ�Ǥ���������?

(gdb) x/20i carg1
0x400a80 <carg1>:       lui     $gp,0xfc0
0x400a84 <carg1+4>:     addiu   $gp,$gp,30128
0x400a88 <carg1+8>:     addu    $gp,$gp,$t9
0x400a8c <carg1+12>:    addiu   $sp,$sp,-144
0x400a90 <carg1+16>:    sw      $gp,32($sp)
0x400a94 <carg1+20>:    move    $s8,$sp
0x400a98 <carg1+24>:    sw      $s2,16($s8)
0x400a9c <carg1+28>:    sw      $s1,20($s8)
0x400aa0 <carg1+32>:    lw      $t3,-32692($gp)
0x400aa4 <carg1+36>:    lw      $a0,0($t3)
0x400aa8 <carg1+40>:    lui     $t2,0xf000

�Ȥ����褦�� .cp ��Ϣ���Ѵ�����롣�����ϼ�ʬ�Ǥ�ä�
�����ɤ�������ɡ�

�֥����� jal �ߤ����ˤ��Ѵ�����ʤ��Τ����ޤ���?

0x400b00 <carg1+128>:   move    $a1,$s5
0x400b04 <carg1+132>:   move    $a2,$s4
0x400b08 <carg1+136>:   move    $a3,$s3
0x400b0c <carg1+140>:   lw      $t9,-32664($gp)
0x400b10 <carg1+144>:   jalr    $t9
0x400b14 <carg1+148>:   nop
0x400b18 <carg1+152>:   lw      $gp,32($s8)

��äѤ� sp ���Ф� $gp �ϥ����֤����Τ���jalr ��
��ʬ���������������¿�����

  *.i �������Τ��ɤ����� .include ��
�ե�����̾������롣���ϥե���������Ф���
 .i ����٤���

a.c b.c �Τ褦�ˤĤʤ���Ȼߤޤ�ʤ��ʤ롣(-D�Υ롼�פ�?)

�빽����ӤΥХ����ĤäƤ��뤸��������Ӥ�embug��������͡�

long long ����Ӥ� int ����Ӥ��������ѥ롼������ä�����
�ɤ��ʤ�?

�Ĥ������ޤä����ְ�äƤޤ�����

Sun May 23 17:10:59 JST 2004

��ä�MIPS���ž�ä��衣�ޤ���code jump �ϡ��Ǥ��Ƥʤ����ɡ�

���⤽�� external jump���Ǥ��뤫�ɤ���Ĵ�٤Ƥʤ��ʡ�

slt $r1,$r2,12 �ߤ����ʥ����ɤ�Ф�������...

parallel_rassign �ä� target=soruce ��̵�¥롼�פ��ʤ�?

Sun May 23 21:21:22 JST 2004

��äѤꡢboolean �ΰ������ʤ���jmp�Ǥʤ������ɤ���͡�

Mon May 24 07:11:57 JST 2004

�ؿ��ƤӽФ��ΰ����ϡ���äѤ�$sp���ե��åȤ��Ѥ�٤��Ǥ��礦��
�Ǥʤ��ȡ�$fp!=$sp �λ��ˤ��������ʤ롣($s8=$fp)

code ��������ѿ����ɤ�ʤ���

0x401170 <main1>:       lui     $gp,0xfc0
0x401174 <main1+4>:     addiu   $gp,$gp,28352
0x401178 <main1+8>:     addu    $gp,$gp,$t9
0x40117c <main1+12>:    addiu   $sp,$sp,-144
0x401180 <main1+16>:    sw      $gp,16($sp)
0x401184 <main1+20>:    sw      $ra,136($sp)
0x401188 <main1+24>:    b       0x401234 <main1+196>
0x40118c <main1+28>:    sw      $s8,132($sp)
0x401190 <main1+32>:    move    $s8,$sp

0x400aa0 <carg1>:       lui     $gp,0xfc0
0x400aa4 <carg1+4>:     addiu   $gp,$gp,30096
0x400aa8 <carg1+8>:     addu    $gp,$gp,$t9
0x400aac <carg1+12>:    addiu   $sp,$sp,-144
0x400ab0 <carg1+16>:    sw      $gp,32($sp)
0x400ab4 <carg1+20>:    move    $s8,$sp

�Ǥ�����$t9 �äƤʤ������?

0x401290 <main+48>:     lw      $t9,-32744($gp)
0x401294 <main+52>:     addiu   $t9,$t9,4464
0x401298 <main+56>:     jalr    $t9
0x40129c <main+60>:     nop
0x4012a0 <main+64>:     lw      $gp,16($s8)

���줫���äƤ��Ȥϡ�����Ƥ����̤ꡢ
    printf("\tj %s\n",s);
�ǤϤ���ʤΤ͡�

$t8 �ϡ�$25 �äƤ��Ȥϡ�$t9 ��$26? jmp��ߤ������͡� $jp?
cpload $25 ��$25 ����ʤ���? ���㤡��
        jrn = register_name(cadr(jmp));
        printf("\tmove $25,%s\n",jrn);
        printf("\tjal\t$31,$25\n");
����Ф����Τ���?

.ent ���ʤ��äƤ�����⤢�뤱��... ���������ä��褿����
�ɤ�����? (���⤽�⡢code �äơ�������ƤӽФ����?)

    printf("\tla $25,%s\n",s);
    printf("\tj\t$25\n");

�Ǥ����ߤ������͡�
    1,9d0
    < arg1: 0 1 2 3 4 : 1 1
    < arg1: 1 2 3 4 0 : 1 1
    < args: 1 2 3 4 0 : 1 1
    < 321=0
    < args3: 11 22 33 44 55 : 1 2 3 4
    < args4: 11 22 33 44 55 : 2 3 4 1
    < args5: 66 77 88 99 10 : 3 4 1 2
    < args6: 66 77 88 99 10 : 3 4 1 2
    < args3: 66 77 88 99 10 : 3 4 1 2
    make: [check-code] Error 1 (ignored)
    +pstwo1+kono ./a.out
    arg1: 0 1 2 3 4 : 0 0
    arg1: 1 2 3 4 0 : 0 0
    args: 0 263785888 4200109 2712942 0 : 0 0
    Segmentation fault
�ޡ�������������͡�


0x401180 <main1+16>:    sw      $gp,16($sp)

0x401298 <main+56>:     jalr    $t9
0x40129c <main+60>:     nop
0x4012a0 <main+64>:     lw      $gp,16($s8)

���ΰ�Ӥ��ʤ��Τ��Ƥ�....  $sp!=$fp �ˤ���ȡ�$gp �������
���ޤ���call ������ $fp=$sp �ˤ���Ȥ�����⤢�뤬....

��ɡ���ʬ�ǡ�
     lw      $gp,16($sp)
����ΤDz�衣

Mon May 24 13:26:54 JST 2004

MIPS �� jump �ϡ��Ǥ��ޤ�����MIPS��R1SAVE���ʤ��Τ͡�R1SAVE 
�������㴳�����ʵ��⤹�뤬������֤�����ΤϤ��������ʤ���
�͡�

leave �ǡ�control ��ɬ�� on �ˤʤ�Τϲ���?

���ϡ���äѤꡢc2cbc �Ǥ��礦��

(float) f == 1.0  �� double ���Ѵ����Ƥ���ʡ�

register oprtc ����
        move $4,$20
        addu $4,$4,16
        move $20,$4
�Ȥ��ʤ�Τ��ᤷ���ʤ�?

Tue May 25 05:14:30 JST 2004

indirect jump �ǡ�$25 ���������������ɡ�
����˲�����ɬ�� simple �ˤʤ뤫�顢�����Ǥ�
$25 ��ľ�������Ǥ���͡�move ��ĸ�����������ɡ�

pcond �ϡ�pcond_const ����Ĥ٤���

cmp/jcond �ϡ���Ĥǽ������������ɤ���switch ʸ�� bne $6,1,$L_11 
�Ȥ��Ǥ��������ɤ���͡�

struct proto tcp_prot = {
        .name           =       "TCP",
        .close          =       tcp_close,
        .connect        =       tcp_v4_connect,
        .disconnect     =       tcp_disconnect,
        .accept         =       tcp_accept,
        .ioctl          =       tcp_ioctl,
        .init           =       tcp_v4_init_sock,

�ϡ���������͡����ä�����������ʡ�(����ʤ��񤷤��ʤ���)
��������ö�����ꥹ�Ȥˤ��ʤ��ȳ�Ǽ�Ǥ��ʤ��������ߤ�������
�ɤ��ʤ�������? ʸ������Ф�����?

��äѤꡢ�񤷤��󤸤�ʤ����ʤ�������äơ����ξ��emit_data/
decl_data �Ǥ��ʤ���͡�local �ξ���assign ����˥���ѥ�
�뤹�뤳�ȤϤǤ��������ɡ�global �ϡ�assign_data �ǡ��ʤ�
���Υ��塼������뤫��mode �����䤹�櫓�͡�

decl_data ����Ƭ��getsym����ΤϤޤ����櫓�͡�
            while(t1) {
                offset = decl_data(car(t1),n,offset);  /* alignment? */
                ....
            }
������ˡ�

    getsym();
    if (SYM==DOT) {
      smode=mode;
      sstlist = stlist;
      stlist = 0;
      if (mode!=LOCAL)
	  mode = SNAMEMODE;
      while(sym!=RC) {
	  type = search_struct_type(..&offset1);
	  decl_data(car(t1),n,offset1);
      }
      if (mode== SNAMEMODE)
	  emit_sname_assign(stlist);  // global?
      offset += sizeof(struct);
      stlist = sstlist;
      mode=smode;
    } else {
      while(t1)
	offset = decl_data(car(t1),n,offset);  /* alignment? */
	....
    }
�ߤ����ʴ���? nest �������ϡ�emit_sname_assign �Ǥ� decl_data
��Ƥ�ǡ����٥��塼������뤷���ʤ�����

Mon May 31 19:08:57 JST 2004

register_assop �ϡ�����������ɡ�register_assop_const ��
�����ɤ��ɤ��ʤ��͡�

Wed Jun  2 13:12:35 JST 2004

rexpr �� value option ���դ��ơ�
   code_bool 
�Ǥϡ�rexpr,drexp ��Ƥ�����������������... && || �Ȥ��ɤ�����
���ʡ�

���������ʤ��Ѥ��������ߥ����ĤäƤ���͡�

Thu Jun  3 13:16:33 JST 2004

code_bool �ϤǤ���������ɡ��ޤ���������­����͡�

code_bool �� !use �λ��ˡ�null branch���Ĥä��㤦����...
�ޡ��������ʤ�����

Fri Jun  4 12:57:28 JST 2004

switch ʸ���������ɡ�

       main() {
           int i=3,j=1,k=0;
           switch(i)  
               for(;j<10;j++) {
                   case 3: k++; case 2: k++; case 1: k++; case 0: k++;
               }
           printf("%d\n",k);
       }

�ʤ�����ɡ�j<10 �ʤɤ�ɾ����������jmp����ɬ�פ�����Τǡ���
���caseʸ��jump���ʤ��Ȥ����ʤ�����jump ����ɬ�פ����뤫��
�����ϡ�switch �μ���ʸ��ºݤ�ɾ�����Ƥߤʤ��Ȥ狼��ʤ���

�ʤΤǡ� checkret() �ǡ����ν�����Ԥ������ɤ���
     if (first_case) {
         jmp(first_case); first_case =0;
     }
���ʡ��⤷�����줬�Ԥ���ʤ顢�������table jump routine �Ǥ���٤���

switch ��ޤȤ��ΤϤ�ä����ɡ������Υ����ɤ���table
�ϡ��ۤȤ�ɤǤʤ��͡�2ʬ�ڤϽФ뤱�ɡ�ID��Ϣ³����褦��
���פ������������Τ��ʡ�

chunk �� merge ��algorithm ������.... O(N^2) ����͡�

     c0,  c1,  c2, ... cn

�ǡ�(�ʤ󤫸������Ȥ���...)

     c0,  c1,  c2, ... cn
     +------------------+ rate
     +---------------+    rate
     +----------+         rate
     +----+               rate
          +-------------+ rate
          +----------+    rate
          +-----+         rate
                   ...

�Ȥ����Τ��롣((n-1)*(n-2)/2) �����ǡ����֡�rate �ι⤤��Τ�
���Τ����������Ȥϸ¤�ʤ�.... rate ����ʤ��ơ�cover Ψ��
�⤤��Τ������ɤ����õ�ˡ���ɤ��ơ��ޤ���

     RATE �ʲ��Τ�Τ�õ�� (�������ʤ�)
     �����ơ�cover Ψ�ι⤤��Τ�Ȥäơ����٤Ƥ���Ԥ���

           +------------+ rate 75%
     +-------++------+    rate 80%

�ߤ����ʤΤ�ɤ����뤫������... �ơ��֥뤬���ʤ�����ͥ��?
�ơ��֥뤬��Ĥ��ɤ��Ȥϸ¤�ʤ���

count ��¿���Τ� delta ���ۤʤ�Ȱ���Ū�ˤϤ��ᡣ

     +-------++---------+ rate 80%
          <------>   �ߤ����ʷ��Ǽ��礦���⤢�롣

���ξ��� cover rate ���Ѥ��ʤ��Τǡ�table rate �Ƿ׻�����?

�����ȡ������������Ƥζ�֤��ȹ礻���������櫓�ǤϤʤ���

     c0,  c1,  c2, ... cn
     +----+               rate   ���줬 fix ����ȡ�
              +---------+ rate
          +-------------+ rate
          +-----+         rate
                   ...           �ʤɤ���������ʤ���

�������׻����Ƥ�������׻����Ƥ⤪��ʤ��Ϥ���
�����������ͤ�¿�����η׻��̤��ʤ���

�ޤ�����äѤꡢ

  for i (0..n) {
    c_i �� c_n �˸����äƲ�ǽ�ʸ¤���礹��
    �Ǥ��ʤ��ä��顢���������
  }

�Ǥ���?

�ޤ������������Ǥ���������ɡ��٤����Х����ĤäƤ��������͡�

    < # chunks 1 = sum  1/123 sum = 1
    ---
    > # chunks 1 = sum  1/2 sum = 1

�ʤ�ƤΤ⤢�뤷��

merge ���礭���������äƤ��褦�ˤ�����ä����ɡ�������
��̤��ɤ��ʤ��ߤ������ʹ֤ϡ�case 1: case 2: ... �Ȥ����褦��
�񤯤���͡�����ʤ��񤷤��ʤ��Ϥ�������ľ���Τ����ݡ�

Sun Jun  6 02:41:27 JST 2004

���ϥХ��ʥꥵ�����ǡ��ơ��֥���������륳���ɤ�񤱤��ɤ���
��������2ʬˡ���Ȥ��줤�ʥ֥����ѥ�����ˤʤ�ʤ���8ʬˡ��
�餤�ǽ񤯤Τ������󤸤�ʤ����ʡ�

 case_group_1:
      if (c==case_2) goto case_2 ( or nested case_group )
      if (c==case_3) goto case_3
        ....
      if (c==case_8) goto case_8
      goto default
 case_group_2:
      if (c==case_10) goto case_10
        ...
      goto default
 cslabel:
      if (c==case_1) goto case_1  (*)
      else (c<case_1) goto default
      if (c==case_9) goto case_9  (*)
      else (c<case_9) goto case_group_1 (or table lookup )
      if (c==case_17) goto case_17  (*)
      else (c<case_17) goto case_group_2
        ...
      else goto default;

����... (*) �ϡ����ץ���󡣤ʤ������ɤ�CPU�⤢���������MIPS�Ȥ���

�ե�åȤ������ɤ����⤢��Ϥ���(��¬����?)

Sun Jun  6 09:39:13 JST 2004

�ǡ�nested branch �ϡ��ɤ�����������ɤ���? recursive ��
�񤯤�����? bottom up �˽񤭤����Ȥ��������ɡ�

   #define CASE_INDEX_COUNT 8
   switch_index(int chunk,int *cslist) {
       if (case count > CASE_INDEX_COUNT) {
	   chunk1 = gather_chunk()
       chunk1 = switch_index(chunk,&cslist);

   while(chunks) {
       chunk = switch_index(chunk,&cslist);

���餤? (chunk �Ǥ���?!) ...  ��... ���ä��顢merge_chunk
�ǤǤ���󤸤�ʤ���? �Ǥ�����������ɡ�����ä�ʣ�������뤫��

table ������ʤ顢ɬ�� index ��ɬ�ס�

index ��table�ˤʤ뤳�Ȥä�... �����ˤϤ��뤫���Τ�ʤ�����
̵���ˤ���ФǤ��ʤ����ȤϤʤ�����������...

Sun Jun  6 23:07:16 JST 2004

level 1 table ��������������������ʤ���

���Υ��르�ꥺ����ȡ�10����Ϣ³���Ƥ���ơ��֥��
������anomaly������äƻ��˺���͡��ơ��֥뤬ʬ�򤵤���㤦��
�ޡ�����ʥ����ɤʤ��Ȼפ����ɡ�

cmpdimm ��ľ���Τ�˺��Ƥޤ�����

���ȡ�delta!=1 ���ȡ��任�����Ȥ���;�꤬0�Ǥ��뤳�Ȥ��ǧ���ʤ���
�����ʤ���gcc �Ǥϡ�delta!=1 ��ɽ�ϽФ��ʤ��ߤ������͡�

���ȡ��Ԥ��褬Ʊ��case�ϡ�range check �ˤ���Ȥ�...
(�ޤ��ͤ�����)

�ޡ�����ϤǤ��ޤ�����

kernel �Ȥ� gcc �Ȥ� compile �Ǥ�����ɤ����ɤͤ���

Mon Jun  7 18:24:27 JST 2004

���ơ����ϡ���¤�Τν��������c2cbc ����mc-tree ��ʬΥ����

�ɽ��ѿ��ν�������쥸�����ѿ��Ǥ���˴ؤ�餺�����å���
��������Ƥ���ʡ�

  gcc -E -c -DCONFIG_TASK_SIZE=4096 -DCONFIG_KERNEL_START=1 -D__KERNEL__=1 tcp_ipv4.c -I../../include > ~/src/device/test/struct_init.c

kernel source �ϡ��ޤ����ᤤ�󤸤�ʤ�? asm �Ȥ����뤷��
�Ǥ⡢asm ���񤷤����ǤϤʤ����ɤ͡�

stdarg �ϴ�ñ�ʤ�����ɡ�������Ѥ� C source ����äƤ�������
�ɤ��͡�macro �����Ǥʤ� typedef �⤷������͡�

"test" "test" �ϡ�macro ��ǤϻȤ��ʤ����äƤ������Ȥ�ɬ�פʤ�?
�ɤ��������ȤDz�ᤵ��뤫�顣

hoge##name �ߤ����ʤΤΰ���������... hogefuga ���Ѵ����줿���ȡ�
�ޤ���Ÿ������ɬ�פ���������͡�

������������ϡ�chptr ����������� macro processing ����ʤ���
macro �ϡ�getline �ǹԤ��뤫�顣������

������line continuation �� macro �δط��ϱ��������ʡ�
getch �� null ���֤��Τ�ǧ�����ɤ�������ɡ�¾�ΤȤ�����
�ƶ����礭����

##          l = va_arg(ap,long long);
## (*((longlong *)ap)++)

������macro �ط�����space �����Ƥ����ï������?

������������register ��ΰ����ϡ�varargs �ξ��ϡ�
���٤ƥ��������ʤ��Ȥ����ʤ��櫓�͡����㤡��
��ư���������������Ϥɤ���ä�Ƚ�Ǥ����?

Wed Jun  9 10:14:35 JST 2004

�������ʤ��ȡ��ʤ󤫡��ؿ��ΰ����η��Υ����å��򤷤Ƥʤ�
�ߤ�����

stdarg �Ǥ��ޤ�����struct size �Υ��顼�Ϥʤ�?

�����ȡ�
	alloca 
	asm
	struct partial field init
        hoge##name
���ʤ��͡��Ȥ��������������? (��ĥ���)

Thu Jun 10 17:57:35 JST 2004

struct partial field init �ϡ��Ǥ���������ɡ��ɽ��ѿ��ξ��
�ϡ��������ʬ��0�ˤ��Ƥ���ߤ����͡��Ĥޤꡢstatic �ˤȤäơ�
���ԡ����Ƥ���ߤ����͡������ɸ��Ū�ʥ��ޥ�ƥ������ʤΤ���?

��äѤꡢ��ʣ����������ϵ�����ʤ��Τ����̤ʤΤ���

skipspc()=='.' ���ȥ����Ȥ������åפ���ʤ����ա��ࡣ
�⤦�����衣skip flag �ǡ�

�ʤ��  macro_expansion ��
    c = 1;
    macrop = list2((int)macropp,macrop);
    while(c && (*macropp++ = c = *body++)) {
�ʤ���Ѥʥ롼�פʤ��?

Sat Jun 12 10:42:15 JST 2004

��������inline �Τ���� constant switch �Ȥ�����ȡ�����Ū
�� statement ��skip ����äƤΤ�񤫤ʤ��Ȥ����ʤ��櫓�͡�chk
��Ȥ����ɤ�����������ɡ�����ۤɡ��񤷤��Ϥʤ�����....

alloca �� r1 �� $sp ��ư�����Ƥ�����������

�Ĥ�ϡ�
       alloca
       inline
       asm
�ȸ������Ȥˤʤ�ޤ�����... MIPS ��stdarg��ư���Ƥʤ�����... 
����� include file ��������Τʡ�

typeof ������
     typeof (hoge) i;
     sizeof(typeof(hoge));
     ((typeof (hoge)) fuga)
�ߤ����ʴ�����

�ʤ� g() �ǡ�register_save ���Ф���äƤ�͡�

Sun Jun 13 12:20:39 JST 2004

ia32 �� alloca �ϡ��ؿ��ΰ����˸ƤӽФ����ΤϤޤ��������ȡ�
stack ������⡢�ޤ��������㤡���ɤ������?
      a = alloca(3)+3;
      f(i,alloca(3),j);
�ߤ����ʤΤǤ���þ�����㤦�Τ͡�

powerpc �Ǥ�빽���������ʡ��ؿ��ƤӽФ����ΰ����ϡ�
r1 ���ФǤĤޤʤ��Ȥ��ᡣ��������͡��Ȥ�������
�ǽ餫�� r1 ���Ф��Ѥ�衣

        lwz r2,0(r1)
        neg r0,r0
        stwux r2,r1,r0
        addi r2,r1,208
        addi r0,r2,15
        srwi r0,r0,4
        slwi r0,r0,4
        stw r0,208(r30) <=== �ǽ��local �ѿ��Υ��ɥ쥹��
        b L26
L25:
        li r0,0
        stw r0,208(r30)
L26:

�äƤ櫓����

������
      int i;
      goto f(alloca(100),&i);
�ʤΤäƤ����͡����Ȥ���С�local �ѿ��ϤĤ֤��ʤ�����
�����Τ�������������ñ����������������Ф� local �ѿ���
goto �ΰ����ϽŤʤ�ʤ����� parallel assignment ��ɬ��
�ʤ������ʤ�ǡ��ǽ餫�餽�����ʤ��ä��������?

����������������ˤϤɤ�ľ�����ɤ��������? max-func-arg?

�ޤ������礨����alloca �� goto ��ξΩ���ʤ��äƤ��Ȥ�
�����󤸤�ʤ�? ���ʡ�subroutine �Ϥ�����ɤ����������͡�

Mon Jun 14 20:48:13 JST 2004

PowerPC �� alloca ��ư��������...

Tue Jun 15 10:47:53 JST 2004

��ä� inline ������ asm macro �����? asm macro �� constraints ��
���ꤹ��Ф���ʤ��񤷤��ʤ��Ȼפ����ɡ�

inline �ϡ������� CSE �Ȥ� flow ���ϤȤ����ʤ��Ȥ����ʤ�������ɤ͡�

������inline ����Τ��ɤ����� CbC �Ȥ������ˤ���ʡ�

�Ȥ����櫓�ǡ�asm ��������������󤸤�ʤ�?

ia32 ��switch ʸ�����������ʤäƤ뤾��

Wed Jun 16 13:05:40 JST 2004

asm �ϡ�({....; val;}) ����˼������ʤ��Ȥ��ᡣ���ȡ�
local_decls �Ǥ� redefined �����ɡ��ʤ󤫤�����ˡ�����?
̵��äƤ⤤���������...

association list ��Ȥäơ�unwind ������ɤ�������ɤ͡�
����ϡ�����Ū�˼�ľ�����������ɤ�����󤷡�

cheap �ΰ����� boundary �򸫤Ƥʤ��Τ����Ĥ�����͡�

Thu Jun 17 17:10:21 JST 2004

�����ȡ�
    "m" �Ȥ��ϡ�������ѹ��ʤΤǸ��ʤ��Ƥ������
    "r" �ϥ쥸�����������Ƥ�
    "=" �Ͻ��ϤΥޡ����ʤΤ�̵�뤷���ɤ�
    "+", "&" �Ͻ��ϤΥޡ����ʤΤ�̵�뤷���ɤ�
�ǡ�
    "0"   0���ܤ�operand
�Ȥ��ʤ������... �����Ĥ� input (��˥���ѥ��뤹����)
�˸���롣�����顢output operand ����˽������롣out
put operand ��ñ�������ʸ�����顢�����Ok��

Fri Jun 18 13:33:19 JST 2004

�ʤ󤫡�%0,%1 �Ȥ��äơ�Ʊ���쥸�����˳�꿶���뤳�Ȥ�
����ߤ����͡�����ˡ�Ϣ³���ƤǤ����Ȥ�¤�ʤ��ߤ�����

�äƤ��Ȥ�?

�ʤ󤫡��ְ㤨����%0...%8 �ϡ��ѥ�᥿���ν����
�����Ƥ���Τ͡���������ʡ�

Sat Jun 19 00:17:33 JST 2004

asm �Ͻ���ޤ������ޤ���ia32�Ȥ�MIPS�Ȥ��ϡ��ȼ������꤬
�������������ɡ�

Sat Jun 19 06:40:30 JST 2004

label ��function local�ˤʤäƤʤ��ߤ�����

builtin_expect ������

bit filed ���������븫������

��ɡ��������������ʤ��Ȥ��ᤫ��
     q = (struct spin_lock) { };

�Ȥ���