void shortcuts(satinstance sati) {
int p;
maxshortcutclauses = 100000;
nofshortcutclauses = 0;
shortcutclauses = (shortcutclause *)malloc(maxshortcutclauses * sizeof(shortcutclause));
for(p=0;p<sati->nOfSVars;p++) {
shortcutprobe(sati,PLIT(varwithtime(sati,p,flagShortCutHorizon)));
shortcutprobe(sati,NLIT(varwithtime(sati,p,flagShortCutHorizon)));
}
#ifdef SHOWIT
printf("INFERRED %i SHORTCUT CLAUSES.\n",nofshortcutclauses);
#endif
}
static GLboolean equality (slang_assemble_ctx *A, slang_operation *op, GLboolean equal)
{
slang_assembly_typeinfo ti;
GLboolean result = GL_FALSE;
slang_storage_aggregate agg;
GLuint index, size;
GLuint skip_jump, true_label, true_jump, false_label, false_jump;
/* get type of operation */
if (!slang_assembly_typeinfo_construct (&ti))
return GL_FALSE;
if (!_slang_typeof_operation (A, op, &ti))
goto end1;
/* convert it to an aggregate */
if (!slang_storage_aggregate_construct (&agg))
goto end1;
if (!_slang_aggregate_variable (&agg, &ti.spec, 0, A->space.funcs, A->space.structs,
A->space.vars, A->mach, A->file, A->atoms))
goto end;
/* compute the size of the agregate - there are two such aggregates on the stack */
size = _slang_sizeof_aggregate (&agg);
/* jump to the actual data-comparison code */
skip_jump = A->file->count;
if (!PUSH (A->file, slang_asm_jump))
goto end;
/* pop off the stack the compared data and push 1 */
true_label = A->file->count;
if (!PLAB (A->file, slang_asm_local_free, size * 2))
goto end;
if (!PLIT (A->file, slang_asm_bool_push, (GLfloat) 1))
goto end;
true_jump = A->file->count;
if (!PUSH (A->file, slang_asm_jump))
goto end;
false_label = A->file->count;
if (!PLAB (A->file, slang_asm_local_free, size * 2))
goto end;
if (!PLIT (A->file, slang_asm_bool_push, (GLfloat) 0))
goto end;
false_jump = A->file->count;
if (!PUSH (A->file, slang_asm_jump))
goto end;
A->file->code[skip_jump].param[0] = A->file->count;
/* compare the data on stack, it will eventually jump either to true or false label */
index = 0;
if (!equality_aggregate (A, &agg, &index, size, equal ? false_label : true_label))
goto end;
if (!PLAB (A->file, slang_asm_jump, equal ? true_label : false_label))
goto end;
A->file->code[true_jump].param[0] = A->file->count;
A->file->code[false_jump].param[0] = A->file->count;
result = GL_TRUE;
end:
slang_storage_aggregate_destruct (&agg);
end1:
slang_assembly_typeinfo_destruct (&ti);
return result;
}
GLboolean _slang_assemble_operation (slang_assemble_ctx *A, slang_operation *op, slang_ref_type ref)
{
/* set default results */
A->ref = /*(ref == slang_ref_freelance) ? slang_ref_force : */ref;
A->swz.num_components = 0;
switch (op->type)
{
case slang_oper_block_no_new_scope:
case slang_oper_block_new_scope:
{
GLuint i;
for (i = 0; i < op->num_children; i++)
{
if (!_slang_assemble_operation (A, &op->children[i], slang_ref_forbid/*slang_ref_freelance*/))
return GL_FALSE;
if (!_slang_cleanup_stack (A, &op->children[i]))
return GL_FALSE;
}
}
break;
case slang_oper_variable_decl:
{
GLuint i;
slang_operation assign;
GLboolean result;
/* Construct assignment expression placeholder. */
if (!slang_operation_construct (&assign))
return GL_FALSE;
assign.type = slang_oper_assign;
assign.children = (slang_operation *) slang_alloc_malloc (2 * sizeof (slang_operation));
if (assign.children == NULL)
{
slang_operation_destruct (&assign);
return GL_FALSE;
}
for (assign.num_children = 0; assign.num_children < 2; assign.num_children++)
if (!slang_operation_construct (&assign.children[assign.num_children]))
{
slang_operation_destruct (&assign);
return GL_FALSE;
}
result = GL_TRUE;
for (i = 0; i < op->num_children; i++)
{
slang_variable *var;
var = _slang_locate_variable (op->children[i].locals, op->children[i].a_id, GL_TRUE);
if (var == NULL)
{
result = GL_FALSE;
break;
}
if (var->initializer == NULL)
continue;
if (!slang_operation_copy (&assign.children[0], &op->children[i]) ||
!slang_operation_copy (&assign.children[1], var->initializer) ||
!_slang_assemble_assign (A, &assign, "=", slang_ref_forbid) ||
!_slang_cleanup_stack (A, &assign))
{
result = GL_FALSE;
break;
}
}
slang_operation_destruct (&assign);
if (!result)
return GL_FALSE;
}
break;
case slang_oper_asm:
{
GLuint i;
if (!_slang_assemble_operation (A, &op->children[0], slang_ref_force))
return GL_FALSE;
for (i = 1; i < op->num_children; i++)
if (!_slang_assemble_operation (A, &op->children[i], slang_ref_forbid))
return GL_FALSE;
if (!call_asm_instruction (A, op->a_id))
return GL_FALSE;
}
break;
case slang_oper_break:
if (!PLAB (A->file, slang_asm_jump, A->flow.loop_end))
return GL_FALSE;
break;
case slang_oper_continue:
if (!PLAB (A->file, slang_asm_jump, A->flow.loop_start))
return GL_FALSE;
break;
case slang_oper_discard:
if (!PUSH (A->file, slang_asm_discard))
return GL_FALSE;
if (!PUSH (A->file, slang_asm_exit))
return GL_FALSE;
break;
case slang_oper_return:
if (A->local.ret_size != 0)
{
/* push the result's address */
if (!PLAB2 (A->file, slang_asm_local_addr, 0, A->local.ret_size))
return GL_FALSE;
if (!_slang_assemble_operation (A, &op->children[0], slang_ref_forbid))
return GL_FALSE;
A->swz.num_components = 0;
/* assign the operation to the function result (it was reserved on the stack) */
if (!_slang_assemble_assignment (A, op->children))
return GL_FALSE;
if (!PLAB (A->file, slang_asm_local_free, 4))
return GL_FALSE;
}
if (!PLAB (A->file, slang_asm_jump, A->flow.function_end))
return GL_FALSE;
break;
case slang_oper_expression:
if (ref == slang_ref_force)
return GL_FALSE;
if (!_slang_assemble_operation (A, &op->children[0], ref))
return GL_FALSE;
break;
case slang_oper_if:
if (!_slang_assemble_if (A, op))
return GL_FALSE;
break;
case slang_oper_while:
if (!_slang_assemble_while (A, op))
return GL_FALSE;
break;
case slang_oper_do:
if (!_slang_assemble_do (A, op))
return GL_FALSE;
break;
case slang_oper_for:
if (!_slang_assemble_for (A, op))
return GL_FALSE;
break;
case slang_oper_void:
break;
case slang_oper_literal_bool:
if (ref == slang_ref_force)
return GL_FALSE;
if (!PLIT (A->file, slang_asm_bool_push, op->literal))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
case slang_oper_literal_int:
if (ref == slang_ref_force)
return GL_FALSE;
if (!PLIT (A->file, slang_asm_int_push, op->literal))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
case slang_oper_literal_float:
if (ref == slang_ref_force)
return GL_FALSE;
if (!PLIT (A->file, slang_asm_float_push, op->literal))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
case slang_oper_identifier:
{
slang_variable *var;
GLuint size;
/* find the variable and calculate its size */
var = _slang_locate_variable (op->locals, op->a_id, GL_TRUE);
if (var == NULL)
return GL_FALSE;
size = 0;
if (!sizeof_variable (A, &var->type.specifier, slang_qual_none, var->array_len, &size))
return GL_FALSE;
/* prepare stack for dereferencing */
if (ref == slang_ref_forbid)
if (!PLAB2 (A->file, slang_asm_local_addr, A->local.addr_tmp, 4))
return GL_FALSE;
/* push the variable's address */
if (var->global)
{
if (!PLAB (A->file, slang_asm_global_addr, var->address))
return GL_FALSE;
}
else
{
if (!PLAB2 (A->file, slang_asm_local_addr, var->address, size))
return GL_FALSE;
}
/* perform the dereference */
if (ref == slang_ref_forbid)
{
if (!PUSH (A->file, slang_asm_addr_copy))
return GL_FALSE;
if (!PLAB (A->file, slang_asm_local_free, 4))
return GL_FALSE;
if (!_slang_dereference (A, op))
return GL_FALSE;
}
}
break;
case slang_oper_sequence:
if (ref == slang_ref_force)
return GL_FALSE;
if (!_slang_assemble_operation (A, &op->children[0], slang_ref_forbid/*slang_ref_freelance*/))
return GL_FALSE;
if (!_slang_cleanup_stack (A, &op->children[0]))
return GL_FALSE;
if (!_slang_assemble_operation (A, &op->children[1], slang_ref_forbid))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
case slang_oper_assign:
if (!_slang_assemble_assign (A, op, "=", ref))
return GL_FALSE;
break;
case slang_oper_addassign:
if (!_slang_assemble_assign (A, op, "+=", ref))
return GL_FALSE;
A->ref = ref;
break;
case slang_oper_subassign:
if (!_slang_assemble_assign (A, op, "-=", ref))
return GL_FALSE;
A->ref = ref;
break;
case slang_oper_mulassign:
if (!_slang_assemble_assign (A, op, "*=", ref))
return GL_FALSE;
A->ref = ref;
break;
/*case slang_oper_modassign:*/
/*case slang_oper_lshassign:*/
/*case slang_oper_rshassign:*/
/*case slang_oper_orassign:*/
/*case slang_oper_xorassign:*/
/*case slang_oper_andassign:*/
case slang_oper_divassign:
if (!_slang_assemble_assign (A, op, "/=", ref))
return GL_FALSE;
A->ref = ref;
break;
case slang_oper_select:
if (!_slang_assemble_select (A, op))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
case slang_oper_logicalor:
if (!_slang_assemble_logicalor (A, op))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
case slang_oper_logicaland:
if (!_slang_assemble_logicaland (A, op))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
case slang_oper_logicalxor:
if (!_slang_assemble_function_call_name (A, "^^", op->children, 2, GL_FALSE))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
/*case slang_oper_bitor:*/
/*case slang_oper_bitxor:*/
/*case slang_oper_bitand:*/
case slang_oper_less:
if (!_slang_assemble_function_call_name (A, "<", op->children, 2, GL_FALSE))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
case slang_oper_greater:
if (!_slang_assemble_function_call_name (A, ">", op->children, 2, GL_FALSE))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
case slang_oper_lessequal:
if (!_slang_assemble_function_call_name (A, "<=", op->children, 2, GL_FALSE))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
case slang_oper_greaterequal:
if (!_slang_assemble_function_call_name (A, ">=", op->children, 2, GL_FALSE))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
/*case slang_oper_lshift:*/
/*case slang_oper_rshift:*/
case slang_oper_add:
if (!_slang_assemble_function_call_name (A, "+", op->children, 2, GL_FALSE))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
case slang_oper_subtract:
if (!_slang_assemble_function_call_name (A, "-", op->children, 2, GL_FALSE))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
case slang_oper_multiply:
if (!_slang_assemble_function_call_name (A, "*", op->children, 2, GL_FALSE))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
/*case slang_oper_modulus:*/
case slang_oper_divide:
if (!_slang_assemble_function_call_name (A, "/", op->children, 2, GL_FALSE))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
case slang_oper_equal:
if (!_slang_assemble_operation (A, &op->children[0], slang_ref_forbid))
return GL_FALSE;
if (!_slang_assemble_operation (A, &op->children[1], slang_ref_forbid))
return GL_FALSE;
if (!equality (A, op->children, GL_TRUE))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
case slang_oper_notequal:
if (!_slang_assemble_operation (A, &op->children[0], slang_ref_forbid))
return GL_FALSE;
if (!_slang_assemble_operation (A, &op->children[1], slang_ref_forbid))
return GL_FALSE;
if (!equality (A, op->children, GL_FALSE))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
case slang_oper_preincrement:
if (!_slang_assemble_assign (A, op, "++", ref))
return GL_FALSE;
A->ref = ref;
break;
case slang_oper_predecrement:
if (!_slang_assemble_assign (A, op, "--", ref))
return GL_FALSE;
A->ref = ref;
break;
case slang_oper_plus:
if (!_slang_dereference (A, op))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
case slang_oper_minus:
if (!_slang_assemble_function_call_name (A, "-", op->children, 1, GL_FALSE))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
/*case slang_oper_complement:*/
case slang_oper_not:
if (!_slang_assemble_function_call_name (A, "!", op->children, 1, GL_FALSE))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
case slang_oper_subscript:
{
slang_assembly_typeinfo ti_arr, ti_elem;
if (!slang_assembly_typeinfo_construct (&ti_arr))
return GL_FALSE;
if (!slang_assembly_typeinfo_construct (&ti_elem))
{
slang_assembly_typeinfo_destruct (&ti_arr);
return GL_FALSE;
}
if (!handle_subscript (A, &ti_elem, &ti_arr, op, ref))
{
slang_assembly_typeinfo_destruct (&ti_arr);
slang_assembly_typeinfo_destruct (&ti_elem);
return GL_FALSE;
}
slang_assembly_typeinfo_destruct (&ti_arr);
slang_assembly_typeinfo_destruct (&ti_elem);
}
break;
case slang_oper_call:
{
slang_function *fun;
fun = _slang_locate_function (A->space.funcs, op->a_id, op->children, op->num_children,
&A->space, A->atoms);
if (fun == NULL)
{
if (!_slang_assemble_constructor (A, op))
return GL_FALSE;
}
else
{
if (!_slang_assemble_function_call (A, fun, op->children, op->num_children, GL_FALSE))
return GL_FALSE;
}
A->ref = slang_ref_forbid;
}
break;
case slang_oper_field:
{
slang_assembly_typeinfo ti_after, ti_before;
if (!slang_assembly_typeinfo_construct (&ti_after))
return GL_FALSE;
if (!slang_assembly_typeinfo_construct (&ti_before))
{
slang_assembly_typeinfo_destruct (&ti_after);
return GL_FALSE;
}
if (!handle_field (A, &ti_after, &ti_before, op, ref))
{
slang_assembly_typeinfo_destruct (&ti_after);
slang_assembly_typeinfo_destruct (&ti_before);
return GL_FALSE;
}
slang_assembly_typeinfo_destruct (&ti_after);
slang_assembly_typeinfo_destruct (&ti_before);
}
break;
case slang_oper_postincrement:
if (!assemble_function_call_name_dummyint (A, "++", op->children))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
case slang_oper_postdecrement:
if (!assemble_function_call_name_dummyint (A, "--", op->children))
return GL_FALSE;
A->ref = slang_ref_forbid;
break;
default:
return GL_FALSE;
}
return GL_TRUE;
}
void shortcutprobe(satinstance sati,int l) {
int i,l2;
PTRINT reason;
#ifdef HARDDEBUG
printf("--------------------------------------------------------------\n");
#endif
for(i=0;i<sati->nOfVars;i++) {
int flag;
flag=0;
if(!varunsetp(sati,i)) {
printf("INCORRECTLY ALREADY SET: %i",i); printTlit(sati,PLIT(i));
flag = 1;
}
assert(flag==0);
}
setUPstacktop(sati,-1); /* Drop the input unit clauses from the stack. */
sati->dlevel = 0;
sati->declevels[0] = 0;
#ifdef HARDDEBUG
printf("Trying ");
printTlit(sati,l);
printf("\n");
#endif
simpleaddtoqueue(sati,l,REASON_DECISION,0);
if(propagate(sati)) {
// Literal cannot be true.
#ifdef SHOWIT
printf("CONTRADICTION WITH ");
printTlit(sati,l);
printf("\n");
#endif
undo_assignments_until_level_NOHEAP(sati,0);
return;
}
// printf("PROPAGATED\n");
for(i=1;i<sati->endunitstack;i++) { // Go through inferred literals.
l2 = sati->unitstack[i];
reason = LITREASON(l2);
#ifdef HARDDEBUG
printf("Checking %i:",i); printTlit(sati,l2);
printf(" REASON: ");
if(reason == REASON_INPUT) printf("INPUT");
else if(reason == REASON_DECISION) printf("DECISION");
else if((reason&1)==0) printf(" LONG CLAUSE");
else printTlit(sati,reason >> 1);
printf("\n");
#endif
if((reason & 3) == 0 && clauselen((int *)reason) > 3) { // Reason is a long clause?
// Store the new binary literal for later use.
if(nofshortcutclauses+1 >= maxshortcutclauses) {
maxshortcutclauses = maxshortcutclauses * 2;
shortcutclauses = (shortcutclause *)realloc(shortcutclauses,
maxshortcutclauses * sizeof(shortcutclause));
}
shortcutclauses[nofshortcutclauses].l1 = NEG(l) % (2 * sati->nOfVarsPerTime);
shortcutclauses[nofshortcutclauses].l2 = l2 % (2 * sati->nOfVarsPerTime);
shortcutclauses[nofshortcutclauses++].tdiff = tvartime(sati,VAR(l2))-tvartime(sati,VAR(l));
#ifdef SHOWIT
printf("INFER CLAUSE: ");
printTlit(sati,shortcutclauses[nofshortcutclauses-1].l1);
printf(" V ");
printlit(shortcutclauses[nofshortcutclauses-1].l2);
printf("@%i (through length %i)\n",shortcutclauses[nofshortcutclauses-1].tdiff,clauselen((int *)reason));
#endif
}
}
undo_assignments_until_level_NOHEAP(sati,0);
for(i=0;i<sati->nOfVars;i++)
if(!varunsetp(sati,i)) {
printf("INCORRECTLY REMAINS SET: %i",i); printTlit(sati,PLIT(i));
assert(1==0);
}
}
