static void declareParameter( // DEFINE A FUNCTION PARAMETER SYMBOL sym ) // - the parameter { cg_type cgtype; // - type for code generator FN_CTL* fctl; // - function information TYPE ftype; // - function type if( sym != NULL ) { fctl = FnCtlTop(); ftype = FunctionDeclarationType( fctl->func->sym_type ); sym = inlineSymbol( sym ); if( ( TF1_PLUSPLUS & ftype->flag ) && OMR_CLASS_REF == ObjModelArgument( sym->sym_type ) ) { cgtype = TY_POINTER; } else { cgtype = CgTypeOutput( sym->sym_type ); } CGParmDecl( (cg_sym_handle)sym, cgtype ); if( fctl->debug_info && ( GenSwitches & DBG_LOCALS ) ) { if( GenSwitches & DBG_DF ){ DwarfSymDebugGenSymbol( sym, true, cgtype == TY_POINTER ); }else{ SymbolicDebugGenSymbol( sym, true, cgtype == TY_POINTER ); } } IbpDefineSym( fctl->handle, sym ); } }
void CgSetType( // SET NORMAL TYPE FOR GENERATION TYPE type ) // - the type { if( OMR_CLASS_REF == ObjModelArgument( type ) ) { type = MakeReferenceTo( type ); } CgSetTypeExact( type ); }
cg_type CgTypeSym( // COMPUTE OUTPUT TYPE FOR SYMBOL SYMBOL sym ) // - the symbol { TYPE type = sym->sym_type; if( SymIsArgument( sym ) && NULL != StructType( type ) && OMR_CLASS_REF == ObjModelArgument( type ) ) { type = MakeReferenceTo( type ); } return CgTypeOutput( type ); }
cg_type CgGetCgType( // GET CODEGEN TYPE TYPE type ) // - type { TYPE basic; // - basic type cg_type cgtype; // - codegen type basic = TypedefModifierRemove( type ); if( basic->id == TYP_CLASS ) { if( OMR_CLASS_VAL == ObjModelArgument( basic ) ) { cgtype = prcCgType( CgTypeOutput( type ) ); } else { cgtype = TY_POINTER; } } else { cgtype = prcCgType( CgTypeOutput( type ) ); } return cgtype; }
static boolean adjustForVirtualCall( // ADJUSTMENTS FOR POSSIBLE VIRTUAL CALL PTREE *this_node, // - addr[ "this" node ] PTREE *routine, // - routine to be called SEARCH_RESULT *result ) // - search result for routine { SYMBOL sym; // - symbol for call unsigned retn; // - return: TRUE ==> adjusted for virtual TYPE this_type; // - target type for "this" PTREE expr; // - transformed expression boolean exact_call; // - TRUE ==> this node is exact expr = *this_node; this_type = NodeType( expr ); this_type = StructType( this_type ); if( this_type != NULL ) { if( OMR_CLASS_VAL == ObjModelArgument( this_type ) ) { expr = NodeAssignTemporary( this_type, expr ); } else { expr = NodeConvert( MakePointerTo( expr->type ), expr ); } *this_node = expr; } sym = (*routine)->u.symcg.symbol; this_type = TypeThisForCall( expr, sym ); /* virtual calls don't have to check for NULL pointers when they convert */ expr->flags |= PTF_PTR_NONZERO; exact_call = expr->flags & PTF_MEMORY_EXACT; NodeConvertToBasePtr( this_node, this_type, result, TRUE ); sym = SymDefaultBase( sym ); if( ( SymIsVirtual( sym ) ) &&( ! ( (*routine)->flags & PTF_COLON_QUALED ) ) &&( ! exact_call ) ) { expr = AccessVirtualFnAddress( NodeDupExpr( this_node ) , result , sym ); expr->type = MakePointerTo( expr->type ); *routine = NodeReplace( *routine, expr ); retn = TRUE; } else { NodeFreeSearchResult( *routine ); retn = FALSE; } return( retn ); }
PTREE AnalyseCall( // ANALYSIS FOR CALL PTREE expr, // - call expression CALL_DIAG *diagnostic ) // - diagnostics used for function problems { PTREE *r_args; // - reference( arguments ) PTREE *r_func; // - reference( function ) PTREE *ptlist; // - nodes for arguments PTREE left; // - left operand ( the function ) PTREE right; // - right operand ( the arguments ) PTREE this_node; // - node for "this" computation PTREE deref_args; // - member pointer dereference args PTREE last_arg; // - last argument PTREE static_fn_this; // - "this" for a static member PTREE templ_args; // - explicit template arguments SYMBOL sym; // - function symbol SYMBOL caller_sym; // - function that is doing the call TYPE type; // - temporary type TYPE fn_type; // - function type type_flag fn_mod; // - function modifier flags unsigned count; // - # args, caller arg_list *alist; // - arg_list for caller intrinsic_mapping *intr_map;// - mapping for intrinsic function SEARCH_RESULT *result; // - searching result boolean membptr_deref; // - TRUE ==> member pointer dereference boolean has_ellipsis; // - TRUE ==> ellipsis in argument list boolean virtual_call; // - TRUE ==> virtual call TEMP_PT_LIST default_list; // - default PTREE list TEMP_ARG_LIST default_args; // - default arg_list FNOV_DIAG fnov_diag; // - diagnosis information; r_args = PTreeRefRight( expr ); last_arg = *r_args; right = NodeReverseArgs( &count, last_arg ); *r_args = right; r_func = PTreeRefLeft( expr ); left = *r_func; membptr_deref = FALSE; this_node = NULL; intr_map = NULL; static_fn_this = NULL; virtual_call = FALSE; switch( left->cgop ) { case CO_DOT: case CO_ARROW: this_node = left->u.subtree[0]; left->u.subtree[0] = NULL; left = NodePruneTop( left ); *r_func = left; r_func = PTreeRefLeft( expr ); left = *r_func; if( ( left->op == PT_ID ) && ( left->cgop == CO_NAME_DTOR ) ) { /* dtor of a non-class type */ left = NodePruneTop( *r_func ); /* NYI: verify dtor call has no arguments */ expr->u.subtree[0] = NULL; NodeFreeDupedExpr( expr ); expr = NodeConvert( GetBasicType( TYP_VOID ), this_node ); expr = NodeComma( expr, left ); return( expr ); } break; case CO_CALL_EXEC_IND: if( left->flags & PTF_CALLED_ONLY ) { /* member pointer dereference being called */ deref_args = left->u.subtree[1]; this_node = NodeDupExpr( &(deref_args->u.subtree[1]) ); membptr_deref = TRUE; } break; } alist = ArgListTempAlloc( &default_args, count ); ptlist = PtListAlloc( default_list, count ); NodeBuildArgList( alist, ptlist, right, count ); if( this_node == NULL ) { alist->qualifier = FunctionThisQualifier(); } else { alist->qualifier = BaseTypeClassFlags( NodeType( this_node ) ); } if( NodeIsBinaryOp( left, CO_TEMPLATE ) ) { DbgAssert( left->u.subtree[0]->op == PT_SYMBOL ); templ_args = left->u.subtree[1]; left->u.subtree[1] = NULL; left = NodePruneTop( left ); *r_func = left; r_func = PTreeRefLeft( expr ); left = *r_func; } else { templ_args = NULL; } if( left->op == PT_SYMBOL ) { FNOV_RESULT ovret; SYMBOL orig; // - original symbol sym = left->u.symcg.symbol; orig = sym; if( left->cgop == CO_NAME_CONVERT ) { ovret = UdcOverloadedDiag( &sym , left->u.symcg.result , sym , SymFuncReturnType( sym ) , alist->qualifier , &fnov_diag ); } else { ovret = FuncOverloadedDiag( &sym , left->u.symcg.result , sym , alist , ptlist , templ_args , &fnov_diag ); } switch( ovret ) { case FNOV_AMBIGUOUS : CallDiagAmbiguous( expr, diagnostic->msg_ambiguous, &fnov_diag ); NodeFreeDupedExpr( this_node ); ArgListTempFree( alist, count ); PtListFree( ptlist, count ); return( expr ); case FNOV_NO_MATCH : if( this_node == NULL ) { if( SymIsThisFuncMember( orig ) ) { this_node = NodeThisCopyLocation( left ); } } if( this_node != NULL ) { if( ( ! SymIsCtor( orig ) ) &&( ! SymIsDtor( orig ) ) &&( CNV_OK != AnalysePtrCV ( this_node , TypeThisSymbol( orig , this_node->flags & PTF_LVALUE ) , NodeType( this_node ) , CNV_FUNC_THIS ) ) ) { PTreeErrorNode( expr ); InfSymbolDeclaration( orig ); NodeFreeDupedExpr( this_node ); ArgListTempFree( alist, count ); PtListFree( ptlist, count ); return( expr ); } } CallDiagNoMatch( expr , diagnostic->msg_no_match_one , diagnostic->msg_no_match_many , this_node , orig , &fnov_diag ); NodeFreeDupedExpr( this_node ); ArgListTempFree( alist, count ); PtListFree( ptlist, count ); return( expr ); } FnovFreeDiag( &fnov_diag ); left->u.symcg.symbol = sym; result = left->u.symcg.result; if( this_node == NULL ) { if( SymIsThisFuncMember( sym ) ) { if( result->use_this ) { this_node = NodeThisCopyLocation( left ); if( this_node == NULL ) { PTreeErrorExpr( expr, ERR_INVALID_NONSTATIC_ACCESS ); InfSymbolDeclaration( sym ); ArgListTempFree( alist, count ); PtListFree( ptlist, count ); return( expr ); } } else { PTreeErrorExpr( expr, ERR_BARE_FUNCTION_ACCESS ); InfSymbolDeclaration( sym ); ArgListTempFree( alist, count ); PtListFree( ptlist, count ); return( expr ); } } } if( ! AnalyseSymbolAccess( expr, left, this_node, &diagAccess ) ) { NodeFreeDupedExpr( this_node ); ArgListTempFree( alist, count ); PtListFree( ptlist, count ); return( expr ); } type = sym->sym_type; fn_type = TypeGetActualFlags( type, &fn_mod ); if( fn_type->flag & TF1_INTRINSIC ) { intr_map = intrinsicMapping( sym ); if( intr_map == NULL ) { outputCallTriggeredWarning( expr, sym ); } } if( fn_mod & TF1_FAR16 ) { /* we are calling a far16 function */ caller_sym = ScopeFunctionInProgress(); caller_sym->flag |= SF_FAR16_CALLER; } left->type = type; if( this_node == NULL ) { if( SymIsThisFuncMember( sym ) ) { this_node = NodeThisCopyLocation( left ); } } else { if( SymIsStaticFuncMember( sym ) ) { #ifdef OLD_STATIC_MEMBER_ACCESS NodeFreeDupedExpr( this_node ); #else static_fn_this = this_node; #endif this_node = NULL; } } if( this_node != NULL ) { TYPE pted; pted = TypePointedAtModified( this_node->type ); if( pted == NULL ) { pted = this_node->type; } if( TypeTruncByMemModel( pted ) ) { if( SymIsCtor( sym ) ) { PTreeErrorExpr( this_node, ERR_CTOR_OBJ_MEM_MODEL ); } else if( SymIsDtor( sym ) ) { PTreeErrorExpr( this_node, ERR_DTOR_OBJ_MEM_MODEL ); } else { PTreeErrorExpr( this_node, ERR_THIS_OBJ_MEM_MODEL ); } InfSymbolDeclaration( sym ); PTreeErrorNode( expr ); NodeFreeDupedExpr( this_node ); ArgListTempFree( alist, count ); PtListFree( ptlist, count ); NodeFreeDupedExpr( static_fn_this ); return( expr ); } if( adjustForVirtualCall( &this_node, r_func, result ) ) { virtual_call = TRUE; expr->cgop = CO_CALL_EXEC_IND; left = VfunSetupCall( expr->u.subtree[0] ); left = VfnDecorateCall( left, sym ); } else { expr->cgop = CO_CALL_EXEC; left = NodeUnaryCopy( CO_CALL_SETUP, expr->u.subtree[0] ); SymMarkRefed( sym ); } } else { NodeFreeSearchResult( left ); expr->cgop = CO_CALL_EXEC; left = NodeUnaryCopy( CO_CALL_SETUP, expr->u.subtree[0] ); SymMarkRefed( sym ); } } else { if( ! membptr_deref ) { /* i.e, p->foo() where foo is a pointer to a function */ NodeFreeDupedExpr( this_node ); this_node = NULL; } sym = NULL; left = expr->u.subtree[0]; type = TypedefModifierRemove( left->type ); if( type->id == TYP_POINTER ) { type = type->of; } fn_type = TypeGetActualFlags( type, &fn_mod ); if( fn_mod & TF1_FAR16 ) { /* we are calling a far16 function */ caller_sym = ScopeFunctionInProgress(); caller_sym->flag |= SF_FAR16_CALLER; } if( ! TypeHasNumArgs( type, count ) ) { PTreeErrorExpr( expr, ERR_PARM_COUNT_MISMATCH_POINTER ); CErr2p( INF_FUNCTION_TYPE, type ); ArgListTempFree( alist, count ); PtListFree( ptlist, count ); NodeFreeDupedExpr( static_fn_this ); return( expr ); } expr->cgop = CO_CALL_EXEC_IND; left = VfunSetupCall( left ); } expr->u.subtree[0] = left; #if _CPU == _AXP if( intr_map != NULL && intr_map->cgop == CO_VASTART ) { expr = convertVaStart( expr, alist, type ); } else { expr = NodeConvertCallArgList( expr, count, type, &expr->u.subtree[1] ); } #else expr = NodeConvertCallArgList( expr, count, type, &expr->u.subtree[1] ); #endif if( expr->op != PT_ERROR ) { TYPE ftype; // - function type PTREE cdtor; // - CDTOR node PTREE callnode; // - call node PTREE retnnode; // - return node (for struct return) callnode = expr; if( this_node == NULL ) { cdtor = NULL; } else { this_node = NodeArg( this_node ); if( virtual_call ) { this_node->flags |= PTF_ARG_THIS_VFUN; } if( sym != NULL && SymIsDtor( sym ) ) { cdtor = NodeArg( NodeCDtorArg( DTOR_NULL ) ); } else { cdtor = NULL; } } ftype = type; type = TypedefModifierRemove( type ); has_ellipsis = TypeHasEllipsisArg( type ); type = type->of; { TYPE tgt = TypeReference( type ); if( tgt == NULL ) { expr->type = type; } else { expr->type = tgt; expr->flags |= PTF_LVALUE; } } if( sym != NULL ) { if( ! AddDefaultArgs( sym, expr ) ) { NodeFreeDupedExpr( cdtor ); NodeFreeDupedExpr( this_node ); ArgListTempFree( alist, count ); PtListFree( ptlist, count ); return expr; } } if( NULL != TypeReference( type ) ) { expr->flags |= PTF_LVALUE; } if( OMR_CLASS_REF == ObjModelArgument( type ) ) { retnnode = NodeTemporary( type ); retnnode = PTreeCopySrcLocation( retnnode, expr ); } else { retnnode = NULL; } expr = CallArgsArrange( ftype , callnode , callnode->u.subtree[1] , this_node , cdtor , retnnode ); if( retnnode != NULL ) { expr = NodeDtorExpr( expr, retnnode->u.symcg.symbol ); if( SymRequiresDtoring( retnnode->u.symcg.symbol ) ) { expr = PtdCtoredExprType( expr, NULL, type ); } } type = StructType( type ); if( type != NULL && ! TypeDefined( type ) ) { PTreeErrorExpr( expr, ERR_RETURN_UNDEFD_TYPE ); } if( intr_map != NULL && expr->op != PT_ERROR ) { #if _CPU == _AXP if( intr_map->cgop == CO_VASTART ) { expr = transformVaStart( expr ); } else { expr = PTreeIntrinsicOperator( expr, intr_map->cgop ); } #else expr = PTreeIntrinsicOperator( expr, intr_map->cgop ); #endif expr->flags |= PTF_MEANINGFUL | PTF_SIDE_EFF; } } if( static_fn_this != NULL ) { expr = NodeCommaIfSideEffect( static_fn_this, expr ); } ArgListTempFree( alist, count ); PtListFree( ptlist, count ); return expr; }
static PTREE transformVaStart // TRANSFORM TO CO_VASTART OPCODE ( PTREE expr ) // - va_start expression { SYMBOL pre_ellipsis_sym; SYMBOL stop; SYMBOL curr; SYMBOL fn; SCOPE caller_arg_scope; unsigned offset; target_size_t arg_size; PTREE arg1; PTREE arg2; PTREE arg3; PTREE valist; // second argument -- must be pre-... parameter arg1 = expr->u.subtree[1]; arg2 = arg1->u.subtree[0]; arg3 = arg2->u.subtree[0]; pre_ellipsis_sym = PTreeOp( &arg2->u.subtree[1] )->u.symcg.symbol; caller_arg_scope = ScopeFunctionScopeInProgress(); fn = ScopeFunction( caller_arg_scope ); offset = 0; if( ObjModelFunctionReturn( fn->sym_type ) == OMR_CLASS_VAL ) { offset += TARGET_PACKING; } if( SymIsThisMember( fn ) ) { offset += TARGET_PACKING; if( SymCDtorExtraParm( fn ) ) { offset += TARGET_PACKING; } } stop = ScopeOrderedStart( caller_arg_scope ); curr = NULL; for(;;) { curr = ScopeOrderedNext( stop, curr ); if( curr == NULL ) { PTreeErrorExpr( expr, ERR_INVALID_VASTART_SYMBOL ); return( expr ); } if( ObjModelArgument( curr->sym_type ) == OMR_CLASS_REF ) { arg_size = TARGET_PACKING; } else { arg_size = CgMemorySize( curr->sym_type ); arg_size += TARGET_PACKING - 1; arg_size &= ~( TARGET_PACKING - 1 ); } offset += arg_size; if( curr == pre_ellipsis_sym ) break; } if( ScopeOrderedNext( stop, curr ) != NULL ) { PTreeErrorExpr( expr, ERR_INVALID_VASTART_SYMBOL ); return( expr ); } // third argument -- va_list symbol valist = arg1->u.subtree[1]; arg1->u.subtree[1] = NULL; if( arg3->u.subtree[1]->u.int_constant == 0 ) { // compensate for "void *__alist;" arg in <varargs.h> offset -= TARGET_PACKING; } NodeFreeDupedExpr( expr ); expr = NodeBinary( CO_VASTART, valist, NodeOffset( offset ) ); return expr; }
PTREE NodeConvertCallArgList( // CONVERT CALL ARGUMENT LIST, AS REQ'D PTREE call_expr, // - call expression (for errors only) unsigned acount, // - # args, caller TYPE type, // - function type PTREE *args ) // - addr( caller argument nodes ) { PTREE arg; // - caller argument nodes arg_list *plist; // - prototype arguments unsigned count; // - # args, processed unsigned pcount; // - # args, prototype TYPE *pptr; // - prototype type ptr. TYPE proto; // - prototype arg. type boolean extern_c_fun; // - TRUE ==> extern "C" function TEMP_TYPE old; // - old default class for temp.s if( call_expr != NULL && call_expr->op != PT_ERROR && acount > 0 ) { old = TemporaryClass( TEMP_TYPE_EXPR ); plist = TypeArgList( type ); pptr = plist->type_list; pcount = plist->num_args; type = FunctionDeclarationType( type ); if( TypeHasEllipsisArg( type ) ) { for( count = 1 ; count <= acount ; ++count, args = &arg->u.subtree[0] ) { arg = PTreeOp( args ); if( ! ( count < pcount ? arg_convert( arg, *pptr++ ) : convertEllipsisArg( arg ) ) ) { PTreeErrorNode( call_expr ); break; } } } else { if( type->flag & TF1_PLUSPLUS ) { extern_c_fun = FALSE; } else { extern_c_fun = TRUE; } for( count = 1 ; count <= acount ; ++count, args = &arg->u.subtree[0] ) { TYPE cl_type; arg = PTreeOp( args ); proto = *pptr++; if( ! arg_convert( arg, proto ) ) { PTreeErrorNode( call_expr ); break; } cl_type = StructType( proto ); if( NULL != cl_type ) { if( extern_c_fun ) { if( ! passStructOnStack( arg , WARN_EXTERN_C_CLASS_ARG ) ) { PTreeErrorNode( call_expr ); break; } } else if( OMR_CLASS_VAL == ObjModelArgument( cl_type ) ) { passStructOnStack( arg, ERR_CALL_WATCOM ); } } } } TemporaryClass( old ); } return( call_expr ); }