llvm.stg

c--词法分析

group LLVM;

item(st,s,e) ::= <<

;$s$
  $st$
;$e$

>>

declare_global_array(ref,size) ::= <<
$var(ref)$ = weak global [$size$ x int] zeroinitializer
>>

declare_array(ref,size) ::= <<
$var(ref)$ = alloca [$size$ x int]
>>


read(ret,tmp1,tmp2,tmp3,tmp4,tmp5) ::= <<

; Start Read Statement
  $var(tmp1)$ = alloca [100 x sbyte], align 16
  $var(tmp2)$ = load %struct._IO_FILE** %stdout
  $var(tmp2)$ = call uint %fwrite( sbyte* getelementptr ([8 x sbyte]* %str, int 0, uint 0), uint 7, uint 1, %struct._IO_FILE* $var(tmp2)$ )
  $var(tmp3)$ = load %struct._IO_FILE** %stdin
  $var(tmp1)$ = getelementptr [100 x sbyte]* $var(tmp1)$, int 0, int 0
  $var(tmp4)$ = call sbyte* %fgets( sbyte* $var(tmp1)$, int 100, %struct._IO_FILE* $var(tmp3)$ )
  $var(tmp5)$ = call int (sbyte*, sbyte*, ...)* %sscanf( sbyte* $var(tmp1)$, sbyte* getelementptr ([3 x sbyte]* %str, int 0, uint 0), int* $var(ret)$ )
;End Read Statement

>>

break(lab) ::= <<
;Break statement
  $branch(true=lab)$
>>

while(expr,stmt,ref,tmp1,start,block_begin,end) ::= <<
$branch(true=start)$
$label(start)$
$expr;separator="\n"$
$comparison(type="ne",ret=tmp1,ref1=ref,val=0)$
$branch(ref=tmp1,true=block_begin,false=end)$
$label(block_begin)$
$stmt;separator="\n"$
$branch(true=start)$
$label(end)$
>>

if(expr,true,false,tmp1,lab1,lab2,lab3,ref) ::= <<
$expr;separator="\n"$
$comparison(type="ne",ret=tmp1,ref1=ref,val=0)$
$branch(ref=tmp1,true=lab1,false=lab2)$
$label(lab1)$
$true$
$branch(true=lab3)$
$label(lab2)$
$false$
$branch(true=lab3)$
$label(lab3)$
>>

or(ret, expr1, expr2, ref1, ref2, tmp1, tmp2, lab1, lab2, lab3,lab4) ::= <<
$declare(ret)$
$expr1;separator="\n"$
$comparison(type="ne",ret=tmp1,ref1=ref1,val=0)$
$branch(ref=tmp1,true=lab2,false=lab1)$
$label(lab1)$
$expr2;separator="\n"$
$comparison(type="ne",ret=tmp2,ref1=ref2,val=0)$
$branch(ref=tmp2,true=lab2,false=lab3)$
$label(lab2)$
$val_assign(expr="",r=ret,val=1)$
$branch(true=lab4)$
$label(lab3)$
$val_assign(expr="",r=ret,val=0)$
$branch(true=lab4)$
$label(lab4)$
$access(target=ret,source=ret)$
>>

and(ret, expr1, expr2, ref1, ref2, tmp1, tmp2, lab1, lab2, lab3,lab4) ::= <<
$declare(ret)$
$expr1;separator="\n"$
$comparison(type="ne",ret=tmp1,ref1=ref1,val=0)$
$branch(ref=tmp1,true=lab1,false=lab2)$
$label(lab1)$
$expr2;separator="\n"$
$comparison(type="ne",ret=tmp2,ref1=ref2,val=0)$
$branch(ref=tmp2,true=lab3,false=lab2)$
$label(lab2)$
$val_assign(expr="",r=ret,val=0)$
$branch(true=lab4)$
$label(lab3)$
$val_assign(expr="",r=ret,val=1)$
$branch(true=lab4)$
$label(lab4)$
$access(target=ret,source=ret)$
>>

branch(ref,true,false) ::= <<
$if(false)$
br bool $var(ref)$, label %$link(true)$, label %$link(false)$
$else$
br label %$link(true)$
$endif$
>>

comparison(type,ret,expr1,expr2,ref1,ref2, val) ::= <<
$expr1;separator="\n"$
$expr2;separator="\n"$
$if(val)$
$var(ret)$=set$type$ int $var(ref1)$, $val$
$else$
$var(ret)$=set$type$ int $var(ref1)$, $var(ref2)$
$endif$
$to_int(ret)$
>>

not(expr,ret,ref) ::= <<
$expr;separator="\n"$
$var(ret)$ =  seteq int 0, $var(ref)$ 
$to_int(ref)$
>>

to_bool(ref) ::= <<

$var(ref)$=cast int $var(ref)$ to bool 

>>

to_int(ref) ::= <<

$var(ref)$=cast bool $var(ref)$ to int

>>

declare(r) ::= <<
$var(r)$ = alloca int
>>

get_array_ref(ret,size,index,name) ::= <<
$var(ret)$ = getelementptr [$size$ x int]* $var(name)$, int 0, int $var(index)$
>>

array_assign(val_expr, var,tmp1, val_ref,index_ref,index_expr,ret,size) ::= <<
$val_expr;separator="\n"$
$index_expr;separator="\n"$
$get_array_ref(ret=tmp1,size=size,index=index_ref,name=var)$
store int $var(val_ref)$, int* $var(tmp1)$
$access(target=ret,source=tmp1)$
>>

var_assign(expr, var, ref, ret) ::= <<
$expr;separator="\n"$
store int $var(ref)$, int* $var(var)$
$access(target=ret,source=var)$
>>

val_assign(expr,r,val) ::= <<
$expr;separator="\n"$
store int $num(val)$, int* $var(r)$
>>

access_readonly(target,source) ::= <<
$var(target)$ = int $var(source)$
>>

access_array(ret,size,index_expr,index_ref,tmp1,name) ::= <<
$index_expr;separator="\n"$
$get_array_ref(ret=tmp1,size=size,index=index_ref,name=name)$
$var(ret)$ = load int* $var(tmp1)$
>>

access(target,source) ::= <<
$var(target)$ = load int* $var(source)$
>>

create(r,val) ::= <<
$declare(r)$
$val_assign(expr="",r=r,val=val)$
$access(target=r,source=r)$
>>


negate(expr,r,val) ::= <<
$expr;separator="\n"$
$var(r)$ =  mul int -1, $var(val)$ 
>>

divide(ea,eb,r,v1,v2) ::= <<
$ea;separator="\n"$
$eb;separator="\n"$
$var(r)$ =  sdiv int $var(v1)$, $var(v2)$ 
>>

multiply(ea,eb,r,v1,v2) ::= <<
$ea;separator="\n"$
$eb;separator="\n"$
$var(r)$ =  mul int $var(v1)$, $var(v2)$ 
>>

subtract(ea,eb,r,v1,v2) ::= <<
$ea;separator="\n"$
$eb;separator="\n"$
$var(r)$ =  sub int $var(v1)$, $var(v2)$ 
>>

add(ea,eb,r,v1,v2) ::= <<
$ea;separator="\n"$
$eb;separator="\n"$
$var(r)$ =  add int $var(v1)$, $var(v2)$ 
>>

writeln(v) ::= <<

; Writeln Statement
  $var(v)$ = tail call int %puts( sbyte* getelementptr ([1 x sbyte]* %str, int 0,  uint 0) )

>>


var(num) ::= "%sfr.$num$"

label(num) ::=<<
$link(num)$:
>>

link(num) ::= "SFRLabel$num$"

block(vars, stmts) ::= <<
$vars;separator="\n"$
$stmts;separator="\n"$
>>

return(expr,ref) ::= <<

;  Start Return Statement
  $expr;separator="\n"$
  ret int $var(ref)$
;  End Return Statement

>>


write( expr, ref, v1, v2) ::= <<

; Start Write Statement
  $expr;separator="\n"$
  $var(v1)$ = load %struct._IO_FILE** %stdout
  $var(v2)$ = tail call int (%struct._IO_FILE*, sbyte*, ...)* %fprintf( %struct._IO_FILE* $var(v1)$, sbyte* getelementptr ([3 x sbyte]* %str, int 0, uint 0), int $var(ref)$ )
; End Write Statment

>>

num(val) ::= "$val$"

param(name)::= "int $var(name)$"

array_param(name)::= "[65536 x int]* $var(name)$"

function(name, params, content) ::= <<

int %$name$($params; separator=", "$) {
entry:
    $content;separator="\n"$
    ret int 0
}

>>

int_var(num) ::= "int $var(num)$"

array_var(num) ::= "[65536 x int]* $var(num)$"

call(ret, name, param_expr, params) ::= <<
$param_expr;separator="\n"$
$var(ret)$ = call int %$name$($params;separator=", "$)
>>

declare_global(r)::=<<
$var(r)$ = weak global int 0;
>>

wrapper(globals, functions) ::= <<
;
; C-- to LLVM IR Compiler
; Scott Fortmann-Roe
;
;target datalayout = "e-p:32:32"
;target endian = little
;target pointersize = 32
;target triple = "i686-pc-linux-gnu"
    %struct._IO_FILE = type { int, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, %struct._IO_marker*, %struct._IO_FILE*, int, int, int, ushort, sbyte, [1 x sbyte], sbyte*, long, sbyte*, sbyte*, int, [52 x sbyte] }
    %struct._IO_marker = type { %struct._IO_marker*, %struct._IO_FILE*, int }
%str = internal constant [1 x sbyte] zeroinitializer; <[1 x sbyte]*> [#uses=1]
%stdout = external global %struct._IO_FILE*     ; <%struct._IO_FILE**> [#uses=9]
%str = internal constant [3 x sbyte] c"%d\00"       ; <[3 x sbyte]*> [#uses=1]
%str = internal constant [8 x sbyte] c"input> \00"      ; <[8 x sbyte]*> [#uses=1]
%stdin = external global %struct._IO_FILE*      ; <%struct._IO_FILE**> [#uses=1]
%q = weak global int 0; <int*> [#uses=1]

; End Broilerplate

$globals$

; Begin Broilerplate

implementation   ; Functions:

void %writeln() {
entry:
    %tmp = tail call int %puts( sbyte* getelementptr ([1 x sbyte]* %str, int 0, uint 0) )       ; <int> [#uses=0]
    ret void
}

declare int %puts(sbyte*)

void %write(int %i) {
entry:
    %tmp = load %struct._IO_FILE** %stdout; <%struct._IO_FILE*> [#uses=1]
    %tmp1 = tail call int (%struct._IO_FILE*, sbyte*, ...)* %fprintf( %struct._IO_FILE* %tmp, sbyte* getelementptr ([3 x sbyte]* %str, int 0, uint 0), int %i )       ; <int>     [#uses=0]
    ret void
}

declare int %fprintf(%struct._IO_FILE*, sbyte*, ...)

int %read() {
entry:
    %value = alloca int, align 4; <int*> [#uses=2]
    %line = alloca [100 x sbyte], align 16; <[100 x sbyte]*> [#uses=1]
    %tmp = load %struct._IO_FILE** %stdout; <%struct._IO_FILE*> [#uses=1]
    %tmp = call uint %fwrite( sbyte* getelementptr ([8 x sbyte]* %str, int 0, uint 0), uint 7, uint 1, %struct._IO_FILE* %tmp )     ; <uint> [#uses=0]
    %tmp1 = load %struct._IO_FILE** %stdin; <%struct._IO_FILE*> [#uses=1]
    %line = getelementptr [100 x sbyte]* %line, int 0, int 0; <sbyte*> [#uses=2]
    %tmp2 = call sbyte* %fgets( sbyte* %line, int 100, %struct._IO_FILE* %tmp1 )        ; <sbyte*> [#uses=0]
    %tmp5 = call int (sbyte*, sbyte*, ...)* %sscanf( sbyte* %line, sbyte* getelementptr ([3 x sbyte]* %str, int 0, uint 0), int* %value )      ; <int> [#uses=0]
    %tmp6 = load int* %value; <int> [#uses=1]
    ret int %tmp6
}

declare sbyte* %fgets(sbyte*, int, %struct._IO_FILE*)

declare int %sscanf(sbyte*, sbyte*, ...)

; End Broilerplate


$functions$

declare uint %fwrite(sbyte*, uint, uint, %struct._IO_FILE*)

>>