Пример #1
0
static
String handle_static_int_constant(CPrintStyleModule *state,
				  const SuifObject *obj)
{
  IntConstant *expr =
    to<IntConstant>(obj);
  IInteger v = expr->get_value();
  return(v.to_String());
}
Пример #2
0
/* Another helper function for print_var_def().   This function
 * expects that it will need to add a return before printing
 * anything, and it expects that you will add a return after
 * it is done.
 * It returns the number of bits of initialization data that it
 * generates.
 */
int
PrinterX86::process_value_block(ValueBlock *vblk)
{
    int bits_filled = 0;

    if (is_a<ExpressionValueBlock>(vblk)) {
	// An ExpressionValueBlock either holds a constant value or a
	// simple expression representing either an address relative to
	// a symbol or a pointer generated by conversion from an integer
	// constant (presumably zero).

	ExpressionValueBlock *evb = (ExpressionValueBlock*)vblk;
	Expression *exp = evb->get_expression();

	if (is_a<IntConstant>(exp)) {
	    IntConstant *ic = (IntConstant*)exp;
	    bits_filled = print_size_directive(ic->get_result_type());
	    fprint(out, ic->get_value());
	    cur_opnd_cnt++;
	}
	else if (is_a<FloatConstant>(exp)) {
	    FloatConstant *fc = (FloatConstant*)exp;
	    bits_filled = print_size_directive(fc->get_result_type());
	    fputs(fc->get_value().c_str(), out);
	    cur_opnd_cnt++;
	}
	else {
	    // We use non-constant ExpressionValueBlocks to hold a symbolic
	    // address, optionally with an offset, or a pointer initializer
	    // consisting of a `convert' expression.
	    // A SymbolAddressExpression represents a plain symbolic
	    // address.
	    // An address obtained by conversion from another type is a
	    // unary expression with opcode "convert".
	    // A symbol+delta is represented by an add whose first operand
	    // is the load-address and whose second is an IntConstant
	    // expression.
	    // No other kind of "expression" is recognized.

	    if (is_a<UnaryExpression>(exp)) {
		UnaryExpression *ux = (UnaryExpression*)exp;
		claim(ux->get_opcode() == k_convert,
		      "unexpected unary expression in expression block");
		DataType *tt = ux->get_result_type();	// target type
		claim(is_kind_of<PointerType>(tt),
		      "unexpected target type when converting initializer");
		exp = ux->get_source();
		if (is_a<IntConstant>(exp)) {
		    IntConstant *ic = (IntConstant*)exp;
		    bits_filled = print_size_directive(tt);
		    fprint(out, ic->get_value());
		    cur_opnd_cnt++;
		    return bits_filled;
		}
		// Fall through to handle symbol-relative address, on the
		// assumption that the front end validated the conversion.
	    }
	    SymbolAddressExpression *sax;
	    long delta;
	    if (is_a<BinaryExpression>(exp)) {
		BinaryExpression *bx = (BinaryExpression*)exp;
		claim(bx->get_opcode() == k_add,
		      "unexpected binary expression in expression block");
		Expression *s1 = bx->get_source1();
		Expression *s2 = bx->get_source2();
		sax = to<SymbolAddressExpression>(s1);
		delta = to<IntConstant>(s2)->get_value().c_long();
	    } else if (is_a<SymbolAddressExpression>(exp)) {
		sax = (SymbolAddressExpression*)exp;
		delta = 0;
	    } else {
		claim(false, "unexpected kind of expression block");
	    }
	    Sym *sym = sax->get_addressed_symbol();

	    // symbol initialization
	    bits_filled = print_size_directive(type_ptr);
	    print_sym(sym);
	    if (delta != 0) {
		fprintf(out, "%+ld", delta);
	    }
	    // always force the start of a new data directive
	    cur_opcode = opcode_null;
	    cur_opnd_cnt = 0;
	}
    }

    else if (is_a<MultiValueBlock>(vblk)) {
	MultiValueBlock *mvb = (MultiValueBlock*)vblk;
	for (int i = 0; i < mvb->get_sub_block_count(); i++ ) {
	    int offset = mvb->get_sub_block(i).first.c_int();
	    claim(offset >= bits_filled);

	    if (bits_filled < offset)		// pad to offset
		bits_filled += print_bit_filler(offset - bits_filled);
	    bits_filled += process_value_block(mvb->get_sub_block(i).second);
	}
	int all_bits = get_bit_size(mvb->get_type());
	if (all_bits > bits_filled)
	    bits_filled += print_bit_filler(all_bits - bits_filled);

    } else if (is_a<RepeatValueBlock>(vblk)) {
	// Simplifying assumption: We now expect the front-end
	// to remove initialization code of large arrays of zeros.
	RepeatValueBlock *rvb = (RepeatValueBlock*)vblk;
	int repeat_cnt = rvb->get_num_repetitions();

	if (repeat_cnt > 1) {		// insert .repeat pseudo-op
	    fprintf(out, "\n\t%s\t%d", x86_opcode_names[REPEAT], repeat_cnt);
	    cur_opcode = opcode_null;	// force new data directive
	}
	// actual data directive
	bits_filled = repeat_cnt * process_value_block(rvb->get_sub_block());

	if (repeat_cnt > 1) {		// insert .endr pseudo-op
	    fprintf(out, "\n\t%s", x86_opcode_names[ENDR]);
	    cur_opcode = opcode_null;	// force new data directive
	}

    } else if (is_a<UndefinedValueBlock>(vblk)) {
	bits_filled += print_bit_filler(get_bit_size(vblk->get_type()));

    } else {
	claim(false, "unexpected kind of ValueBlock");
    }
    return bits_filled;
}
// All of the array references expressions in the passed in the struct are
//  equivalent, so we can determine types of the original and use that
//  to create a new expression with which to replace everything.
bool TransformUnrolledArraysPass::ReplaceNDReference(EquivalentReferences* a)
{
  assert(a != NULL) ;
  assert(a->original != NULL) ;

  // Check to see if the reference at this stage is a constant or not
  IntConstant* constantIndex = 
    dynamic_cast<IntConstant*>(a->original->get_index()) ;
  
  if (constantIndex == NULL)
  {
    // There was no replacement made
    return false ;
  }

  Expression* baseAddress = a->original->get_base_array_address() ;
  assert(baseAddress != NULL) ;
  assert(constantIndex != NULL) ;

  // Create a replacement expression for this value.  This will either
  //  be another array reference expression or a single variable.
  Expression* replacementExp = NULL ;
  //  QualifiedType* elementType = GetQualifiedTypeOfElement(a->original) ;
  VariableSymbol* originalSymbol = GetArrayVariable(a->original) ;
  assert(originalSymbol != NULL) ;
  LString replacementName = 
    GetReplacementName(originalSymbol->get_name(), 
		       constantIndex->get_value().c_int()) ;
  int dimensionality = GetDimensionality(a->original) ;
  
  QualifiedType* elementType = originalSymbol->get_type() ;
  while (dynamic_cast<ArrayType*>(elementType->get_base_type()) != NULL)
  {
    elementType = dynamic_cast<ArrayType*>(elementType->get_base_type())->get_element_type() ;
  }
  
  // There is a special case for one dimensional arrays as opposed to all
  //  other dimensional arrays.  It only should happen if we are truly
  //  replacing an array with a one dimensional array.
  if (dimensionality == 1 && 
      dynamic_cast<ArrayReferenceExpression*>(a->original->get_parent())==NULL)
  {

    VariableSymbol* replacementVar = 
      create_variable_symbol(theEnv,
			     GetQualifiedTypeOfElement(a->original),
			     TempName(replacementName)) ;
    procDef->get_symbol_table()->append_symbol_table_object(replacementVar) ;
    
    replacementExp = 
      create_load_variable_expression(theEnv,
				      elementType->get_base_type(),
				      replacementVar) ;
  }
  else
  {
    // Create a new array with one less dimension.  This requires a new
    //  array type.
    ArrayType* varType = 
      dynamic_cast<ArrayType*>(originalSymbol->get_type()->get_base_type()) ;
    assert(varType != NULL) ;
   
    ArrayType* replacementArrayType =
      create_array_type(theEnv,
	varType->get_element_type()->get_base_type()->get_bit_size(),
	0, // bit alignment
	OneLessDimension(originalSymbol->get_type(), dimensionality),
	dynamic_cast<Expression*>(varType->get_lower_bound()->deep_clone()),
	dynamic_cast<Expression*>(varType->get_upper_bound()->deep_clone()),
	TempName(varType->get_name())) ;

    procDef->get_symbol_table()->append_symbol_table_object(replacementArrayType) ;

    VariableSymbol* replacementArraySymbol = 
      create_variable_symbol(theEnv,
			     create_qualified_type(theEnv,
						   replacementArrayType,
						   TempName(LString("qualType"))),
			     TempName(replacementName)) ;

    procDef->get_symbol_table()->append_symbol_table_object(replacementArraySymbol) ;

    // Create a new symbol address expression for this variable symbol
    SymbolAddressExpression* replacementAddrExp =
      create_symbol_address_expression(theEnv,
				       replacementArrayType,
				       replacementArraySymbol) ;

    // Now, replace the symbol address expression in the base
    //  array address with this symbol.
    ReplaceSymbol(a->original, replacementAddrExp) ;
    
    // And replace this reference with the base array address.
    replacementExp = a->original->get_base_array_address() ;
    a->original->set_base_array_address(NULL) ;
    replacementExp->set_parent(NULL) ;
  }

  // Replace all of the equivalent expressions with the newly generated
  //  replacement expression.
  assert(replacementExp != NULL) ;
  a->original->get_parent()->replace(a->original, replacementExp) ;
   
  //  ReplaceChildExpression(a->original->get_parent(),
  //			 a->original,
  //			 replacementExp) ;

  list<ArrayReferenceExpression*>::iterator equivIter = 
    a->allEquivalent.begin() ;
  while (equivIter != a->allEquivalent.end()) 
  {
    (*equivIter)->get_parent()->replace((*equivIter),
					dynamic_cast<Expression*>(replacementExp->deep_clone())) ;
    //    ReplaceChildExpression((*equivIter)->get_parent(),
    //			   (*equivIter),
    //			   dynamic_cast<Expression*>(replacementExp->deep_clone())) ;
    ++equivIter ;
  }

  return true ;
}
Constant* MiniConstantPropagationPass::Merge(Constant* x, Constant* y,
        LString opcode)
{
    assert(theEnv != NULL) ;

    if (x == NULL || y == NULL)
    {
        return NULL ;
    }

    IntConstant* xInt = dynamic_cast<IntConstant*>(x) ;
    IntConstant* yInt = dynamic_cast<IntConstant*>(y) ;
    FloatConstant* xFloat = dynamic_cast<FloatConstant*>(x) ;
    FloatConstant* yFloat = dynamic_cast<FloatConstant*>(y) ;

    // This mini propagation only cares for addition and subtraction.  Other
    //  propagations will be handled in a later pass.

    if (opcode == LString("add"))
    {
        if (xInt != NULL && yInt != NULL)
        {
            int mergedValue = xInt->get_value().c_int() + yInt->get_value().c_int() ;
            return create_int_constant(theEnv, xInt->get_result_type(),
                                       IInteger(mergedValue)) ;
        }
        if (xFloat != NULL && yFloat != NULL)
        {
            float mergedValue = StringToFloat(xFloat->get_value()) +
                                StringToFloat(yFloat->get_value()) ;
            return create_float_constant(theEnv, xFloat->get_result_type(),
                                         FloatToString(mergedValue)) ;
        }
        if (xInt != NULL && yFloat != NULL)
        {
            float mergedValue = xInt->get_value().c_int() +
                                StringToFloat(yFloat->get_value()) ;
            return create_float_constant(theEnv, yFloat->get_result_type(),
                                         FloatToString(mergedValue)) ;
        }
        if (xFloat != NULL && yInt != NULL)
        {
            float mergedValue = StringToFloat(xFloat->get_value()) +
                                yInt->get_value().c_int() ;
            return create_float_constant(theEnv, xFloat->get_result_type(),
                                         FloatToString(mergedValue)) ;
        }
    }

    if (opcode == LString("subtract"))
    {
        if (xInt != NULL && yInt != NULL)
        {
            int mergedValue = xInt->get_value().c_int() - yInt->get_value().c_int() ;
            return create_int_constant(theEnv, xInt->get_result_type(),
                                       IInteger(mergedValue)) ;
        }
        if (xFloat != NULL && yFloat != NULL)
        {
            float mergedValue = StringToFloat(xFloat->get_value()) -
                                StringToFloat(yFloat->get_value()) ;
            return create_float_constant(theEnv, xFloat->get_result_type(),
                                         FloatToString(mergedValue)) ;
        }
        if (xInt != NULL && yFloat != NULL)
        {
            float mergedValue = xInt->get_value().c_int() -
                                StringToFloat(yFloat->get_value()) ;
            return create_float_constant(theEnv, yFloat->get_result_type(),
                                         FloatToString(mergedValue)) ;
        }
        if (xFloat != NULL && yInt != NULL)
        {
            float mergedValue = StringToFloat(xFloat->get_value()) -
                                yInt->get_value().c_int() ;
            return create_float_constant(theEnv, xFloat->get_result_type(),
                                         FloatToString(mergedValue)) ;
        }
    }

    return NULL ;

}
void ConstantArrayPropagationPass::ReplaceLoad(LoadExpression* load,
					       ArrayReferenceExpression* ref,
					       VariableSymbol* var,
					       ValueBlock* topBlock) 
{
  list<IntConstant*> allDimensions ;
  
  IntConstant* nextIndex = dynamic_cast<IntConstant*>(ref->get_index()) ;
  if (nextIndex == NULL)
  {   
    OutputWarning("Trying to access a constant array with a nonconstant index!") ;
    delete var->remove_annote_by_name("ConstPropArray") ;
    //    assert(0) ;
    return ;
  }
  allDimensions.push_front(nextIndex) ;
  
  ArrayReferenceExpression* nextDimension = 
    dynamic_cast<ArrayReferenceExpression*>(ref->get_base_array_address()) ;
  while (nextDimension != NULL)
  {
    nextIndex = dynamic_cast<IntConstant*>(nextDimension->get_index()) ;
    assert(nextIndex != NULL) ;
    allDimensions.push_front(nextIndex) ;
    nextDimension = dynamic_cast<ArrayReferenceExpression*>(nextDimension->get_base_array_address()) ;
  }

  ValueBlock* currentBlock = topBlock ;
  
  list<IntConstant*>::iterator dimIter = allDimensions.begin() ;

  for (int i = 0 ; i < allDimensions.size() ; ++i)
  {
    MultiValueBlock* multiBlock = dynamic_cast<MultiValueBlock*>(currentBlock);
    assert(multiBlock != NULL) ;
    currentBlock = multiBlock->lookup_sub_block((*dimIter)->get_value()) ;
    ++dimIter ;
  }
  
  ExpressionValueBlock* finalBlock = 
    dynamic_cast<ExpressionValueBlock*>(currentBlock) ;
  assert(finalBlock != NULL && 
	 "Attempted to use an uninitialized constant value!") ;
  Expression* replacementValue = finalBlock->get_expression() ;
  if (dynamic_cast<IntConstant*>(replacementValue) != NULL)
  {
    IntConstant* constInt = 
      dynamic_cast<IntConstant*>(replacementValue) ;
    IntConstant* replacement =
      create_int_constant(theEnv, 
			  constInt->get_result_type(),
			  constInt->get_value()) ;
    load->get_parent()->replace(load, replacement) ;
    delete load ;
  }
  else if (dynamic_cast<FloatConstant*>(replacementValue) != NULL)
  {
    FloatConstant* constFloat = 
      dynamic_cast<FloatConstant*>(replacementValue) ;
    FloatConstant* replacement = 
      create_float_constant(theEnv,
			    constFloat->get_result_type(),
			    constFloat->get_value()) ;
    load->get_parent()->replace(load, replacement) ;
    delete load ;
  }
  else
  {
    assert(0 && "Unknown constant") ;
  }

}