void ConstantArrayPropagationPass::CollectInitializations()
{
if (!initializations.empty())
{
initializations.clear() ;
}
DefinitionBlock* procDefBlock = procDef->get_definition_block() ;
assert(procDefBlock != NULL) ;
Iter<VariableDefinition*> varDefIter =
procDefBlock->get_variable_definition_iterator() ;
while (varDefIter.is_valid())
{
VariableDefinition* varDef = varDefIter.current() ;
assert(varDef != NULL) ;
VariableSymbol* varSym = varDef->get_variable_symbol() ;
ValueBlock* valBlock = varDef->get_initialization() ;
assert(varSym != NULL) ;
assert(valBlock != NULL) ;
if (ValidSymbol(varSym))
{
initializations[varSym] = valBlock ;
varSym->append_annote(create_brick_annote(theEnv, "ConstPropArray")) ;
}
varDefIter.next() ;
}
}
void SingleInheritanceVtbls::attach_vtbl( SingleInheritanceClassType* ctype,
VariableSymbol* vsym ) {
VariableDefinition* vdef = get_vtbl( ctype );
vdef->set_variable_symbol( vsym );
vsym->set_definition( vdef );
// Insert reference to vsym in ClassType
ctype->set_vtbl_symbol( vsym );
// Insert vdef in ClassType
ctype->get_definition_block()->append_variable_definition( vdef );
// Set type of vsym
DataType* vtbl_type =
vdef->get_initialization()->get_type();
QualifiedType* q_vtbl_type = _tb->get_qualified_type( vtbl_type );
vsym->set_type( q_vtbl_type );
}
/*
* print_var_def() -- Generates assembly language data statements.
* Data objects are put into the sdata section, data section, comm
* section, or the lcomm section. If the data object is global, I
* also specify a .globl pseudo-op.
*/
void
PrinterX86::print_var_def(VarSym *vsym)
{
int vsym_size = get_bit_size(get_type(vsym)) >> 3; // in bytes
VariableDefinition *vdef = vsym->get_definition();
if (vdef == NULL
|| (vdef->get_initialization() == NULL) // FIXME: shouldn't be possible
|| is_a<UndefinedValueBlock>(vdef->get_initialization())) {
// Uninitialized data item. If global symbol, append to
// .comm, else static symbol to .lcomm.
if (is_global(vsym) && !is_private(vsym))
fprintf(out, "\t%s\t", x86_opcode_names[COMM]);
else
fprintf(out, "\t%s\t", x86_opcode_names[LCOMM]);
print_sym(vsym);
fprintf(out, ", %d\n", vsym_size);
} else { // initialized data item
// Specify data section to place data in. On x86, always use
// .data section.
fprintf(out, "\t%s\n", x86_opcode_names[DATA]);
// If global symbol, add .globl pseudo-op. Note that a variable
// is considered global in SUIF if it is part of the global or
// file symbol table. For X86 assembly, a datum is global only
// if it is part of the global symbol table (i.e. is_private()
// checks for def in file symbol table).
if (is_global(vsym) && !is_private(vsym)) {
fprintf(out, "\t%s\t", x86_opcode_names[GLOBL]);
print_sym(vsym);
fprintf(out, "\n");
}
// Determine alignment and align
int bit_alignment = get_bit_alignment(vdef);
// If vdef's alignment is zero (shouldn't be!), use that in vsym's type
if (bit_alignment == 0)
bit_alignment = get_bit_alignment(get_type(vsym));
int alignment_value;
switch (bit_alignment) {
case 8: // byte aligned
alignment_value = 0;
break;
case 16: // halfword aligned
alignment_value = 1;
break;
case 32: // word aligned
alignment_value = 2;
break;
case 64: // double word aligned
alignment_value = 3;
break;
case 128: // quad word aligned
alignment_value = 4;
break;
default:
claim(false, "bad alignment for %s", get_name(vsym).chars());
}
fprintf(out, "\t%s\t%d\n", x86_opcode_names[ALIGN], alignment_value);
// Disable automatic alignment
fprintf(out, "\t%s\t%d\t# %s\n", x86_opcode_names[ALIGN], 0,
"disable automatic alignment");
// Write out the label
print_sym(vsym);
fprintf(out, ":"); // return added in process_value_block
// initialize memory with values
cur_opcode = opcode_null;
cur_opnd_cnt = 0;
process_value_block(vdef->get_initialization());
fprintf(out, "\n");
}
}
