view Changes @ 481:6445b419aef0

*** empty log message ***
author kono
date Sun, 04 Dec 2005 14:19:25 +0900 (2005-12-04)
parents 5c497d547c0b
children 8370ba6e8557
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 �������argument �⡢
    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 evaluator �򥻥ޥ�ƥ�������¹ԷϤˤ���Ƥ������Ȥϲ�ǽ��?

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 argument {
	    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 argument {
	    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? synchronized state ����?
�������sequential implementation�Ǥϡ�����ʤ�ΤϤ���ʤ���

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

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

serialized �� semantics ��?

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

carrying state �� static state��

Mon Dec 13 19:42:41 JST 1999

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

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

Wed Dec 15 14:09:49 JST 1999

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

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

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

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

arguments ��static �ΰ�ˤ��������������ȸߴ������Ȥ�ʤ���
stack ��� frame pointer ��ˤʤ��ȥ�������顣

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

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

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

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

�Ȥ������Ȥϡ���ϤꡢC ��call �ϡ�call function ��
�¸����ơ�����¾�θƤӽФ��ϡ����٤ơ�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 �ʳ��ϡ�consistent 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 arguments in save area
	# set extra argument pointer in %edx
	    jmp function
�Ȥ��������ˤʤ�櫓�͡�second ���������ΤϤ��ɤ�����������
�ˤ��褦��

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

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 argument ��ɬ��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 register ��������褦��

    stmode=REGISTER

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

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

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

Sun Jan  2 01:47:17 JST 2000

register �ѿ��ϤǤ��ޤ��������ɡ�register ����ĻȤ��ȡ�
���դˤʤäƤ��ޤ��Τǡ�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 ��return

��Ϥ�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 ������ȡ�������spaghetti�ˤʤ�ʤ�?


Tue Jan  4 11:47:24 JST 2000

continuation ����ʤ��ơ�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
�ƤӽФ��ˤ���ˤ�? dispatcher ��ʬ�Ǻ�뤳�Ȥˤʤ롣���ʤ�
���ɤ�������...

code method(obj,arg)
{
}

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

Tue Jan  4 14:22:19 JST 2000

main ���ѿ�����٤��Τȡ�goto (*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 Definition
	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 ¦��Ƚ�Ǥ��뤫? 
	return(ID)
�ߤ����ʷ���ID��Ƚ�Ǥ��롣��������С�return ¦��ID
�򸫤�Ƚ�ǤǤ��롣����...

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

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

�����ʤ������.... 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_yields() ������񤱤뤫��? 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 ��
�ʤ�ʤ������?  ANSI �������Ѥ������ʤ���

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

���줴�ȡ��ɤä��ˤȤä��֤���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

�����Ʊ���褦�ˤ���ʤ�С�register�λ��ѿ���ǽ��Ĵ�٤�ɬ�פ�
����Τ����ɡ�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 Segment ��ñ�̤Ȥ��ƻȤ��Ȥ��ˡ�����ѿ��Ϥɤ�����
�褦��ʬ�����? 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�ΰ��������ߤ��Ƥ����Ĥ�����..
��äѤޤ����󤸤�ʤ���?

temporal 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

overlapped �Ѥ� 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 �������overlap���Ƥʤ��Ȥ����ݾڤ��ʤ���

Wed Feb 19 15:38:55 JST 2003

��ʬ���ȤȤ�overlap�򸫤Ƥʤ��Τǡ�
    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/double �Ͻ�Ĵ�˿ʤ�Ǥ뤱�ɡ�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 �Ǥ���signed/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 multiple 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_assign
�������������󤸤�ʤ���?

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 segment/
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  �Ȥʤ�ؿ��ƤӽФ�����롣���顢
callee 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-continuation �ߤ����ʴ�������

�֤�¦�ϡ�

  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
�����ꤷ�Ƥ����ɤ���

Intel�Ǥ� goto ��ư���ʤ��ʤä��Τϡ�arg_offset ����register �ѿ�ʬ
����褦�ˤʤä����顣save ���뤳�Ȥ�ͤ���ȡ����������ɤ����ºݡ�
function call �������save����Ƥ��ޤ����Ȥ������Ȥϡ��̤� r20-r29
�Ǥ���ɬ�פϤʤ��äƤ��Ȥ����̾��input register var���ɤ����Ȥ���ȡ�
register�ѿ���save����ɬ�פ�ʤ��͡�
������input register 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() �Ǽ�ä��褿register��ï��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 ��Ȥä��Ѵ�
�Ǥ⤤���󤸤�ʤ�? ��������С�spaghetti 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 ��register
����Ĥ���櫓�͡�push �Ǥ��ʤ���?

    case COND:        /* a?0:1 should consider non-branch 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-branch 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 �ο����ΰ�����unsigned�Ǥ���٤�����͡�
�ǡ�- �����ä�����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{
                 shift();
     }
�ߤ����ʴ���?

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/signed �ζ��̤��ʤ��Ȥޤ�����͡�

���Ū�ʥƥ��ȥ롼���󤬤��ä�����������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 directory ��õ����

�ޤ���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 segment ¦��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=source ��̵�¥롼�פ��ʤ�?

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 field ���������븫������

��ɡ��������������ʤ��Ȥ��ᤫ��
     q = (struct spin_lock) { };

�Ȥ���

    typedef struct __wait_queue wait_queue_t;

    struct __wait_queue {
	    unsigned int flags;
       ...
    };

�äƸ��������� typedef �� struct �����������󥱥󤵤�Ƥ��ޤ���
����� struct def �ϡ�typedef ���줿��̾���Τ�褦���ʤ�������
0 �ʤ顢type �� nptr �����äƤ���Τǡ������filed list��õ�����ɤ���

��ä�bit filed���ʤ��Ȥ��ᤫ���ɤ�����Τ��ʡ�type �γ�ĥ?

bit field �����������ʤ����

�ޤ�����¤�Τ�������Ʊ���褦�ʷ��ˤ�����ɤ��櫓�����ɡ�

bit field �ν�����äƤΤ⤢��Τ���(������)

�����󡢤�äѡ��̤Ƥʤ��ʡ�
    ASSOP, PREINC, POSTINC.... 
�ޤ���
    BASSOP, BPREINC, BPOSTINC.... 
�Ǥ⤤��������ɡ�

Sun Jun 20 20:21:38 JST 2004

�ɤ��⡢mc-parse �ˡ�mc-codegen ������������ʬ�����ʤ��������Ǥ���
�ߤ������͡������ܤ��ΤϤ��ɤ�������... binop �Ȥ�����Ȥ��
mc-codegen �ˤ���٤���ΤʤΤ���

�Ǥ⡢����򤷤ʤ��ȡ���ʸ���б�������ʸ�ڤ���ʤ��櫓����
inline �ǡ���ʸ�ڤ��ɾ��������⤢�뤫��ʤ�����ɾ������
���ˡ���ʸ�ڥ�٥���ѹ�����٤��ʤΤ���������������٥��
�ڤǤ��٤��ʤΤ����Ȥ�������⤢��櫓����

macro ��ʬ�䤷�������ɤ��͡�

Mon Jun 21 00:29:12 JST 2004

mc-tree �ϡ��⤦�����٤졣�ڤ�Υ���������ɤ���
conv �⡢����ʤ󤸤�ʤ�?

�ʤ󤫡���ʬ���Ѥ�����ä��ʡ�ư�����Τ����Ѥ�����

�Ǥ������ static �ˤ���������...
     mc-codegen ����������Ȥ���� mc-parse.c ��extern
�äƤΤ� C �Ǥ�ɽ���Ǥ��ʤ�����ö��extern ����ȻȤ��Ƥʤ��Ƥ�
���ˤ����ʤ��ʤ뤫�顣

mc-codegen �λȤäƤ����ѿ��Τ������ɤ줬static�ʤ�������ФǤ��ʤ���

emit_data_closing �ξ�꤬�ѡ�

Tue Jun 22 01:05:09 JST 2004

�褦��äȥꥫ�Х�Ǥ����衣

local scope { int hoge; ... { int hoge;... }} for(int i=0; hoge...)
�ϡ���餶������ʤ��������͡�

Tue Jun 22 06:49:55 JST 2004

bit-field �� alignment �ϡ��������ƥ�����ˤ�ä�Ǥ�դä�
�������ʡ�

MIPS

01:ffffffffffffffff
02:fffffff0 0000001f 00000000 00000000 00000000 00000000 00000000 00000000
02:00000000 00000000 ffffffff 00000001 00000000 00000000 00000000 00000000
02:00000000 00000000 00000000 00000000 ffffffff 00000001 00000000 00000000
01:ffffffffffffffff
02:fffffff0 000fffff 00000000 00000000 00000000 00000000 00000000 00000000
02:00000000 00000000 ffffffff 0000ffff 00000000 00000000 00000000 00000000
02:00000000 00000000 00000000 00000000 ffffffff 0000ffff 00000000 00000000
1:ffffffffffffffff
2:fffffff0 0fffffff 00000000 00000000 00000000 00000000 00000000 00000000
2:00000000 00000000 ffffffff 00ffffff 00000000 00000000 00000000 00000000
2:00000000 00000000 00000000 00000000 ffffffff 00ffffff 00000000 00000000

PowerPC

01:ffffffffffffffff
02:0fffffff f8000000 00000000 00000000 00000000 00000000 00000000 00000000
02:00000000 07ffffff fc000000 00000000 00000000 00000000 00000000 00000000
02:00000000 00000000 03ffffff fe000000 00000000 00000000 00000000 00000000
01:ffffffffffffffff
02:0fffffff fffff000 00000000 00000000 00000000 00000000 00000000 00000000
02:00000000 00000000 ffffffff ffff0000 00000000 00000000 00000000 00000000
02:00000000 00000000 00000000 0000ffff ffffffff 00000000 00000000 00000000
1:ffffffffffffffff
2:0fffffff fffffff0 00000000 00000000 00000000 00000000 00000000 00000000
2:00000000 00000000 ffffffff ffffff00 00000000 00000000 00000000 00000000
2:00000000 00000000 00000000 00000000 ffffffff ffffff00 00000000 00000000

�����ϡ�mc-parse.c �ǤϷ����ʤ��Τ���

�ޤ���
        boundary ��ޤ���ɤ߹��� (ɬ�����ꤵ�줿���Υ������˼��ޤ�)
���ˡ�
        �ɤ߹������ʬ�λ��ꤵ�줿bit���֤�����
           �ޤ� 0 �ˤ��ơ��֤������� or ����(?)
�����ơ�
        ���
�äƴ����Ǥ����͡�64bit �Ϥ��ɤ������ʡ�

�äƤ��Ȥϡ�
       and mask ��Ĥ��äơ�or mask ��Ĥ��äơ�
       �༡�¹�
�äƴ����Ǥ������Ϥ�����
       
BIT_FIELD ��size����ʤ��ȡ���������Ǥ��ʤ���

Wed Jun 23 14:06:10 JST 2004

(�����ϰ��ߤ���...)

emit_data �ϡ�mc-codegen �ˤ���٤�����͡�

bit_field ������ѿ��ν�������Ǥ��ʤ������ä��󡢤ɤä���
����ʤ��Ȥ��ᡣassign_data level?

�ʤ󤫡�assign_expr �� ���� type ������ѿ����񤭤��Ƥޤ�����
���줬�Ѥ��������Х��θ������ä��Τ���

Fri Jun 25 00:00:46 JST 2004

�ʤ󤫡�Union �Υƥ��ȥ����ɤ�񤤤Ƥʤ��������롣
Union �ϡ��ְ�äƤޤ�����

bit field �ϤǤ��ޤ�����

�ʤ� MIPS ��gcc�ϡ�bit field �˥Х�����ߤ������͡�

Fri Jun 25 11:30:30 JST 2004

3249,3252c3249,3251
<     //  n = get_register_var(0);
<     g_expr_u(assign_expr0(n,list2(ADDRESS,cadr(e2)),INT,INT));
<     e4 = rvalue_t(list2(INDIRECT,rvalue_t(n,INT)),type);
<     g_expr(assign_expr0(list2(INDIRECT,rvalue_t(n,INT)),
---
>     g_expr_u(assign_expr0(n,list2(ADDRESS,e2),INT,INT));
>     e4 = rvalue_t(list2(INDIRECT,n),type);
>     g_expr(assign_expr0(list2(INDIRECT,n),
3255,3256c3254
<     if (car(n)==LVAR) free_lvar(cadr(n));
<     else if (car(n)==REGISTER) free_register(cadr(n));
---
>     free_lvar(cadr(n));

�ʤ�����ɡ�lassop ������Ǥ����ꤢ�ꤽ����

bassop ��ƤӽФ� BPOSTINC �ǡ�post �ν����򤵤ܤäƤޤ���

�äƤ�������bassop �ϴְ�äƤ��뤸���

bassign ���ä��顢�ɤ߽Ф���bit replace ���ɤ��������
op �򤫤������ä��顢bit_field �Ȥ����ɤ߽Ф��ơ�
��ö�������ͤˤ��Ƥ���׻����ʤ��Ȥ��ᡣ

post �ν�����ʣ���ʤΤ����ѤΤ�񤤤������ɤ���

    if (simple) {
	tmp_var = bit_field
	tmp_var op= operand
	bit_field = new_var
    } else {
	address = lvalue;
	tmp_var = address->bit_field
	tmp_var op= operand
	address->bit_field = new_var
    }
    if (post) tmp_var;

�Ǥ����͡�

Fri Jun 25 14:49:57 JST 2004

�⤦����ʣ�����ä����Ǥ⡢����ޤ�����codegen level ��
����Τ��ɤ���͡�

�ޤ���bit-field �⡢

     constant assign �λ��κ�Ŭ�� (and/or mask �η׻�)
     1 bit �λ�������̿���Ȥ�?
     bit.r == 1 ��and 0x100 �˥���ѥ��뤹��

�Ȥ�����������뤳�ȤϤ��뤱�ɡ���̣�ʤ����...

Sat Jun 26 16:32:57 JST 2004

�ǡ�local �ѿ��ΰ���������....

    ����ѿ����ɽ��ѿ�������̾���ե������̾����̾����٥�

�Ȥ���櫓����͡��ǡ��������פ�Ǥ�դˤ������櫓����

     nptr �򡢶ɽ�->�ɽ�->��� ��link����褦�ˤ�����ɤ�

malloc ����褦�ˤ���? ����Ȥ�link����褦�ˤ��뤫��

������hash �׻�̵���� lsearch ���Ƥ���Ȥ���������ʡ�
hash ���̴ؿ��ˤʤäƤʤ�����


Sun Jun 27 10:58:04 JST 2004

�礷���ѹ����Ƥʤ����ɡ�ia32 code ���Х��ä���

Sun Jun 27 14:52:59 JST 2004

is_memory �ΥХ��Ǥ�����

���������С�double register pair ��parallel assignment�ä�
��äƤ�?

�����󡢤�äѤꡢcodegen �� register pair ���Τ뤳�Ȥ�����
��褦�ˡ�list2(LREGISTER,high,low) �ߤ����ʷ��ˤ�������͡�
�ʤ�ǡ�����ʤ���ä��ä�? 
	list2(DREGISTER,list2(REGISTER2,high,low))
	list2(LREGISTER,list2(REGISTER2,high,low))
	list2(FREGISTER,list2(REGISTER,high))
�Ȥ�?
	list3(REGISTER,1,reg);
	list3(DREGISTER,2,reg,reg);
	list3(FREGISTER,1,reg);
���ʡ�

����������ɡ��ѹ�¿���ʤ�? �Ǥ⡢use_reg �Ȥ���ʣ������ͤ���ȡ�
�����������������󤸤�ʤ����ʤ���

�Ǥ⡢�ѹ�¿����͡������Ȥ��Ƥϡ�regs[] �� lregster ʬ���ʤ���
���ळ�Ȥ��ʡ��Ǥ⡢�����˴�ñ�ˤʤ�Τ���?

code_*() �ǥ쥸������ȤäƤ�����ʬ��������ɬ�פ����뤫�顢
���ʤ��礭���ѹ��ˤʤ�Τ����Ǥ⡢code_*() �˰����Ϥ��ѿ���
��ʸ��������Ǥ�Ʊ���ˤʤ�ΤϽ��פ���͡�

��ʸ�ڤǤΥ쥸�����ѿ��Υ�ˡ�������ݻ����ʤ��ȡ�
    if(r!=reg)
        printf("\tmr %s,%s\n",register_name(reg),register_name(r));
    return;
�ߤ����ʤΤ�����͡��Ȥ������Ȥ� reverse poiner ������äƤ�
�Ȥ���

overlap �򸫤�Ȥ��ˡ���ʬ���Ȥ� overlap ���Ƥ��Ƥ�����ʤ���
���������Ťʤ�ʤ��褦�˥��ԡ����ʤ��Ȥ��ᡣ�������ʤ��ȡ�
����ʹ�¤�Τ���󥳥ԡ�����Ϥ�ˤʤ롣

      |---||--------------|

           |--------------||---|

      |--------------|     |---|

      |--------------||---|

�ߤ����ʴ������͡�����ϡ��ޤ��������Ƥʤ������͡�

Sun Jun 27 21:06:28 JST 2004

��äѤꡢname/namebuf ��Ϣ�Ͻ񤭴������Ǥ���?

�ޤ���get_name/get_string  �ϡ�cheap ��˥��ԡ����롣
�ǡ�new_def �Ǥʤ��ä����ˤ� cheap �򸵤��᤹��
name, namebuf �ϡ��ʤ�����

  string hash (oblist) ->  hash table ->
    nptr -> macro/reserve/local/global/typedef etc

�Ȥʤ롣local nptr �ϡ�local_scope list ����Ͽ����
scope ��ȴ����Ȥ��˾ä���

get_name/string ��t������Ͽ���Ƥ��ޤ���gserach/lsearch/msearch
�ϡ���Ͽ���줿hash �����linked list ���ɤ���gsearch �� linked
list �ˤ���ɬ�פ����롣nptr �ˤϡ�next ��Ĥ���?

������ARM �ˤ� fpp �Ϥʤ��Τ͡����䡢GBA�ˤϤʤ����ɡ�
Zaurus �ˤϤ���äƤ����ѥ�����?!

�äƤ��Ȥ�... MIPS �� PowerPC ��­������dz�ä��褦�ʼ���
�򤷤ʤ��Ȥ����ʤ��Τ��������ࡣ

macrobuf �ϡ�cheap �Ƕ�ͭ�Ǥ���Ϥ�����������С�linebuf �ʳ���
��Ĥˤʤ롣linebuf ����ˤǤ��뤫��? ����ϡ�̵���ʤ������...
cheap �ʤ�����ɡ�extendable �ˤ��뤿��ˤ�...

     struct cheap {
         char *cheap;
         char *last;
	 struct cheap *next;
     }

�Ȥ��ơ�����ؤΥݥ��󥿤�cheap�Ȥ����Ѥ�����ɤ���cheapp �Ȥ���
����Τǡ���ä�������..

Mon Jun 28 20:18:03 JST 2004

���Τ���������ä��㤦�ȡ�chptr �� cheap �򻲾Ȥ��������顢
���ä��⡢ľ���ʤ��Ȥ��ᤸ���

���䡢����Ϥʤ���mappend �ǡ�ɬ�� cheap chunk �˼��ޤ�Ϥ�
�����顣�빽��̵�̤��Ф��ǽ���⤢�뤱�ɡ��̤ˤ����󤸤�ʤ�?
�����Ÿ������ macro �κǸ�������� cheap ����ϤߤǤ�Ȥ���
������ɤ��ʤ�? 2M �Ȥ���Ÿ�������櫓�Ǥ�ʤ�����?

mappend �� chunk boundary �ˤ������ copy �� append ��
�����Ƥ��ޤ����ɤ�����cheap rest ���Ƥ��顢chptr ��
���ؤ��������餤��������ɤ���

Tue Jun 29 17:36:36 JST 2004

  #define car(a) heap[a]
������...
       typedef struct tree {
          int id;
          int next;
       } TREE;
�Ȥ��ơ�
   #define as_tree(a) (TREE)(heap[a])
	  TREE t = tree(a);
	  if (t.id == HOGE) {....
�äƤ����褦�˥������������Ϥ����͡�
   #define tree(a) ((TREE)(heap[a]))
	  if (tree(a).id == HOGE) {....
�Ǥ⤤������

conservative ���Ѥ������Τ���drastic ���Ѥ������Τ�
�ɤä����衣


name space �ϡ�tag, macro, ����¾? typename �ϽŤʤäƤ��ƤϤ����ʤ���
field ���̤����ɡ�sc �Ƕ��̤���櫓������...

hash_search ���֤��Τ� name spcae assoc ����͡�

�����name ������ȡ� macro Ÿ�����줿 chptr ���񤭤����ǽ�������롣
             cheap->ptr         chptr
    |--------|-name1-| |-name2-|pppppppp|
             cheap->ptr         chptr
    |--------|xxxxxxx| |-name1-name2-|--|
��ޤǥ��ԡ����Ƥ��Ф����������...
                                     chptr
    |--------|xxxxxxx| |-name1-name2-|pp| |pppppp|

�Ǥ⡢chptr �ϡ�boundary �ˤ����뤳�ȤϤʤ�������顢�����������Ȥ�
�����ʤ��󤸤�ʤ���? chptr �Ϥ�����ʤ��Ƥ⡢cheap->ptr �ϡ�������
��ǽ�������뤫��

����Υ��ԡ���������ơ�mappend �Ǥ�page ž�����ʤ��褦�ˤ���С�
mappend �� reset_cheap ���Ƥ��ɤ���

Thu Jul  1 20:28:49 JST 2004

    { int hoge;
        { int hoge; ....} }
�����ɡ�����

�ۤʤ��٥���äƤΤ�ɤ���äƸ��Ĥ����?  define case �ϡ�
�狼�뤫������פ����ʤ󤫥��ץ���󤤤��?

   hash -> name_space -> nptr
           global (typename, global, function)
           tag
           field
           local -> name_space
		    label
                    tag
                    field

�Ǥ���٤������?

Fri Jul  2 06:46:27 JST 2004

����ʤ��ѹ�������äơ�ư���櫓�ʤ���͡�

ñ�Υƥ��Ƚ�?
    cheap
    hash
���餤?

��äѤꡢ���Ѥ�����ȡ��⤦�������Ȥϻפ����ɡ�

Fri Jul  2 23:38:14 JST 2004

���ȡ��⤦����..

����ե���ѥ���ΥХ����Ȥ�ʤ��衣

�⤷������ȡ�void fuga(b,d,e,f) { return hoge(a,b,c,e) ;  }
�äƤ����ץ������Ǵ����ˡ�tail recursion ����ʤ顢
CbC �ȡ�����ʤ��ʤ󤸤�ʤ�? (����?)

����������ñ��? ���䡢�ؿ��ƤӽФ��ȸߴ�����ݻ����ʤ��Ȥ����ʤ�
�Τǡ���äѤꡢ���ä��������񤷤����쥸�����Υ����֤Ȥ����뤷��

��������I2C, I2S, U2UC, U2US ��ɬ�פʤߤ������͡�����˱����ơ�
    code_i2c
    code_i2s
    code_u2uc
    code_u2us
���������

endian ��ͭ������ʤΤ������㤡��hash �ΥХ��Ȥϴط��ʤ��Τ͡�

K&R argument �� redefined �����ǡ��������ѿ��ˤʤä�
���ޤ���

Sat Jul  3 15:16:50 JST 2004

�褦��ä� recovery �Ǥ��ޤ�����

global heap �γ�ĥ���񤷤���͡��äˡ�heap �λȤ�����
���Ȼ��ʺ����񤷤���nptr,heap,local �Ȥ�integer ��
������������ʤ�Ȥ⤫����

�ޤ����������gcc �γ�ĥ��... �Ȥ��ʤ�... __label__

��äѤꡢ��̾������ѿ��Ȥ��̤�̾�����֤���ʡ�

�ޤ��ͤ��� code �����빽������եꥯ�Ȥ��Ƥ���ʡ��ޡ����������ɡ�

����黻�Ҥΰ������ά�Ǥ���Τ���

�����Ĥ�����Ϥ��뤬��kernel source �ϡ��̤�ޤ�����

Sun Jul  4 19:17:02 JST 2004

arg ����˴ؿ������äơ����줬����˴ؿ���������äƤ���ȡ�
���줬define����Ƥ��ޤ������줬�Ȥ����EXTRN1�ˤʤäơ�
̤����ؿ��ˤʤäƤ��ޤ���

�Ȥꤢ����������ʤ�Τ��ʡ�

���Ȥϡ�
         inline
         c2cbc converter
�Ǥ��͡�

inline �Ϲ⤯�դ����������ɡ�

inline ��ޥ����Ǽ�������Τ����Ū��ñ�ʤ����͡������ɡ�
c2cbc ��ͤ���ȡ���äѤꡢ��ʸ�ڤǼ�������٤��Ǥ���?

global heap �ϳ�ĥ��ǽ����ʤ�? local heap ���ʤ����ˡ�
��Ф������ä����ĥ���Ƥ��ޤ���realloc �Ǥ�������
pointer �ȤäƤ���Τ� scope ��������ʤ���?

�����󡢤�äѤꡢglobal heap �γ�ĥ�ϡ�����ۤ�ñ�㤸��ʤ�
�ߤ����͡�


41c41,43
< int args,init_vars,heap[HEAPSIZE];
---
> int args,init_vars;
> int *heap;
> static int HEAPSIZE = HEAPSIZE0;
236a234,245
> void
> clear_lfree()
> {
>     if (gfree>HEAPSIZE-LHEAPMARGIN) {
> 	HEAPSIZE *= 2;
> 	heap = realloc(heap,HEAPSIZE*sizeof(int));
> 	if (!heap) error(MMERR);
> 	fprintf(stderr,"heap extended to %d\n",HEAPSIZE);
>     }
>     lfree= HEAPSIZE;
> }
> static void
331a353,354
>     if (!heap) heap = (int *)malloc(HEAPSIZE*sizeof(int));
>     if (!heap) error(MMERR);

���餤�ǤϤ��󤼤���ᡣ

�̤�����ʤ��Ǥ��뤸��󡣤ʤˤ�äƤ��?

LDECL ����� nlist �ä������ˤ����? ����ʤΤ����뤫�顢��
�֤� nptr ����̵�̤ˤ��Ƥ�������͡�make_local_scope ��
�����ɤ��󤸤�ʤ����ʡ�macro �ϡ������ư���Ƥ���櫓������

�ʤ󤫡�struct ��������äȤ���ʤߤ������ʡ�type̾��local
�ˤʤäƤ��ޤ�����?

�ʤ󤫡�type �� tag ��global�ˤ���Τ��̤ä�����... scope
�˴ؤ��Ƥϡ��⤦�����ƥ��Ȥ�񤫤ʤ��Ȥ�����ʡ�

Mon Jul  5 14:11:07 JST 2004

local label �͡��ޤ�����ñ�ʤ������...

lazy flag �ǡ�
     do if 
       make l = listN(IF,cond,then,else)
       if(lazy)
            return l;
       else
            eval_if l;
     eval_if
�ߤ����ʴ���?

Tue Jul  6 17:46:50 JST 2004

type �� tag �����ˤ���󤸤�ʤ��ơ�tag ���ä�����衢
type �ϡ�LTDECL �ΤߤǶɽ�äƤ����褦�ˤ���٤�����͡�

static �� global �ˤʤä���äƤ�ʡ�

���������ʤ����ʤ󤫲�������ä��衣����

bit field �ä�

	e4 = rvalue_t(e2,type);
	g_expr(assign_expr0(e2, list4(BFD_REPL,e4,e3,t), type,type));

�ʤ�����ɡ�������ȡ�
        e2 ����Ϥ��ơ�push ���ơ�
        e2 ��⤦����ɤ߹���� load
        ������ replace
        pop ���� assign
�äƴ����ʤ����ʡ��̤ˤ���������ɤ���
        e2
        load
        replace
        store
�äƤ����褦�ˤ�����������ɡ�

�Ǥ⡢������ʬ�ä� long long ���̤äƤ��뤫���ѹ�����Ȥʤ��
�̤�¿�������ʡ�

GVAR + offset ����list2(INDIRECT,list2(ADD..)) ��Ÿ�������Τǡ�
simple �����ˤ�äƤ�����ʤ����Ȥ������Ȥϡ�GVAR �� GVAR + offset
�Ȥ��������ˤ��������ɤ��äƤ��Ȥ���͡�

list2(GVAR,nptr) �ʤ�����ɡ������list2(GVAR,nptr,0)
�ˤ�����ɤ�? �ޤ��ͤ�������ޤ�Ȥ��ʤ��Ȥϻפ����ɤ͡�
�ºݡ��Ф륳���ɤ��Ѥ��ʤ�����

�빽��ʣ����ʣ��������󤸤�ʤ���?

Wed Jul  7 23:19:35 JST 2004

�Ǥ������ɡ�mips �� register usage ��������������ä�
�쥸������Ȥ���Ϥ���

save_stack �ǡ�regisiter ���������Τ�˺��Ƥޤ�����

parallel_rassign �Ǥϡ���IJ��������顢������¾�ΰ�¸�롼��
���褹��Τ˻Ȥ��Τ��ɤ�������...

�ɤ��⡢;�פ� extsb ���Ƥ���ߤ������ʡ�

�����ɬ�פʻ����Ѵ�����٤�����͡��Ǥʤ��ȡ�
       lbz
       extsb
       stb
�����㤦���顣

Thu Jul  8 02:31:03 JST 2004

ARM�ϡ��ɤ���add, sub �ϡ�8bit �����������Ƥ�ߤ����͡�

table ��max-min ��16bit ���Ȳ��ꤷ�Ƥ���ߤ������ܿ���
�ޤ�Ǥ���Ȥ��ϡ����θ¤�Ǥʤ���

Fri Jul  9 14:45:56 JST 2004

LDECL �ϡ�disp < 0

const ��������ʤ��Ȥ����ʤ������ʡ�

arm �ϡ�����ѿ���
        ldr     r3, .L28+88
    ....
.L29:
        .align  2
.L28:
        .word   i1
        .word   i2
        .word   s1
        .word   s2
        .word   us1

�ߤ����ʷ��Ǵ��ܻ��Ȥ���櫓�����ɡ����Ȥ�����˥ꥹ�Ȥ˳�Ǽ���ʤ���
����? �ѿ�ɽ�˳�Ǽ�����������... make scope �ǽ���ʤ�����?
linear list �ǻ��äƤ⤤��������ɡ�

ptr_cache �����ǥꥹ�Ȥ���Ƥ�?

�ʤ󤫡�add # �ΰ�̣���ɤ��狼��ʤ��衣�̤˾�˥���
���Ȥ�����Ϥʤ���Ǥ���?

�ɤ��狼��ʤ����ɡ�
      8bit ��������ǡ����եȤ�2����
�ߤ����ʴ���?

�Ǥ������ɡ��ɤ�ʥ��르�ꥺ��������������衣

    8bit mask ��2���ĥ��եȤ��ơ�
      �Ĥ꤬���뤫�ɤ�����ߤ�

�����ȡ�16x8x8 ���餤�Υ�����?
    for(sign=-1;sign<=1;sign+=2) {
	if (sign==1) d = c; else d = -c;
	for(i=0;i<32;i+=2) {
	    if (!(im=mask8(d,i)))  continue;
	    id = d - im;
	    if (id==0) goto found;
	    for(j=i+8;j<32;i+=2) {
		if (!(jm=mask8(id,j)))  continue;
		jd = id - jm;
		if (jm==0) goto found;
		for(k=i+8;k<32;k+=2) {
		    if (!(km=mask8(jd,j)))  continue;
		    kd = jd - km;
		    if (km==0) goto found;
		}
	    }
	}
    }
	emit_const(c);
    found:
	if (sign==1) emit_add(im,jm,km);
	else emit_sub(im,jm,km)
�Ǥ����͡�1024 �롼�פ������� const ���?

�����⡢������ǡ���äȤ�û��̿���õ���ʤ��Ȥ���ʤΤ���

pointer offset �⡢�����ʤΤ���? (���β�ǽ���Ϥ���Ȼפ�)

12*8*4 = 384 ���餤��(�ǰ���)

    sub mask8 {
	my ($d,$bit) = @_;
	$d & (255 << $bit);
    }

    sub make_const {
	my ($c) = @_;
	my ($sign,$im,$jm,$km);
	my ($min_stage) = 4;
	my ($msign,$mim,$mjm,$mkm);
	for($sign=1;$sign>=-1;$sign-=2) {
	    my $d;
	    if ($sign==1) { $d = $c; } else { $d = -$c; }
	    last if ($min_stage==1);
	    for(my $i=24;$i>=0;$i-=2) {
		$jm = $km = 0;
		next if (!($im=mask8($d,$i)));
		my $id = $d - $im;
		if ($id==0) { 
		    $min_stage=1; $msign = $sign;
		    $mim = $im;$mjm = $jm;$mkm = $km;
		    last;
		}
		next if ($min_stage<=2);
		for(my $j=$i-8;$j>=0;$j-=2) {
		    $km = 0;
		    next if (!($jm=mask8($id,$j)));
		    $jd = $id - $jm;
		    if ($jd==0) {
			$min_stage=2; $msign = $sign;
			$mim = $im;$mjm = $jm;$mkm = $km;
			last;
		    }
		    next if ($min_stage<=3);
		    for(my $k=$j-8;$k>=0;$k-=2) {
			next if (!($km=mask8($jd,$k)));
			$kd = $jd - $km;
			if ($kd==0) { 
			    $min_stage=3; $msign = $sign;
			    $mim = $im;$mjm = $jm;$mkm = $km;
			    last;
			}
		    }
		}
	    }
	}
	if ($min_stage<=3) { emit($sign,$im,$jm,$km); }
	else { print "emit const $c\n"; }
    }

���餤�Ǥ�����

Sun Jul 11 12:54:26 JST 2004

��äѤ�large offset �Ϥ��ޤ�ư���Ƥʤ��ߤ����͡�

local global table �ϡ�12bit offset(+sign 1bit) ������4096/4
��1000̿����ˤϽ��Ϥ���ɬ�פ����롣�����⡢���˽��Ϥ���Ƥ�
���Τϡ����Τ�Ȥ�ɬ�פ����롣�ʤ�ۤɤ͡��äƤ������Ȥϡ�
�ơ��֥�ˤ��������ե饰��Ĥ��ʤ��Ȥ��ᤫ��(���줰�餤
������֥�Ǥ�äƤ��) 

���٤Ƥ�printf��counter ��Ĥ�����ɤ��櫓�����ɡ������Ĥ���
���꤬����������ʡ�����ä���¿�����͡�

ARM�ˤ� short �äƤʤ��Τ���short ��¿�Ѥ��Ƥ���ץ�������
����ʤΤ͡�

(�Ǥ⡢�ɤä����äƸ����ȥƥ��ȴĶ����������񤷤���)

sl�Ȥ�ip�Ȥ��פ����줬���ꤽ���ʥ쥸������̾�����礷����̣������
�櫓�ǤϤʤ��餷����

ARM�äơ��ʤ�signed char ��unsinged char �ζ��̤��ʤ��ʡ�

lvar offset ��������äȤ��ɤ��������ʡ�
constant ����ޤäƤʤ����顢���ä�����ä�code_add
���Ȥ��ʤ������䡢��ޤ�Τ���?

Sun Jul 11 20:37:20 JST 2004

��äѤꡢlocal variable �Υ��ե��åȤ����ξ������Ǥʤ��Τ�
�ޤ�����

                     �����
         fp          <-------|
   +------+------------------+
          <----lvar_offset--->

�ʤΤ��ޤ��������͡�

          �����
         fp------->          |
   +------+------------------+
          <----lvar_offset--->

�ˤ�����ɤ���������͡��ʤ󤱤ɡ�def �� pre decrement ���Ƥ��뤬
�ޤ���������<0 �Ǥʤ��Ȥޤ����Τǡ�ñ��� post decrement �Ǥ���ᡣ

�Ǥ⡢���콤���̤�¿����͡�

          �����               
         fp------->          sp----->
   +------+------------------+
 callee   <----lvar_offset--->  caller
   arg                            arg
   <------> pre known offset
   ---->

�ȡ�ľ�����ɤ���

�󡢤���....

                       <------r1_offset------------------------------>
                                                 <-lvar_offset------->
 r+  +------------+---+-------+------------------+--------------+----+    -
      callee arg   xx   local   register save       caller arg     xx
                        disp      reg_save          max_func_args*SIZE_OF_INT
        lvar>0          lvar<0                      lvar>0x1000 0000
                      r30                                            r1
                                       
�Ȥ���Τϡ�PowerPC �Ǥ��ѹ����礭�����롣�쥸���������֤�����
���ɤ��狼��ʤ�����

�⤷�����ơ�register save �ΰ�ϸ���?! 


Mon Jul 12 05:35:33 JST 2004

�����󡢤�äѤꡢ�񤷤����... ���Τ���printf �� local variable
������Ƥ��ޤ���

register save �ΰ�ϸ���ʤ櫓����ʤ��������ǽ餫����ľ���ơ�

 function call stack frame
                      <-------r1_offset------------------------------>
                                      <------------lvar_offset0------>
                      <--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

�Ȥ������Ȥˤʤ�ޤ�����frame ������ΤȤ�������̵����32bit add
�ˤʤä��������ʤ��ʡ�������ȡ�callee arg �����ꥪ�ե��åȤˤʤ餶��
�����ʤ���reg_save ���Ǹ�ޤǷ�ޤ�ʤ����顣

�Ϥ������ѤʤΤ�PowerPC�����ǡ�MIPS��ia32 �ϡ����Τޤ�ư���Ȥ����Τ�
�狼��ޤ�����

Mon Jul 12 12:54:14 JST 2004

������ɡ�MIPS�� $fp ������祪�ե��åȤˤ���Τ϶�ϫ�����͡�
  .frame $fp ����ʤ��ơ� .frame $sp �ˤ����ư���Τ���
���ȡ�goto ��Ϣ�ϡ�
    code_environment
    code_fix_frame_pointer
    leave
�λ��Ĥ�ľ���ʤ��Ȥ���ʤΤ͡�

�����ѹ��ϡ�ARM�Υ��ե��åȷ׻�����ꥪ�ե��åȤǹԤ������
��äƤ��������ɡ�ARM�Υ쥸���������֤�����ΰ�ˤ���С�
���뤤�ϡ��ɤ������ɤ����С�callee arg ��ޤ�Ƹ���˽���
��Ϥ���


�ʤ���ư�������쥸������ f4 �����ߤ����͡�

	    mov	ip, sp
	    stmfd	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
	    sub     fp, ip, #4
	    sub     sp, sp, #12
    .L3:
	    ldmea	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}
    .Lfe1:

�ޤ�ǡ�6809 �� PSHS X,Y,D ���͡�PULS X,PC �Ȥ���

�ʤ�����ɡ�������ȡ�

                      <-------r1_offset------------------------------>
                                      <------------lvar_offset0------>
                      <--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

�ˤʤ餶������ʤ����Ȥʤ�ȡ��ɤä����ϡ����ꥪ�ե��åȤ��ʡ�
�ޡ�callee ¦�Ǥ��礦���ޡ�����˽����������뤤�ϡ��ݥ���
�ǻؤ��Ƥ⤤�������͡��Ƥ�������reg_save �˴ؤ�餺��ޤä��ΰ�
��Ȥä��㤨�Ф����󤸤�ʤ�? �礷���̤���ʤ�������ư������
�쥸�������Ĥ����͡�

�⤦���������ꤽ�����͡�

Wed Jul 14 12:45:01 JST 2004

��äѤ���ư����������Ȥʤ�����˼�������ΤϤ��ɤ���

���졢? mc-code-mips.c ��
    rexpr_bool(int e1, int reg)
    {       
	int e2,reg0;
	int op = car(e1);
    return 0;

�äƤʤ��? ���ä�����ä��Τ�?

����äȥХ��äƤޤ������Ǥ⡢�ʤ�Ǥ�����? logic miss ������?

drexpr_bool for MIPS �Ϻ�äƤʤ��ߤ����͡�long long �Ϥ�������
���Ѥ���������

double/long long ����������ɤ���
    local const table  ��Ϣ³���������
    ����ΰ�˽�������ơ������ؤΥݥ��󥿤�local const table �������
�Ǥ����������... ���Ԥ��ȡ�search�����ɤ�����Ԥ��ȡ�double load
�ˤʤ�Τǡ��ʤ󤫷������ޤ��ް��פ���0��Ȥ��ʤ��Τ�ʤ󤫤͡�

adr �ʤ�Ƹ����Τ�����Τ���adr ���� ldmia �äƤʤ��ѡ�mvfs #0 
�ʤ�ƤΤ�����Τ���0,1,10 ������Τ��狼�뤱��...

float �� switch �äƤ����?

(�Ϥ������ɤ�����... �콵�֤����äƤ뤷...)

Sun Jul 18 20:45:48 JST 2004

�ʤ��ʤ�����ʤ��͡�GBA��Linux Zaurus ��ξ��������ʡ�
(��ä� ARM �˼��Ĥ����Τϼ��ԤǤ���)

alloca �ΰ���������ξ����äƤʤ��͡�

�ޤ�����Ĺ�������Ǥ⡢��ꤿ���ä�������顢�����ʤ���

��ư�������쥸������ĤäƤα����ʡ��쥸�����ϻȤ����Ӥˡ�
��󥻡��֤���ߤ����͡�

Wed Jul 21 13:51:56 JST 2004

���ơ�inc_inst �򡢤ɤ���äƤ���뤫....

copmpile error �ϼ�ä����ɤ���

Fri Jul 23 13:28:24 JST 2004

�ʤ�Ƭ�����ʤ��ʡ�

Sat Jul 24 19:27:55 JST 2004

����mc-arm �ǹ�ʸ���顼���Ǥ�Τϡ��ʤ󤫤�����Ƥ��뤫��
�ʤ�����ɡ������ľ�ܤ˥ǥХå�����Τϡ�����ޤ��ɤ���ˡ
����ʤ�����������������٤Υ��顼��ưŪ�˸��Ĥ��Ƥ����Τ�
�ߤ����衣


Tue Jul 27 13:45:21 JST 2004

.L183:
        mov     sl, r9
.L178:
        mov     r9, sl
.L175:
        mov     sl, r9
.L172:
        mov     r9, sl
.L169:
        mov     sl, r9
.L166:
        mov     r8, sl
.L163:

����ͤ���

�ޤ����Ǥ⡢�ʤ�Ȥʤ���ä��褿����

�ܤ��ܤ����ʤ�����ʸ��񤫤ʤ��㤤���ʤ��Τˡ�

Thu Aug 12 14:15:40 JST 2004

����äȴ֤������͡�ARM�⡢�⤦���������ɡ�c2cbc ���������
���ʤ��ȡ�C++ ������Ѵ��Ϥɤ�����? cfront �ä�ư���Τ���?

(�������ʸ�񤤤���ä�...)

Mon Aug 16 17:27:17 JST 2004

COND �ϡ��Ǥ������ CREG_REGISTER ��Ȥ��褦�ˤ������ɡ�
���ɥۥå����͡�(�ޤ��ͤ�)

COND�Υƥ��Ȥ����äƤʤ��ʤ���

Tue Aug 24 15:39:27 JST 2004

register �����Ƥ��ѡ��ۤȤ�ɤ�register var �˳�����Ƥ�褦��
�ʤäƤ��뤱�ɡ���ä�tmp���ʤ��ȷ׻��Ǥ��ʤ���͡�

Thu Sep  2 20:46:56 JST 2004

���������� Input register ��tmp�˻Ȥ�ʤ��ΤϤʤ��?

��Ĵ�˥Х����Ͽʤ�ǤϤ���������...

Sat Sep  4 18:04:40 JST 2004

INPUT/REGISTER �� double int register �� float register 
�ǰ�Ӥ��Ƥʤ���

Wed Sep  8 01:08:35 JST 2004

lvar_offset_label, r1_offset_label �äƤ����? fp ��
�ȤäƤ������顢����ʤ���⤢�뤬..

�ɽ��ѿ�����Υ��ե��åȤǥ������������ؿ��ƤӽФ���sp ���ե��å�
���Ѥ�ʤ顢����ʤ��Ϥ���

Sat Sep 11 15:13:33 JST 2004

��äѤꡢCSE ���餤���٤�����ʤ�? �ޥ��������������Ȥͤ���
   if (o==H1||o==H2|o==H3)
�ߤ����ʤ�Τ͡��ޤ��ͤ���

�Ǥ⡢��������ȡ�asm ���ʤ����Ǥ⡢��������� elimination 
���ꤿ����͡�

������ϡ�inline ���褫��

Tue Sep 14 14:36:15 JST 2004

arm lvar ��large offset ��ʤ�Ȥ����ʤ��ȡ�lvar intro
�Ǥʤ��Ƥ�Ǥ���Ϥ�����͡�

�����ɡ�ptr cache �� const list
�����Ū�˰��ˤǤ��ʤ�? ξ���Ȥ�const�����ͤ���

��������ptr cache �ϳ��ˤǤ���äƤ��ơ�nptr ������ˤ��Ƥ���
�Τǡ�����ä��񤷤���uniq nptr �����ƤϤ�Ƥ��Ф褤�ߤ���
������...

        str     r1, [fp, #0+.L3]
        str     r2, [fp, #4+.L3]
�ʤ�����ɡ�L3 ������ʤΤǤ���ˤʤäƤ��ޤ���(�ޤ������������)
�ޤ����Ǥ⡢L3 �ϵ���ˤϤʤ�ʤ��󤸤�ʤ�?

Wed Sep 15 16:50:46 JST 2004

basic �Υ쥸�����˺ܤä������򥹥��å����᤹�Ȥ���������������


��������C++ ��maglegation�򤤤��С�C++ �Ȥ���³��ǽ��
�����ɡ�


Wed Oct 13 21:06:31 JST 2004

mvn ��1's complement �ǡ�sub ��2's complement �ʤߤ����͡�
�ʤΤǡ�8bit const �λ��ˤ��������ʤ롣

32bit word ��alignment��4�Ǥʤ��ƤϤʤ�ʤ��餷����

0x20005cc <code_lvar_address+216>:      str     r0, [r11, -#22]
(gdb) p $r0
$13 = -1073742791
0x20005d0 <code_lvar_address+220>:      ldr     r0, [r11, -#22]
(gdb) si
(gdb) p $r0
$15 = -63324161
(gdb) p (char*) -1073742791
$16 = 0xbffffc39 " \004@L
(gdb) p (char*)-63324161
$17 = 0xfc39bfff <Address 0xfc39bfff out of bounds>
(gdb) quit

�����ࡣ

Fri Oct 15 08:46:59 JST 2004

        mov     ip, sp
        stmfd   sp!, {fp, ip, lr, pc}
        sub     fp, ip, #4
        sub     sp, sp, #16
        str     r0, [fp, #-16]    ����1
        str     r1, [fp, #-20]    ����2
        str     r2, [fp, #-24]    ����3
        str     r3, [fp, #-28]    ����4
           ...
        ldr     r2, [fp, #4]      ����5
        add     r3, r3, r2
        ldr     r2, [fp, #8]      ����6

���������쥸�����ΰ���ʬ�ϥ���ˤϼ���ʤ��ǡ��ɽ��ѿ�¦
�ˤ������餷����sp�ϡ�stmfd �Ǽ�ưŪ��Ĵ������뤫�顢sub sp
�϶ɽ��ѿ�ʬ������fp ��#4��������Ϥ���?

�Ǥ⡢������� va_next �����������ɡ�

Fri Oct 15 20:51:19 JST 2004

        mov     r3, #0
        str     r3, [sp, #0]
        mov     r3, #1069547520
        add     r3, r3, #3145728
        ldr     r0, .L28+388
        adr     r1, .L28+392
        ldmia   r1, {r1-r2}     @ double
        bl      printf

�äƤ櫓�ǡ��ޤ����ä�double/long�ϡ�Ⱦʬ�����쥸�������֤����
�ߤ����͡�

Sat Oct 16 19:12:31 JST 2004

�ޡ������ľ�ä�������ɡ�register �ϡ�input register �ʳ���
���� save ���Ƥ���ߤ������ʡ�frame ���碌�����ɤ�������

cmf f4,#0����f4 �����������Ƥʤ��������ߤ�����illigal instruction
�äƤ������ɡ� f4 ���ͤˤ��Τ�?

fdecl_struct(int fntype)
{
   ...
        mode=ADECL;
            args = 0;
            def(&str_ret);
            struct_return = list3(list2(LVAR,str_ret.dsp),sz,type);
            caddr(fnptr->ty) = glist2(POINTER,caddr(fnptr->ty));

�ʤ�����ɡ�����ä� save_input_register �����LVAR�ˤʤ�櫓
����͡�def �������ˤϥ쥸�����˳�����Ƥ����ǽ���⤢���͡�
�����������ȤϤʤ��Τ���

�ǡ�mc-parse.c �ǡ�
    if (struct_return) {
       ...
                gexpr(list4(STASS,rvalue(car(struct_return)),e,e1),0);

�äƤʤ�櫓����͡�

�ǡ�mc-code-arm.c �Ǥϡ�������dsp���ѹ�����뤫�����ʤ櫓�͡�(�����å�
�˳�����Ƥ��Ƥʤ�����)

�����顢struct_return �� save_input_register �ǽ�������ɬ�פ����롣

ARM�Ǥϡ�register�������ʬ��stack�˼���Ƥʤ��Τǡ�struct_push
�ǡ�����ʬ��register ��copy���ʤ��Ȥ��ᡣ�Ǥ⡢��������ȡ�����¦
�Ϥɤ������?
        mov     ip, sp
        sub     sp, sp, #8
        stmfd   sp!, {r4, r5, fp, ip, lr, pc}
        sub     fp, ip, #12
        sub     sp, sp, #96
��������ʤ��Ȥ�äƤ뤷��

Sun Oct 17 13:13:00 JST 2004

�ʤ� long long �˴ؤ��Ƥϡ�gcc �������빽���ְ�äƤ���ʤ���

signed char �˴ؤ��Ƥϡ�ldrsb �äƤΤ�����ߤ����͡��ʤ�ǡ�
arm-linux-gcc �ǤϤǤʤ��������?

Mon Oct 18 00:15:05 JST 2004

self compile ���̤�ʤ���¾�Υƥ��Ȥ�ͥ�褹��٤�����

Mon Oct 18 20:25:16 JST 2004

emit_copy �� offset �ΰ�������Ӥ��Ƥʤ��餷����
���ȡ� powerpc ��r3,r4,r5 ��Ȥä����֤�memmove���ƤФ��ߤ�����

�����󡢤�äѤ깽¤�Τ�쥸�����˳�꿶��ΤäƤ��ʤ���ɤ�
�ʤΤ͡��ä˥ͥ��Ȥ���ؿ��Ǥ�...

��¤�Τ�stack���ɬ�� align �����餷����

ARM �� bitield �ʤ������  |---====|=====|====----| �Ȼ��Ĥˤޤ�����Τ�
�������ߤ������͡�char �Ǥ� |--===|===--| �����뤷���äƤ��Ȥϡ����ʤ�
�Ѥ��ʤ��Ȥ�����Ƥ��Ȥ��ʤ������ʤ����Ǥʤ���С�����������ư��������ɡ�

�Ĥ�ϡ�stdarg �� bitfield ���������ޤ��������󤸤�ʤ�? stdarg �ϡ�
stdarg.h ��ʬ�Ǻ����ɤ��ߤ�����

Tue Oct 19 11:12:16 JST 2004

�ޤ���? �Υ��顼����
##      mode=(s==STRUCT?GSDECL:GUDECL);
# 1287: : creg=r4 freg=f0
        ldr     r4, [fp, #4]
        mvn     r7, #6
        cmp     r4, r7
        bne     .L713
        mov     r7, #2
        b       .L714
.L713:
        mov     r7, #3
        mov     r0, r7
.L714:
        ldr     r7, .L709+4
        str     r0, [r7, #0]
�ƥ��ȥ롼����ɬ�פ��͡�

(MIPS�Ȥ�PowerPC�Ȥ��������ֲ�������ä��ߤ���...)

C �ȤθƽФ�������Ƥ���(��äѤ�쥸����?) mc �� gcc �Υ��֥������Ȥ�
���ߤ�����Ȥ�����͡�

��ư�������ط��� Endian ����������

Tue Oct 19 19:07:57 JST 2004

        stmfd   sp!, {r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}

�äƤ櫓�ǡ�r0-r3 ��input register�ǡ�r4-sl ��register_var ��tmp
���ͤ�櫓���͡�r4����������register_var �˳�꿶�����þ�����������

�äƤ��Ȥϡ�����ѿ��ǤϤʤ��Ѷ�Ū�˥쥸�����ѿ���Ȥä�����
�ɤ��櫓������...

save_stack �� register var ��save ����ɬ�פϤʤ�������...

longlong_lib �� creg �� RET_LREG �ˤʤäƤ������ɡ����γ��ǡ�
emit_pop_free ������ˡ����ΰ�����RET_LREG�ȽŤʤäƤ��ơ�
����free����Ƥ��ޤ�����������ȡ�����emit_pop�ǡ���񤭤���Ƥ��ޤ���
�ʤΤǡ�RET_LREG�ˤ��ʤ��ǡ�lmove ���Ƥ��ޤ��Τ��ɤ���

align ����������

Sat Oct 23 23:33:11 JST 2004

struct ��Ȥä� interface ��register ��map���뤫�ɤ������ޤ���
�񤷤����ɤ͡�

��äѤ�arm��bitfield���碌��Τϻߤ᤿���������󤸤�ʤ�?
long long �ʳ��ϡ������礭�������б��Ǥ��롣long long �ΤϤ߽Ф�
�ϡ�����ä��н�Ǥ��ʤ���
      a:8 =>  a0:4<<4+a1:4
      a:8 = hoge =>    a0:4 = hoge<<4, a1:4 = hoge;
�Ȥ����褦��ʬ�򤹤�?

Sun Oct 24 14:19:13 JST 2004

code_frame_pointer �� code_environment ��Ʊ���ʤ�Ǥ�����...

����ʹ�¤�Τ�������������ȡ�

��ʬ���Ȥ��ŤʤäƤ���
   |----------|
       |----------|

�Ǥϡ�
   |----------|
            --copy-> |----------|
     ¾�Τ�Τ�����
            <-copy--
       |----------|
�äƤ��Ȥˤʤ롣

����ϡ�����äȼ�֤��礭����
   |--|---|---|
       |--|---|---|
��ʬ�䤹��(ʬ�䤬�٤����ʤ�ʤ�?)
   |---|--|---|
       |---|--|---|

ʬ��Ϥ�����͡���ʬ���Ȥ����ŤʤäƤʤ��Τ��ä���overappable copy
���롣
   |----------|----------|----------|
       |----------|----------|----------|

circular dependency ��recursive call����ɬ�פϤʤ��͡�

�ʤ󤫡���¤�Τ����١������å��ˤ������Ƥ����ᤵ��Ƥ���ߤ���

RSTRUCT �äơ������ˤ����?

�ʤ󤫡��֤ޤ���emit_copy ���ְ�äƤ���!��

PowerPC �ϡ�code �Υ쥸�����˳�����Ƥ�줿ʬ�Υ����å���ΰ���
�������ƤƤ���ʡ��ʤΤǡ�
## code carg6(int i, int j,int k,int l,struct arg args0)
##     goto carg3(args0,args0,i,j,k,l);
�ǡ�args0 ��copy��;�פ˽Ф�͡� �����⤺�������ѡ�(*)

̵���ǤϤ�������...

�Ǥ⡢����ǥХ��򸫤Ĥ����櫓����

�����֡�enbug ������ä���...

emit_copy ��memmove ������ˤϡ�offset ��̵�뤹�롣address + offset
���顢reverse �� address �ޤǥ��ԡ�����Ȥ�����̣�����顣

memmove �ϡ�����쥸����������Ƥ��ޤ��Τǡ�parallel assignment
�ΰ���ˤ����̤Υ쥸�����ϻȤ��ʤ���

PowerPC �� code segment �ǡ���������CALLER_ARG �Ĥޤꡢ�ؿ��ƤӽФ�
�Υ����å��ȽŤʤäƤ��롣code_disp_offset �Ǥ�Ĵ���Ǥ��ʤ��餷����
���ޤǤϡ�(*) �Τ�����;�פ˰���ѿ����äƤ����ΤǸ������ʤ��ä�
�餷����

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

¾�Τ��ɤ�ɤ�ư���ʤ��ʤ�...

Mon Oct 25 03:13:48 JST 2004

codegen �ǡ�jump ���Ƥ���Τ����ɡ������Ǥϡ�offset -1 �ǡ�
�ɽ��ѿ��Ȥʤ롣�ɽ��ѿ��򤽤Τޤ�code_segment �ΰ�����
���Ƥ���餷����

code_segment¦�Ǥ⡢Ʊ��offset�ǽ������뤬��ARM�ξ��ϡ�
offset 0- -xx �ޤǤϡ�register save �����롣�������٤�
���Ƥ��ޤ��餷����goto ���ˡ��ǡ���ä��Ȥ���error�Ȥʤ롣
register ��������save ����Τǡ����Ϥ狼�äƤ���Τǡ������
­�����ɤ����������ɤ͡�(���졢�����ä���...)

Mon Oct 25 19:36:16 JST 2004

�ʤ󤫡��Ǥ�����

�ޤ����쥸����ʬ�Υ��ե��åȤ�code_segment�Ǽ����Τ�ľ���Ƥʤ���
ARM �� bit field �η�ɤ���͡�

���Ȥϡ�
       inline
       CbC2C
       C2CbC
�������͡�

Wed Oct 27 08:48:37 JST 2004

MIPS��alloca�ϡ�$sp���ư����Τǡ�j �θ�Ρ�code segement ��
        lw      $gp,$L_41($sp)
�Ϥޤ����������̾�ϡ�
        lw      $gp,$L_41($fp)
���Ф롣�����顢alloca ��$gp���ư����ɬ�פϤʤ�����������code_segment
�� alloca �ϻȤ��ʤ���$gp ��sw���ʤ�����?

input interface ��¤�Τ� alignment ��64�ˤ���С��ޥå������ǽ����
����äȹ⤯�ʤ롣

const ���쥸�����˴��ˤ��뤫�ɤ���������å�����? �ޡ�����ʤ�����

ARM �� bitield 
    |---====|=====|====----|
    |--===|===--| 
�ϡ�mc-codegen ¦���н褷�ʤ�? char/short/int �� -> short/int/long
�ˤ�����ɤ��櫓����͡�

����ϡ�long �������Ϥߤ����Τ�int���äƤ狼�äƤ��롣

bit_filed
	bit_field(upper) << offset + bit_filed(lower)

bassign
	bit_filed(upper) = value >> offset;
	bit_filed(lower) = value << (32-offset-size);

bassop ....

��äѤ�����ᡣ

bit_filed �����ˡ��ɤ߹��ߤ��ʳ���
     upper2 << offset + (lower&mask >> 32-offset-size)
���뤫��

bit_field_repl,bit_filed_repl_const �Ϥ��Τޤޤǡ�
��������Ȥ��ˡ���� replace ���롣

����ʤ����Ȥ���

** �����ǤϤʤ��ơ�

long ��int��;�ä��Ȥ��γ��ݤ�����(int)(bitfield_opt)��stack����Ѱդ��롣
(new_lvar�Ǥ��礦��) get_register_var �Ǥ⤤������... ARM �Ǥϰ�̣�ʤ�
�������ʡ�

     mc-codegen:bit_field �Ǥϡ�load ������ˡ�bitfield_opt �ˤ�load
     code_bit_field �Ǥϡ�ɬ�פʤ�С�bitfield_opt �����ͤ��ɤ�

     mc-codegen:bassign �Ǥϡ�load ������ˡ�bitfield_opt �ˤ�load
     mc-codegen:bit_field_repl �Ǥϡ�ɬ�פʤ�С�bitfield_opt ���ִ�����
     �������ˤϡ�˺�줺��bit_field_opt ��񤭹���

     mc-codegen:bassop �Ǥϡ�tmp1 ���ɤ�Ȥ���bitfield_opt �ˤ⤤���

�Ǥ����󤸤�ʤ�? ��������...

Thu Oct 28 17:40:35 JST 2004

��������ѹ�����¿�����롣long long �ǥХ�����꤬�ޤ������
�ˤϡ���Ǽtype �� struct { int [3]; } �Ȥ��ơ�����ΰ�˳�Ǽ
���롣�ºݤˤϡ����ɥ쥹�����ä���뤳�Ȥˤʤ롣�ǡ�code_bit_
replace_const �ʤɤǤϡ����ɥ쥹���Ф��ƽ���������ɤ�������
����С�codegen ¦���ѹ���(�ۤȤ��)�ʤ��ʤ롣

�Ǥ⡢��������ȳ�Ǽ�����ͷ�����̤��ʤ��Ȥޤ����͡�

Fri Oct 29 04:19:58 JST 2004

code-* ¦�ˤ�type��������¤�Ȥ����Ϥ��Τ��ɤ��ʤ���

���Ȥϡ���Ǽ��>�ͷ��λ���bit���ͤν������ʡ�

���μ��bit-field �äơ�����ʤ顢inline �� *C* �ǵ��Ҥ����٤�
��Τ���͡�

Fri Oct 29 20:30:41 JST 2004

�Ǥ�������.... bassign �����sassign�ǥ��ɥ쥹�������Х���
����餷��������ϡ�;�פʥ��ԡ������äƤ⡢���Ϥʤ��Ϥ�
�ʤ������
diff test/bitfield.gcc.out test/bitfield.mc-arm.out
1058c1058
< 2:00000000 00000000 00000000 def00000 56789abc 00000234 00000000 00000000
---
> 2:00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
�ȸ������ǡ���񤭤��Ƥ��ޤ���

dum()��Ϥ����ľ�ä�������Τǥ쥸�����Υ��ƥʥ󥹤�
����餷����...

����ѿ���ptr cache����jump ��input argument regsiter ��
�����Ƥ��ޤ���ARM�ʳ��Ϥɤ����Ʋ����ʤ�? ñ�˥쥸����
���Ѥν��������ǡ��Ǥ��ǽ���Ϥ���äƤ��Ȥ���
jump �����usig_reg ������ɤ�������ɡ�

get_input_register* ��code�ξ����� using_reg ������ä����ɡ�
��������?

���äȡ�goto ����ư�������쥸�����Ϥ��򤢤ޤ�ƥ��Ȥ��Ƥʤ��͡�

bitfield �ϡ����ɥ쥹�Ϥ��ǡ��������ʤ������ɤ��͡�

Sat Oct 30 17:48:18 JST 2004

������������ѹ������Ĥ�...

  a = b = c = 0

�ǡ�a ����������ˤϤʤ�ʤ��Τ�? �̾�Ϥ���������ɡ�bitfield
�Ȥ��Ǥ�;���ɤ��ʤ��͡�

Sat Oct 30 20:39:34 JST 2004

MIPS ��$4,$5,$6,$7 �ϰ����Ϥ��˻Ȥ���櫓�����ɡ�
6,7��long long ������Ȥ��ˤϡ�$5 �ˤϡ�$6 ��Ʊ���ͤ�����?
���䡢bitfield1.c �� printf �� %lld �� %d �ˤʤäƤ��������Ǥ�����

ARM �� lreg ��regsiter �� lost ����Τ�ߤ���ʤ�...
use_input_reg(int reg,int mode) �äƤ�äѤꡢ����������͡�

�ʤ󤫡�ľ���Τ�5���֤⤫���ä��衣

ARM �Ǥϡ�use_int/use_longlong �η����֤��� lreg ��lost ����
�餷���Τ�����¾��mips/powerpc �Ǥϡ������������Ȥϵ����ʤ���
�ʤ�Ǥ�����?

Wed Nov  3 18:31:28 JST 2004

��äѤ깽¤�Τ�intñ�̤�ʬ�򤹤�������������ɤ��ʤ�͡���
������������ȡ�����ʹ�¤�ΤǤϥ���ѥ�����֤������ꤹ����
�Τȡ������ɤ��Ǥ����ʤäƤ��ޤ���

���������⡢�⤦�����ͤ���٤����ʡ�
   code f(int a,struct b) {
       goto g(b,a);
   }
�ߤ����ʾ����͡�

ʬ�򤷤Ƥ��顢�⤦���١�memcpy �ˤޤȤ��Ȥ�����⤢�뤱��...
�����١����ǤϤʤ��ơ�swap base ���ִ��ˤ���?
   for(i) swap(a[i],b[i]);
�ߤ����ʴ���?
   code f(struct a,struct b) {
       goto g(b,a);
   }
�ߤ����ʾ��ϡ�����ʤΤ�˾�ޤ�����...

ʬ�򤷤ƽ���¸���ä��ơ�address ��sort �����... memcpy
�ϸ��ФǤ���Ϥ�������...

����������������¸�ϡ�����Ū��swap�Dz��Ǥ���Ϥ���
    copy(a,b)
    swap(a,b)
���ȹ礻�ǡ���Ŭ�ʷ�̤�������Ϥ�����������С�save�Ȥ�
�򤷤ʤ��Ƥ��ࡣ
     (a,b,c) <= (b,c,a)
�ϡ�
     swap(a,b); swap(c,a);
�Ȥʤ�? ����?

case triple
       a     b       c
     |---||-----||---------| 
        b       c        a
     |-----||---------||---|

������

     circular_dependency =>   smallest dependent element
                              singleton or not

     swith(circula_depent(&small)) {
     case CIRCULAR_DEPEND:  save(small); remove(small); break;
     case DEPEND_SINGLETON:  memcpy(small); break;
     default: continue; // try another
     }

������ȡ�a ��save, b ��save�ǡ�c ��signleton �Ȥ������Ȥˤʤ롣
���䡢b ��singleton �ˤʤ뤫��? b&c ���Ĥ�memcpy�ˤޤȤ��
�Τϡ�����ۤɰ�̣�Ϥʤ���...

����Ǥ⡢
case eq
         a          b
     |---------|---------| 
         b          a
     |---------|---------| 
�ϡ�save code ���ФƤ��ޤ����ޤ�����ξ��Ǥ⡢a ���Ǥ������
�������͡����衢
     one integeter save
�������Ǥ���Ϥ���(�����swap) �ǡ�ʬ�򤹤�Ф����swap code�ϽФ롣

memcpy ���뤿��ˤϡ������������save���ʤ��Ȥ��ᡣ�����顢memcpy
�Ȥ�ξΩ���ʤ������󡣤����顢swap operation �ˤ���Τ��ɤ�������
case triple ��swap operation �Dz�褹����ˡ���ɤ��狼��ʤ���
       a     b       c
     |123||45678||9abcdefgh| 
     |-23||45678||9abcdefgh| {1}
     |423||-5678||9abcdefgh| {1}
�äƤʴ�������������ϡ�space/operation trade off �ʤ�?
       a     b       c
     |123||45678||9abcdefgh| 
     |-23||45678||9abcdefgh| {1}
     |4-3||15678||9abcdefgh| {2}
     |45-||12678||9abcdefgh| {3}
     |456||-2378||9abcdefgh| {1}
     |456||7-318||9abcdefgh| {2}
     |45678||-12||9abcdefgh| {3}
     |45678||9-2||3abcdefgh| {1}
     |45678||9a-||31bcdefgh| {2}
     |45678||9ab-||12cdefgh| {3}
     |45678||9abc-||23defgh| {1}
     |45678||9abcd-||31efgh| {2}
     |45678||9abcde-||12fgh| {3}
     |45678||9abcdef-||23gh| {1}
     |45678||9abcdefg-||31h| {2}
     |45678||9abcdefgh||-12| {3}
     |45678||9abcdefgh||1-2| {3}
     |45678||9abcdefgh||12-| {3}
     |45678||9abcdefgh||123| {-}
       b        c        a
�ǡ��Ǥ���ˤϤǤ�������....

����ȡ�memcpy�Ȥɤä���®�����ϥ������ƥ������memcpy�ˤ�롣

�����顢
    �������١���������¤�Τ�ʬ��
    �礭�ʤ�Τϡ�singleton/smallest detection ��ޤ����
    save ���礭������Ȥ��ˤϡ�circular dependent �����Ǥ���̤�Ф�
�äƤʴ����Ǥ����͡�

����̤ʤ�����ɡ�
       a   b       c
      |-||---||-------|
      123456789abcdefgh 
       a b1    c     b2    c_t + c_s ��swap
      |-||||-------||-|
      123459abcdefgh678 
      b2 b1    c     a     a_t + b2  ��swap
      |-||||-------||-|
      678459abcdefgh123 
        b     c      a     b2,b1 ��swap
      |---||-------||-|
      456789abcdefgh123 
�äƤʴ������礭�ʤ�Τ���swap���ʡ���������м�ưŪ��ʬ�䤵���
�Τǡ�ʬ���ɬ�פʤ��ʤ�?

     circular_dependency =>   smallest dependent element
                              singleton or not

     swith(circula_depent(&small,&large_conflict)) {
     case CIRCULAR_DEPEND:  
	if (size(small) < SAVE_MAX) {
	    save(small); remove(small); break;
	} else {
	    swap_divide(large_conflict);
	    reposition(conflict);
	    remove(large);
	    break;
	}
     case DEPEND_SINGLETON:  memmove(small); break;
     default: continue; // try another
     }

     swap:     ld  r0,(to);
               ld  r1,(from);
               st  r0,(from++);
	       st  r1,(to++);
               if (cnt-->0) goto swap

�äƴ���? swap ���줿�Ǹ夬���ɤ������ѥ�����ˤʤ뤫�ϡ�����ä�
������������ɤ͡�

Thu Nov  4 10:15:29 JST 2004

�����ʤ� long long ��������եȤ� > 32 �ξ���˺��Ƥ���͡�

Fri Nov 12 15:37:42 JST 2004

��äѤꡢrecord (taged union) ���ߤ�����͡�

    struct {
       enum {hoge0,hoge1,hoge2} i;
       switch(i) {
       case hoge0: struct {...} b;
       case hoge1: struct {...} c;
       case hoge2: struct {...} d;
       }
    } a;

    assert(a.i==hoge0);
    a.b.j = 3;
    assert(a.i==hoge0);
    printf("%d\n",a.b.j);

�����󡢤���ޤ��ɤ��ʤ��ʤ���������ä��顢����ʤ���͡�

Fri Nov 12 15:59:32 JST 2004

Template ���뤤�Ϸ��ѿ������줿���ʤ���͡������Ȥ��Ƥ⡢
��̸���������ʤ���

Sat Nov 13 11:05:06 JST 2004

main() { printf("%d,%d\n", -555>>3,-555/8); }
-70,-69

�ʤ�ۤɤ͡�

�ʤ� arm-linux-gcc ���Х��äƤ����...

    ltosop_register()
    {
    register long long i1,i2,i; 
    register unsigned long long u1,u2,u; 
    u1 = 632423423; u2= 32394234;
    u = 0;
        ....
    u = u1 & u2;
    printf("#2052:ltosop r u 6 %llu\n",u);

        sub     r6, fp, #48
        ldmia   r6, {r2-r3}
        sub     r7, fp, #48   <---?!
        ldmdb   r7, {r6-r7}
        and     r2, r2, r6
        and     r3, r3, r7
        sub     r7, fp, #64
        stmia   r7, {r2-r3}
        ldr     r0, .L640+92

�ʤ�Ǥ��͡�

Sun Nov 14 15:59:33 JST 2004

�褷��inline ��뤫��

   inline function (or parsed tree)
       // list4(INLINE,name,type)
       sc = INLINE
       attr = parse
   declaration (argument, local, static)
       list4(ST_DECL,next,NMTBL *nptr,stmode)        done by def (?)
   statement
       list3(ST_IF,next,list3(cond,then,else))
       list4(ST_DO,next,cond,while)
       list4(ST_WHILE,next,cond,while)
       list3(ST_FOR,next,list4(A,B,C,body))
       list4(ST_SWITCH,next,expr,body)
       list3(ST_COMP,next,body)
       list2(ST_BREAK,next)
       list2(ST_CONTINUE,next)
       list3(ST_CASE,next,label)
       list3(ST_DEFAULT,next)
       list3(ST_RETURN,next,expr)
       list3(ST_GOTO,next,expr,env)
       list3(ST_ASM,next,list4(A,B,C,D),e1)
       list3(ST_LABEL,next,label)
       list3(ST_COMMENT,next,comment)  (?)

  �����Ĥ���expr�ȽŤʤ뤱��... (�ޤ���?) RETURN, ASM

 (1) make inline tree
 (2) evaluate inline function (copy and partial evaluation)
        peval(inline_func,args)
    similar to the function call (with type check)

    const ����Τ��ʤ���
    builtin_constant_p ������

 partial evaluation ���ʤ��� code ��������? (�񤷤�...)
 partial evaluation ���Ƥ��� code �������롣�ޤ������ä��Ǥ��礦�ͤ���
    g_expr ���ѹ����ʤ��Ƥ⤹��

Mon Nov 15 17:37:57 JST 2004

code hoge() {  a; }
code hoge1() { b; }
 
�Ǥϡ�a-> b �ˡ����Τޤ������٤��������͡��ե����뤬ʬΥ�����
���Ͼ������뤬.... �������ʤ����˥��顼��Ф��ʤ��ȡ�

if (0) hoge; ��hoge����������Ƥ��ޤ���control ���ڤäƤ�Ф�͡�
���䡢�ä��Ƥޤ�����������jmp ����������Ƥ��ޤ��͡�checkret
�ǡ������å�����٤��Ǥ��礦��

checkret �ϡ�control �����������Ȥ����ǸƤФ��櫓�����顢�����
control=1 �ˤ���Τϡ�checkret �����Ǥ���٤���
    jmp(hoge) �ϡ�pending_jmp
�����ꤷ�ơ�checkret �ǡ�pending_jmp ����������櫓������
�ǡ�pending jmp �����ꤷ��label����������С�pending_jmp ��0��
���ꤵ���(������reference���줿�����Τ�ʤ�����label����������?)
label ��reference�������ɤ�����flag���դ��������ɤ�?

if (1) hoge else fuga ; �� fuga ����������Ƥ��ޤ���bexpr ��
always jump ���ɤ������֤������Ȥ�������...

Mon Nov 15 21:25:15 JST 2004

��¤Ū�ˤϤ���inline �ϡ�CbC �γ��ǹԤ���٤���Τ���͡�
�����ǽ������Ƥ⤤��������ɡ�����ϳ��Ǥ��٤���ΤǤ���

gcov ������!

Sat Nov 20 16:44:38 JST 2004

�Ť�switch�μ���������Ƥ��롣lazy jump �αƶ��餷����

PowerPC �� cmp immideate value ����Ϥ��Ƥʤ������Τ�����ϡ�
�Ѷ�Ū������������뤱�ɤ͡�ľ���Ȥ��ɤ��������⡣
MIPS �� ARM �ϡ�����äȤ������äƤ�ʡ�

���졢ʣ���Υե�����򥳥�ѥ��뤹��Ȥ������꤬���ä��褦��
������������... ����͡�
    ./mc-hoge mc-*.c


Sat Nov 20 22:00:36 JST 2004

�������ʤ󤫤��������˲����Ƥ��뤷��

�ʤ󤫡����������ĤäƤ��͡�ia32 �� long eq/ne �� int + unsigned ��
unsigned �ˤʤä��ꡣ

size < int ��struct ���ͤ��Ϥ�������������

Sun Nov 21 13:02:09 JST 2004

gexpr �� parse = list2(expr,parse); ���륪�ץ������դ���С�
inline �μ�֤Ͼ��ʤ��Ƥ��फ�⡣

static �Ǥʤ��ȼ��Τ���Ϥ���ɬ�פ�����櫓�͡�

const, volatile ���ʤ����礷����Ŭ�����Ǥ��ʤ����ޤ�������ޤ�
���ʤ��Ĥ��ʤ�����ɡ�

const, volatile �Ϸ��ˤ���Ȥ��ɡ��������ɡ�C �ˤ����ʤ鷿��������
storage class �Ǥ����ʤ��ñ�ʤ�����ɡ�sc �� bitmask �ˤ��뤫��
       extern (or static)
       extern used
       const

attr �ˤϡ�INLINE, CONST, VOLATILE ���Ȥꤢ�����Ϥ��롣

���������ѿ��ȶɽ��ѿ��ν�������줿�ͤ�ɤ����ˤȤäƤ���ɬ�פ����롣
�ɤ�? dsp? attr?

address �ΰ��������ְ�äƤ롣

����� .literal4 �äƤ����Τ˳�꿶����ߤ����͡�

l.c ��local type������Dz���Ƥ��롣list3 �ˤ�������������ʡ�

macro.c �� signed char �ΰ�¸��������?

size_t �˴ؤ��ƤϾ���Ĵ�٤����������󤸤�ʤ���?

## struct temp temp3 = {
##    .c = (int)&b,
##    .d = -10,
##    .a = (int)b
## };
.globl  _temp3
_temp3:
        .long 0       �Ϥ�?
        .space  4
        .long 59997
        .long -10
   space ��?
## 
## 

������������ʡ�

Mon Nov 22 22:34:03 JST 2004
  typespec
        if(mode==LDECL) return 0;   // not a type
        t= INT;                     // empty typespec 
�����顢
        smode = mode; mode = STAT;
        checksym(LPAR);
        mode = LDECL;  // typespec required this
        if((t=typespec(ctmode))==0) {
            mode = STAT;   // too late for expression 
            expr(0); 
������

hash ������ޤ��ɤ��ʤ����äƤ�������compiler ��20%��l.c ��98%...
rehash �ϡ�����ä��񤷤����롣����ơ����ץ���������Ǥ���
�褦�ˤ��뤫��

#define hash_value(hash,ch) (hash = (37*hash)^(11*(unsigned char)(ch)))
// #define hash_value(hash,ch) (hash = (37*hash)^((unsigned char)(ch)))

�ʤΤ�����open hash �����餫��

Wed Nov 24 13:21:03 JST 2004

�쥸������
        mov creg, regv
        add creg,$3
        mov regv, creg
�Ϥʤ�Ȥ���������͡�

goto ʸ�ǡ�parallel assignment ����
        i+1
�ߤ����ʾ��ˡ�
        mov creg,regv
        add creg,$1
        store creg,lvar
        load creg,lvar
�ߤ����ʤΤ�Ф��Ƥ��ޤ�������ϡ�i+1 ��is_memory �Ǥʤ����顣
ñ��ˡ������Ĥ��ȡ�source list ��i ������ʤ��Τǡ�i��overwrite
����Ƥ��ޤ���

�ǡ�is_contains_p1 �ǡ�source ����󤹤�ȡ�parallel_assign ��
�ߤޤ�ʤ��ʤ롣(����?)

remove0(soruce) �Ǵޤޤ�Ƥ���source��������ڤ�ʤ�������͡�
save �������ȡ�source ��񤭴�����櫓�����ɡ�������ʬ����θ����Ƥʤ���
�����󡢤���ä����᤿�����ɤ��ߤ������ʤ���

��äѡ��ޤ���� parallel assign �����ʤ��Ȥ���ʤ󤸤�ʤ���?

�����ȡ�
     i = i+1
�äƤΤ�����ȡ�i=i �Ǥʤ�����ä��ʤ��ǻĤ롣��������������ˡ��
�ʤ��櫓�͡��Ǥ⡢circular dependency �ˤʤ�ʤ��Τϲ���?

Thu Nov 25 09:05:24 JST 2004

progress ����ޤ����Ƥ��������顢�����Ǥʤ�Ȥ�����?

dependency singleton �򸫤Ĥ�����ɤ��櫓����͡�ʣ�����Ĥ��äƤ����
save ���Ƥ���Ϥ��ʤ櫓�����顣

circlular dependency ���Ϥ���Ƥ���Τ�source�Ρְ�ĤΥ���פǤ��äơ�
���Ǥʤ��������顢circular dependency �Ǥ�overlap �򸫤Ĥ����ʤ��櫓
���͡�

�����󡢤�äѤꡢadhoc �ʤ���ʣ���ˤʤäƤ��ޤ���������ä��顢CSE
�����ܤˤ�ä����������󤸤�ʤ����ʤ���

tmp1 �ϡ��㤦���顼���ʡ�code4 �����printf �� j ������Ƥ���͡�
�ʤ�ǡ�r30 �������offset ��caller �����⤹����?

r1 ���Ф������դ�������... ���������С�register ��ʬ�� code
segement �Ǥϥ���˳�꿶��ʤ��ä��äϤɤ�������? 

    list5(target,next, ty, source, source-dependency)

����͡���������ȡ�source list ����ñ���remove�Ǥ��ʤ���¾��
dependency���������㤦�����Τ�ʤ����顣�ʤΤǡ�source �ϡ�
���ơ�list5 ��ľ�ܻȤä������ɤ�? ��������С�target ��
remove ����м�ưŪ��remove�����Τ�...

progress �Ǥʤ�Ȥ�����ȡ���äѤꡢ���� save ������㤦�͡�
toplogical sort ���ʤ��Ȥ��ᤫ��

singleton ���ɤ���multi �ʤ�С��ɤ���save���������顣
list5 �Ϥ��ʤ��Ȥ��ᡣ


#define CHECK_HEAP(b) ({int _k=(int)(b);if(_k>heapsize)error(-1);_k;})
#define car(e) (heap[(int)(CHECK_HEAP(e))])

�ϡ�����������ɤ�������Υ���ѥ��뤬�ְ�äƤ���ߤ����͡�

�äƤ�������expr() ��� docomp ���¹Ԥ���ƥ���������������㤦����
�ޤ���ʡ����Ȥ���������ˡ�Ȥ��Ƥ�... (�����󡢻פ��դ��ʤ��ʡ�
����ʤ󤸤�ʤ���?)

ñ�ȤΥ��֥롼������������ơ������ؤδؿ��ƤӽФ��ˤ����?
code �����Ϥ�­���ʤ��ȤǤ��ʤ�����
	b hoge
    haga:
	fuga
	st value
	ret
    hoge:
	bl haga
	value 
�ޤ�������������ɡ���Ⱦ�ξ��ϡ�ɬ�פʤ������͡�

������������ȡ�({   goto exit0;  }) �ߤ����ʤΤ��������
	b L1
    L2:
	fuga
	st value
	j L3
    L1:
	.........
	b L2
    L3:
	value 
�Ǥ�����? �Ϥ���

Sat Nov 27 08:51:01 JST 2004

({}) �ǡ�init_vars ��nest�����ǽ��������Τ�˺��Ƥޤ�����

register stack ���ۤʤ�Τ���þ���Ƥ���ߤ�����

    ## 	if (car(ns)==sc) {
    ## (heap[(int)(({int _k=(int)(ns);if(_k>heapsize)error(-1);_k;}))])
	    b	L_2215
    L_2216:
    # 3764: gexpr_init: creg=r11 freg=f14
	    lwz r11,lo16(-16)(r30)
	   ....
    L_2215:
	    lwz r11,lo16(28+L_2206)(r30)
	    b	L_2216

�ɤ����褦���ʤ���

Sun Nov 28 02:41:11 JST 2004

> L_code_postinc$non_lazy_ptr:
>       .indirect_symbol _code_postinc
>       .long   0

�ʤ�����ɡ�PowerPC �ǡ�
     �ؿ��Ȥ��ƻȤ��Ƥ��� is_function && sc==EXTRN1
           binding helper ɬ��
           non_lazy ������
�ȡ�
     ����ѿ��Ȥ��Ƥ��Ȥ��Ƥ���
           binding helper ����
           non_lazy �Τ�ɬ��
����̤���ɬ�פ�����ߤ����͡������ parse.c ���ɲä���ɬ�פ����롣

��äȤ⡢.long 0 ��;�פ˽��Ϥ�������������

Sun Nov 28 03:42:04 JST 2004

float/double/longlong ��code segement argument �Υƥ��Ȥ򤷤Ƥʤ���

ia32 �� ({}) ������������

Sun Nov 28 15:49:54 JST 2004

listn �� object ���Ѥ���?

   struct nodes {
      union {
	  int tag:12;
	  int type:4;          LONGLONG,INT,SHORT,CHAR
	  int unsigned:1;
	  int arity:4;
	  int size4:4;
      } tag;
      int next;
      union:tag {
	  int arg0,...argn;
      }
   }

Mon Nov 29 11:55:14 JST 2004

attr �ϡ�Ϣ�ۥꥹ�Ȥˤ���٤�����

partial evaluation �򡢤ɤ��ʳ��ǹԤ����äƤ������꤬����Τ���

expr15 (function call)

inline �ں����κ����Ÿ������ȷ����֤�Ÿ�����뤳�Ȥˤʤ롣
���ʤ��Ƥ��ɤ���... �����⡢ST_* �� expr ����˻ĤäƤ��ޤ�
�Τǡ�g_expr �ǡ�ST_* �򰷤����Ȥ�ɬ�ܡ��äƤ��Ȥ��ѹ����빽
�礭����������Ÿ������� binop �κ�Ŭ���ˤҤä�����ΤǴ�ñ��
docomp ��Ʊ��������ɬ��?

function (codegen)

������Ÿ������ȡ������Ȥ����ѿ������������ʤ��ʤ롣���٤졣

�äƤ��Ȥϡ�expr15 �ǡ�partial evalucation �Ϥ�롣inline
���Ÿ�����ʤ��Ȥ��ơ��Ĥä� ST_* �ϡ�g_expr �ǽ�������
�äƤ��ȤǤ��͡�

static �Ǥ�ݥ��󥿤���줿�ꤹ��ȴؿ�����������ɬ�פ����롣
extern �ʤ顢�ʤ����顣����ϡ���ʬ�Ǥ��ʤ��ȥ��ᡣ�ޤ���
inline �δؿ��ꥹ�Ȥ���Τ��ɤ�����������ɡ�

Wed Dec  1 18:40:37 JST 2004

chk �ϡ�mc-code-*.c �˸����٤��ǤϤʤ���

static  �� used �äƤ���°�����ʤ��Ȥ���äȤޤ�����compiler warning
�����٤�������

switch(5) �ߤ����ʾ���one path�Ǽ�갷���Τϡ�����ä����ݡ�
     switch(5) 
        for() {
	default: ...
        case 3: ...
        case 5: ...
        case 7: ...
        }
�ߤ����ʾ�礬����櫓����͡������⡢default �����뤫�ɤ���
�ϡ�switch �ξ��ǤϤ狼��ʤ�����cslist ������å�����Ф�
���뤫���Ǥ⡢default code ��������뤫�ɤ����ϡ�default 
�򸫤Ĥ��������ǤϤ狼�ꤨ�ʤ���

pexpr �Ǥϡ���äȾܤ�������������Τǡ�����ñ�ˤʤ롣

Thu Dec  2 12:06:22 JST 2004

attribute �ͤ����������ʤ��ͤ���

inline �ϡ����Ȥ� partial evaluator �������͡�

gexpr �Ȥ���ʤ������ǡ����٤Ƥ�copy����ɬ�פ����롣lvar �ϡ�
ɽ�������촹����disp �ϡ�����ʬ�����ä����롣register ����ϡ�
���λ���õ�����Ȥˤʤ롣pfdecl �Ǥ�쥸�����Ϻ���ʬ���ʤ���
�����ʤ�������ɤ͡�

partial evaluator �äƻפä�����̤�¿���ʤ���

Fri Dec  3 12:47:50 JST 2004

inline �ΰ�����׻����ơ�vartable �˳�꿶�롣pexpr �������
�顢���Τޤ�����ˡ��ѿ����ä��� alias ���򤱤ʤ��Ȥ����ʤ�
�Τǡ�new_lvar & copy ���ѿ��Ǥ⡢const (read only)�ʤ顢��
�Τޤ޻Ȥä��ɤ������Τ�����ϡ�const �ä�������ʤ��Ƥ⥳��
�ѥ�������Ǹ��ФǤ��뤱�ɤ͡����Υ���ѥ���Ϥ��ܤ����ˤʤ�
�ǡ�

ʣ���ʼ��ʤ��ѿ������(new_lvar)������������(����parse���դ�
�ä���)ɬ�פ����롣�ʤ�����ɡ���󤷤��Ȥ��Ƥʤ��ʤ顢��
�Τޤ޻ȤäƤ��ɤ�����ǻȤ��ʤ���ǽ����⤤�Τǡ����Ρְ�
��פΰ�̣�Ϸ빽ʣ����attr ��ɾ�����줿�ɤ�����Ф��Ƥ�����
���ɤ�? �������������Ѥ�������ϡ��Ȥ��Ƥʤ��Ƥ⡢����
ɾ������ɬ�פ����롣f(k,i++) {ret k;} �ߤ����ʾ�硣�����⡢
f ������ɾ������ɬ�פ�����Τ���i �����θ�Ȥ��ʤ��ʤ�¹�
����ɬ�פʤ���.... �����ѤΤ���ʤ��䡢eval���ʤ�����Ƚ
�ꤹ��Τ��񤷤����顢̵��������Ǥ��礦�͡��Ǥ⡢������asm
�˿��碌����Ȥ����뤱�ɡ�

     vartable     argument (-4)
        -> ptr    local    (0)
                  local    (4)

�äƤʴ���? argment size �ϡ��ɤ���äƷ׻��������ä�?

���ȡ�return value ���֤���������... �ʤ����ϴ�ñ�����ɡ�
������ϡ�
    if()�˻Ȥ�����
    �����������
    �Ȥ��ʤ����
�Ȥ����͡�ST_COMP�ˤ��뤳�Ȥϴ�ñ�ʤ�����ɡ�;�פ�
�ѿ���ɬ�פˤʤ롣COMMA �Ǥ����Τ���
     if() { retrun ...} else { return ... }
�Τ褦�ʾ��Ϥɤ�����? COND ���Ѵ�����?
     while() { return hoge; }
��?
     ({ while() { ret = hoge }; } ret;)
���ʡ�����Ū�ˡ�
    ({hoge....  ret=hoge.... ; ret;})
�ˤ���? hoge ����¤�Τξ���....

goto ����äƤ������⤢�꤫��
         { return exp; ... } =>   {  exp; goto exit; ... exit: }
�ˤ��롣����������ѿ������ס�nest �������ˤ��ᤫ�����䡢goto
���ʤ��Ȥ���ʤΤ���pexit_label �äƤΤ�����櫓�͡�

ñ��ʾ���ñ��ˤ���ˤ�? ñ��ǺǸ�λ��������̰�������?

local �ѿ���Ȥ���Τ����������������ɤ������... ����ˤ�
2 pass ɬ�ס�rechability ��2pass�Ǥʤ��Ȥ��ᤫ���������ɤ���
��öŸ�������塢���פʥ����ɤ�������äƤ��������Ǥ����͡�
�����Ǥʤ��� switch �����ץ����ɤ�������ʤ�?

pcontrol �ߤ����ʤΤǽ���Ǥ��ʤ�? pcontain �ߤ����ʴ����ǡ�
ľ����ST���¹Ԥ����(���⤷��ʤ�)�����ɤ�ޤ�Ǥ��뤫�ɤ���
��Ƚ�Ǥ��롣pcontain = pcontrol ��or�ߤ����ʴ���?

Sat Dec  4 12:24:26 JST 2004

����ϡ�is_readonly() ����? (�Ȥꤢ����)������㤦�äƤ�����
�⤢�뤱�ɡ�is_readonly �ǡ�vartable �˳���tree�򤤤��ȡ�parse
tree �˳���lvar��������ࡣ������̤�����ˡ��ɬ�פˤʤ롣
����ϡ��ޤ���debug �Τ���ˤ�ɬ�פ������ɤ�������ɡ�type tree
����ˡ�list2(KONST,e) �򤤤��ȡ�¾�η������å��� == �Ǥ�
���ޤʤ��ʤäƤ��ޤ���has_type(INT,t) �ߤ����ʷ�? ����ϡ���
�äȤ��������롣���⤽��const�����������Ǥʤ���С����٤Ƥ�
�����פ�*C�ߤ����ʤΤ���? �����ʤ��ܤǤ��������������͡�
compund type �ˤ�const���դ��Ϥ������顣const struct hoge
�ߤ�����?

list2(LVAR,hoge,fuga) ��hoge��­��������褦�ʥ����ɤϤޤ�����
���������С�����ѿ��ΰ������Ȥ��Ϥ���ޤ��äƤʤ��ʡ�

Sat Dec  4 13:18:05 JST 2004

��������inline function ��continuation �äƤ������꤬�����
����������󡢳��δؿ��������ɤ��櫓�ʤ�����ɡ�����꤬
�ۤäƤ��ޤ���inline ����������뤫�ɤ����ˤ�äưۤ롣inline
�γ���ɬ�����äƤΤϡ��ɤ��餫�Ȥ������ưפ˼¸��Ǥ��롣��
�ä��ꡢreturn/env ���Ϥ��Ƥ����ɤ����顣

goto �Ǵؿ���Ǥ�դΰ��֤�����äƤΤ�Ͷ��Ū��������������
����Ū�ǤϤ���������... ��ʸ���ɤ��狼��ʤ��ʡ�setjump ��
�ͤù����äƤΤϰ�Ĥβ����ˡ����

    if (setjmp(hoge)==0) {
       goto f(&hoge);
    }

code f(jmp_buf *hoge) {
    goto hoge(1);
}

�Ǥ���? ���������С�code �����longjmp ����Ȥɤ��ʤ�������?
�ɽ��ѿ��ϲ����Ƥ��ޤäƤ���Τǡ��ƤӽФ����ؿ��ˤ����ʤ��͡�
�ޤ�����äѤꡢ���������褦�ˤ���󤸤�ʤ���? setjmp ��ʸ
�ϡ�����ޤ��ɤ��ʤ�������򤤤��ʤ� return/environment���ɤ��ʤ�
���ɤ͡�shift/reset �ߤ����ʹ�ʸ���ɤ���?


Sun Dec  5 18:14:05 JST 2004

�ؿ��ΰ�����const�ξ����ɤ��ˤȤäƤ��������ɤ��狼��ʤ���
��äѤ� CINT �Ȥ����? ��ɡ�const �äơ����٤Ƥη���ľ�򤷤Ƥ���
���顢�����������ˤ��ʤ���С�tree �ǻ����ʤ��Ȥ����ʤ���͡�
��������ȡ�������Ȥ����ǡ�pointerȽ�Ǥ����äƤ��ޤ��������
���줷���ʤ���������ϡ�
   #define TYPE(a) (a & 0xfffffffe) 
   #define IS_CONST(a) (a & 1) 
�Τ��ޤ�? ���㤡��
   #define IS_UNSIGNED(a) (a & 2) 
�Ȥ��⤤���?

����ϡ��ѹ����礭���Τǡ��Ȥꤢ������mc-inline.c �Υ��顼��
�ȤäƤ���ˤ��뤫��

Tue Dec  7 12:19:08 JST 2004

lvar �������ִ�����ΤϤޤ��������ե��åȤΥ��������䤹�����ɤ���
��������פ����ɤ͡�

Wed Dec  8 13:04:18 JST 2004

������....
       type tag
�ͤ���

     type tag                            10bit
��°����
     signed/unsigned                      1bit
     size                                 4bit   (double/float)
     const                                1bit
     volatile                             1bit
     restrict                             1bit
     assop                                1bit                           
     arity  (number of recursive tree)    4bit
°����16bit �Ȥ�٤��Ǥ��礦�͡�
     ATTR(tag,size,sign,assop,arity)
        (tag<<16)+sign+(size<<1)+(assop<<9)+(arity<<12)

CONV �� ICONV,FCONV + source type (INT) �Ȥ��������ߤ������͡�

�󡼡��ʤ󤫤��ޤ������ʡ�

Thu Feb 17 13:07:36 JST 2005

�ޤ����������������Ƥ���衣string �� const �κ����Ѥ����ޤ������͡�

Tue Mar  1 14:55:55 JST 2005

arm �ʤ�����ɡ�post increment �Ȥ������͡����ܤ餺�ˤ������
        ldrb    ip, [r0, #1]!
���ȡ�arm �ϡ�predication ������Ȥ��ʤ���gcc�ˤϾ��Ƥʤ��͡�
�ޤ����Ǥ��ʤ����ȤϤʤ�����������ɡ����ɤ���������peep hole
Ū��? �ޤ���inline mode �Ǥ�뤷���ʤ��Ǥ��礦�͡�

        sub     ip, fp, #68
        ldmia   ip!, {r0, r1, r2, r3}
        stmia   lr!, {r0, r1, r2, r3}
        ldmia   ip!, {r0, r1, r2, r3}
        stmia   lr!, {r0, r1, r2, r3}

�����.... memcpy �ʤΤ���

Sat Jul 30 14:41:54 JST 2005

������function �η���list node ��VOID�Ȥ���primitive�������äƤ��ޤä�
����͡�����ϡ��ʤ󤫡���ä��ޤä����������뤬... �ɤ��⡢��Ȥ��
���ޤ�����Ȥ��Ƥʤ��ơ�type<0�Ǥ� car(type)�Ȥ���äƤ��ߤ������͡�

inline code �äƤΤϤ��ꤨ���?

�����Τ�ʤ��� gcc �� .s ��#�ޥ�����Ÿ���򤹤�褦�ˤʤäƤ�͡�

    #include_next <stdarg.h>

�Ǥ�����?!

    ./mc1 -s -ob10.s mc-parse.c
    /usr/include/sys/cdefs.h:335:Macro syntax
    #  error Unknown architecture

���Υ��顼�Ϥʤ󤫤��ä���... __ppc__ ���������Ƥʤ��Τ������ʤ��Τ��衣
ifdef �򸫤�Ȥ��ˤ� EMPTY �ˤʤäƤ�ʡ�

##     nptr_pool->ptr += sizeof(NMTBL);
## 4074: gexpr_init: creg=r3 freg=f14
        lwz r3,0(r11)                     nptr_pool ���ɤ߹�������
        stw  r3,lo16(-20)(r30)
        la r3,lo16(-20)(r30)   
        la r10,lo16(-20)(r30)
        addi r10,r10,lo16(24)
        stw r10,0(r3)

������ʡ�

iassop �� hoge += const �ν������ְ�äƤ����ߤ�����¾�Τ�?!
���⤽�⡢��������黻�ν����äƤ����������?

���Ĥɤ��ǡ������ʤä��Τ�... �äơ����⤽�⡢�����������Τ�
�Ѥ���͡�

lassop ��Ʊ�����꤬���ä��͡�
        /*  new = &e2 */
        /*  *new = *new op e3 */
        n = list3(LVAR,new_lvar(size_of_int),0);
        g_expr_u(assign_expr0(n,list2(ADDRESS,e2),INT,INT));
        g_expr(assign_expr0(rvalue_t(n,INT),
            list3(op,rvalue_t(list2(INDIRECT,rvalue_t(n,INT)),t),e3),t,t));
        free_lvar(cadr(n));
���⤽�⡢�ʤ�Ǥ����ʤ��? e2 ���ˤ��ʣ���ʾ��ʤ�����?
get_register_var ���ʤ���?

�ʤ�ǡ����ΰ�����Ϫ�����ʤ��ä��Τ��������...



Mon Nov  7 20:30:26 JST 2005

MIPS �ǡ�
        jal fptodp
�ǡ��ƽ�¦�ζɽ��ѿ�������äƤΤ��ޤ�����餷����

����ʤ��ߤ�����

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

�ʤ�����ɡ�int �Ȥκ��߾����ǤϤ����ʤ�ʤ��餷����

$4 ���Ȥ��Ƥ���� $f12 �ϻȤ鷺�� $5 ��Ȥ��Ȥ������ˤΤ褦�Ǥ��͡�

Tue Nov  8 20:20:29 JST 2005

��¤�Τζɽ��ѿ��ν�����˼���񤱤ʤ���������������ɤ���������å�����ɬ�פ��ꡣ

goto �� struct ��Ĥ���������ˤȤä��Ȥ��ˤ��ޤ�ư��ʤ�.. (�äƤ�������
int �ʳ��ΰ������㤦�ޤ�ư��ʤ�   )�äƥХ���ľ���ޤ�����

ia32 �� emit_copy ��̵�¥롼�ס�

Thu Nov 10 18:46:39 JST 2005

ia32 ��float drindirect ��offset

��¤�Τ�alignment���äƤޤ���Ǥ�����

Unioon ��disp �η׻����Ѥ���ʤ���?

    } else if (mode==GUDECL||mode==LUDECL) {
        // disp = ((disp+(size_of_int-1))&~(size_of_int-1));
        if (type>0 && car(type)==BIT_FIELD) {
            cadr(caddr(type)) = 0; sz = size(cadr(type));
        }  else {
            sz = size(type);
        }
        fields = list4(type,fields,(int)(n->nm),0);
                                                ^^^ disp ����ʤ���?
    ....

    case GUDECL: case LUDECL:
        if (disp < sz) disp = sz;
        return n;

�� union ����disp�����̰����Τ褦�Ǥ���... ����ޤ�ƥ��Ȥ���Ƥʤ��ʤ���

Sat Nov 26 09:53:48 JST 2005

MIPS �ǡ�
code segment ��� float/double conversion �θ������ѿ��˥������������
code dump �����Ǥ���...

      l.s $f12,16($11)
      jal fptodp
      sw $2,16($sp)
      sw $3,20($sp)

0x400ab0 in print_foo ()
pc =00400ab0 fp =7ffff900 r2 =00000012 r3 =00000003 r4= 7ffff670 r5= 00000000
r6 =00000012 r7 =00000000 r8 =00000c00 r9 =00000010 r10=00000000 r11=10000130
0x400ab0 <print_foo+32>:        jalr    $t9
(gdb) ni
0x400ab8 in print_foo ()
pc =00400ab8 fp =7ffff900 r2 =00000000 r3 =40100000 r4= 00000000 r5= 800fffff
r6 =7fffffff r7 =00000000 r8 =00000000 r9 =00100000 r10=00000000 r11=00000401
0x400ab8 <print_foo+40>:        lw      $gp,64($s8)
(gdb) p (void*)((int)$gp)
$3 = (void *) 0x10008030
(gdb) si
0x400abc in print_foo ()
pc =00400abc fp =7ffff900 r2 =00000000 r3 =40100000 r4= 00000000 r5= 800fffff
r6 =7fffffff r7 =00000000 r8 =00000000 r9 =00100000 r10=00000000 r11=00000401
0x400abc <print_foo+44>:        sw      $v0,16($sp)
(gdb) p (void*)((int)$gp)
$4 = (void *) 0x0


�狼��ޤ�����code segment ����Ǥ� jal ����ʤ��� 

        la      $25,fptodp
        jalr    $25
        lw      $gp,$L_7($sp)

���ʤ��㤤���ʤ��ä�������ʤ�Ǥ�������˺�줿��($fp ��Ȥ����㤦����ʤΤ�)

Sun Nov 27 15:04:31 JST 2005

code ����ʤ��� _code �ˤ����?

function call �� code segment ���Τǽ񤱤�С�mc-code-xxx.c ����ô������
������ɡ�asm ��ʻ�Ѥ�? �Ǥ⡢������ʬ���Τ� system ��¸������ʤ���

S����ʸ��Ƴ������? mc-parse.c �Υ�����������ʬ��ʬΥ���ʤ��ȡ�

recursive type �γ�ĥ�������͡��Ǥʤ��� code segement �η������Τ�
���������ʤ���

    typedef hoge(arg) { ...; }  hage;

�ǡ�hage ��hoge����ǻȤ���褦�ˤ���� C �Ȱ�̣���Ѥ�äƤ��ޤ�����
one path compile ���ˤ�����


Sun Dec  4 14:16:24 JST 2005


��¤�Τν�����ǡ���¤�ΤΥͥ��ȤȤ������̵�뤷�ơ����餺�顢
�¤٤�äƤΤ���餷����

   sturct hoge { int a; double b[3]; } = {1,2,3,4};

�ߤ����ʡ����ϡ����顼�ˤʤ뤱�ɤ͡��������������Ȼפ����ɡ�