void ir_ternary(nodeType* n)
{
nodeType* expr = get_operand(n,0);
nodeType* stmt1 = get_operand(n,1);
nodeType* stmt2 = get_operand(n,2);
set_T(expr,newlabel());
set_F(expr,newlabel());
memset(stmt1->opr.next,0,16);
memset(stmt2->opr.next,0,16);
memset(n->opr.next,0,16);
strcpy(stmt1->opr.next,n->opr.next);
strcpy(stmt2->opr.next,n->opr.next);
strcpy(n->opr.next,newlabel());
seen_bool_flow = 1;
generate(expr);
seen_bool_flow = 0;
debugger("%s:\n",get_T(expr));
fprintf(output,"%s:\n",get_T(expr));
prepost_put = 1;
generate(stmt1);
prepost_put = 0;
debugger("br.s %s\n ",n->opr.next);
fprintf(output,"br.s %s\n",n->opr.next);
debugger("%s:\n",get_F(expr));
fprintf(output,"%s:\n",get_F(expr));
prepost_put = 1;
generate(stmt2);
prepost_put = 0;
debugger("%s:\n",n->opr.next);
fprintf(output,"%s:\n",n->opr.next);
}
void ir_bool_flow(nodeType* n)
{
nodeType* B1 = get_operand(n,0);
nodeType* B2 = get_operand(n,1);
debugger("n true label:%s\n",get_T(n));
debugger("n false label:%s\n",get_F(n));
switch(n->opr.oper)
{
case BOOL_OR:
debugger("MATCHED BOOL_OR in ir_bool_flow\n");
set_T(B1,n->opr.T);
set_F(B1,newlabel());
set_T(B2,n->opr.T);
set_F(B2,n->opr.F);
generate(B1);
debugger("%s:",get_F(B1));
fprintf(output,"%s:",get_F(B1));
debugger("seen_bool_flow : %d\n",seen_bool_flow);
generate(B2);
break;
case BOOL_EQ:
//the rule is to load value of B1 and B2 on stack then use beq to jump accordingly so we have to switch of seen_bool_flow flag and restart later.
seen_bool_flow = 0;
generate(B1);
generate(B2);
seen_bool_flow = 1;
debugger("MATCHED BOOL_EQ in ir_relop_flow\n");
debugger("beq %s\n",get_T(n));
fprintf(output,"beq %s\n",get_T(n));
debugger("br %s\n",get_F(n));
fprintf(output,"br %s\n",get_F(n));
break;
case NEQ:
debugger("NOT EQUAL TO\n");
//the rule is to load value of B1 and B2 on stack then use bne.un to jump accordingly so we have to switch of seen_bool_flow flag and restart later.
seen_bool_flow = 0;
generate(B1);
generate(B2);
seen_bool_flow = 1;
debugger("MATCHED NEQ in ir_relop_flow\n");
debugger("bne.un %s\n",get_T(n));
fprintf(output,"bne.un %s\n",get_T(n));
debugger("br %s\n",get_F(n));
fprintf(output,"br %s\n",get_F(n));
break;
case BOOL_AND:
set_T(B1,newlabel());
set_F(B1, get_F(n));
set_T(B2, get_T(n));
set_F(B2, get_F(n));
generate(B1);
debugger("%s:",get_T(B1));
fprintf(output,"%s:",get_T(B1));
generate(B2);
break;
default: debugger("Bool DEFAULT\n");
}
}
Flux Fhll( Vars Uimo, Vars Ui, Vars Uipo, Vars Uipt){//calculates the HLL flux for a given interface in x
Flux F_HLL;
Vars UL = U_L(Ui, Uimo, Uipo); Vars UR = U_R(Ui, Uipo, Uipt); //Calculates the conserved variables at the interfaces
double alphap = alpha(UL, UR, 1., 1);
double alpham = alpha(UL, UR, -1., 1);
Flux FL = get_F(UL); Flux FR = get_F(UR); //Calculates the Fluxes from the left and right at the interface
F_HLL.rhov = (alphap*FL.rhov + alpham*FR.rhov - alphap*alpham*(UR.mass - UL.mass))/(alphap + alpham);
F_HLL.momx = (alphap*FL.momx + alpham*FR.momx - alphap*alpham*(UR.xvelocity - UL.xvelocity))/(alphap + alpham);
F_HLL.momy = (alphap*FL.momy + alpham*FR.momy - alphap*alpham*(UR.yvelocity - UL.yvelocity))/(alphap + alpham);
F_HLL.energy = (alphap*FL.energy + alpham*FR.energy - alphap*alpham*(UR.energy - UL.energy))/(alphap + alpham);
return(F_HLL);
}
double HLL(int N, Vars * U, Flux * F_HLL){
int i; double maxalph = 0.;
for(i=0;i<N-1;++i){
Flux FR, FL; FL = get_F(U[i]); FR = get_F(U[i+1]);
double alphap = alpha(U[i], U[i+1], 1.);
double alpham = alpha(U[i], U[i+1], -1.);
F_HLL[i].rhov = (alphap*FL.rhov + alpham*FR.rhov - alphap*alpham*(U[i+1].mass - U[i].mass))/(alphap + alpham);
F_HLL[i].mom = (alphap*FL.mom + alpham*FR.mom - alphap*alpham*(U[i+1].velocity - U[i].velocity))/(alphap + alpham);
F_HLL[i].energy = (alphap*FL.energy + alpham*FR.energy - alphap*alpham*(U[i+1].energy - U[i].energy))/(alphap + alpham);
maxalph = MAX(maxalph, alphap, alpham);
//printf("%d %f %f\n", i, alphap, alpham);
}
return(maxalph);
}
void ir_if(nodeType* n)
{
nodeType* expr = get_operand(n,0);
nodeType* stmt = get_operand(n,1);
set_T(expr,newlabel());
set_F(expr,n->opr.next);
memset(stmt->opr.next,0,16);
strcat(stmt->opr.next,n->opr.next);
debugger("expr true label:%s\n",get_T(expr));
debugger("expr false label:%s\n",get_F(expr));
seen_bool_flow = 1;prepost_put = 1;
generate(expr);
seen_bool_flow = 0;prepost_put = 0;
debugger("%s:\n",get_T(expr));
fprintf(output,"%s:\n",get_T(expr));
generate(stmt);
return;
}
void ir_relop_flow(nodeType* n)
{
int temp_bool_flow = seen_bool_flow;
seen_bool_flow = 0;
nodeType* B1 = get_operand(n,0);
nodeType* B2 = get_operand(n,1);
generate(B1);
generate(B2);
switch(n->opr.oper)
{
case LT:
debugger("MATCHED LT in ir_relop_flow\n");
debugger("blt %s\n",get_T(n));
fprintf(output,"blt %s\n",get_T(n));
debugger("br %s\n",get_F(n));
fprintf(output,"br %s\n",get_F(n));
break;
case GT:
debugger("MATCHED GT in ir_relop_flow\n");
debugger("bgt %s\n",get_T(n));
fprintf(output,"bgt %s\n",get_T(n));
debugger("br %s\n",get_F(n));
fprintf(output,"br %s\n",get_F(n));
break;
case LE:
debugger("MATCHED LE in ir_relop_flow\n");
debugger("ble %s\n",get_T(n));
fprintf(output,"ble %s\n",get_T(n));
debugger("br %s\n",get_F(n));
fprintf(output,"br %s\n",get_F(n));
break;
case GE:
debugger("MATCHED GE in ir_relop_flow\n");
debugger("bge %s\n",get_T(n));
fprintf(output,"bge %s\n",get_T(n));
debugger("br %s\n",get_F(n));
fprintf(output,"br %s\n",get_F(n));
break;
default:
debugger("Relational Flow default\n");
}
seen_bool_flow = temp_bool_flow;
}
