void ExportPass::ConstructModuleSymbols()
{
CProcedureType* originalType = dynamic_cast<CProcedureType*>(originalProcedure->get_procedure_symbol()->get_type()) ;
assert(originalType != NULL) ;
// The original type takes and returns a struct. We need to change this
// to a list of arguments.
VoidType* newReturnType = create_void_type(theEnv, IInteger(0), 0) ;
constructedType = create_c_procedure_type(theEnv,
newReturnType,
false, // has varargs
true, // arguments_known
0, // bit alignment
LString("ConstructedType")) ;
StructType* returnType =
dynamic_cast<StructType*>(originalType->get_result_type()) ;
assert(returnType != NULL) ;
SymbolTable* structSymTab = returnType->get_group_symbol_table() ;
assert(structSymTab != NULL) ;
for (int i = 0 ; i < structSymTab->get_symbol_table_object_count() ; ++i)
{
VariableSymbol* nextVariable =
dynamic_cast<VariableSymbol*>(structSymTab->get_symbol_table_object(i));
if (nextVariable != NULL)
{
// Check to see if this is an output or not
QualifiedType* cloneType ;
DataType* cloneBase =
dynamic_cast<DataType*>(nextVariable->get_type()->get_base_type()->deep_clone()) ;
assert(cloneBase != NULL) ;
cloneType = create_qualified_type(theEnv, cloneBase) ;
if (nextVariable->lookup_annote_by_name("Output") != NULL)
{
cloneType->append_annote(create_brick_annote(theEnv, "Output")) ;
// Why doesn't this stick around?
}
constructedType->append_argument(cloneType) ;
}
}
constructedSymbol = create_procedure_symbol(theEnv,
constructedType,
originalProcedure->get_procedure_symbol()->get_name()) ;
constructedSymbol->set_definition(NULL) ;
}
void CopyPropagationPass2::CollectVariables()
{
assert(procDef != NULL) ;
if (killMap.empty() == false)
{
ClearMap() ;
}
assert(killMap.empty() == true) ;
assert(procDef != NULL) ;
SymbolTable* symTab = procDef->get_symbol_table() ;
Iter<SymbolTableObject*> symIter =
symTab->get_symbol_table_object_iterator() ;
while (symIter.is_valid())
{
if (is_a<VariableSymbol>(symIter.current()))
{
// For each variable symbol, create a new list of statement/int pairs
// and add that to the kill map
list<std::pair<Statement*, int> >* assocList =
new list<std::pair<Statement*, int> > ;
killMap[to<VariableSymbol>(symIter.current())] = assocList ;
}
else if (is_a<ParameterSymbol>(symIter.current()))
{
// If we are compiling a module, we also have to find the argument
// (which should be a struct) and collect all of those variable
// symbols..
ParameterSymbol* nextParm =
dynamic_cast<ParameterSymbol*>(symIter.current()) ;
assert(nextParm != NULL) ;
// Now check that we have a struct type
DataType* parmType = nextParm->get_type()->get_base_type() ;
StructType* parmStructType =
dynamic_cast<StructType*>(parmType) ;
if (parmStructType == NULL)
{
list<std::pair<Statement*, int> >* assocList =
new list<std::pair<Statement*, int> > ;
killMap[dynamic_cast<VariableSymbol*>(symIter.current())] = assocList ;
symIter.next() ;
continue ;
}
// Go through this symbol table, just like the parent table...
SymbolTable* structSymTab = parmStructType->get_group_symbol_table() ;
Iter<SymbolTableObject*> structSymIter =
structSymTab->get_symbol_table_object_iterator() ;
while (structSymIter.is_valid())
{
// These should all be variable symbols!
if (is_a<FieldSymbol>(structSymIter.current()))
{
// For each variable symbol, create a new list of statement/int pairs
// and add that to the killMap.
list<std::pair<Statement*, int> >* assocList =
new list<std::pair<Statement*, int> > ;
killMap[to<VariableSymbol>(structSymIter.current())] = assocList ;
}
else
{
std::cerr << "Non variable symbol inside a struct!" << std::endl ;
assert(0) ;
}
structSymIter.next() ;
}
}
symIter.next() ;
}
}