CALL_OPT AnalyseCallOpts // ANALYSE CALL OPTIMIZATIONS ( TYPE type // - class type of target operand , PTREE src // - source operand , PTREE* a_dtor // - addr[ CO_DTOR ] , PTREE* a_right ) // - addr[ base source operand ] { CALL_OPT retn; // - type of return PTREE right; // - bare source operand right = *NodeReturnSrc( &src, a_dtor ); *a_right = right; if( type == ClassTypeForType( right->type ) ) { if( NodeCallsCtor( right ) ) { retn = CALL_OPT_CTOR; } else if( NodeIsBinaryOp( right, CO_CALL_EXEC ) || NodeIsBinaryOp( right, CO_CALL_EXEC_IND ) ) { TYPE ftype; // - function type ftype = TypeFunctionCalled( NodeFuncForCall( right )->type ); DbgVerify( ftype != NULL , "AnalyseCLassCallOpts -- impossible parse tree" ); if( OMR_CLASS_REF == ObjModelFunctionReturn( ftype ) ) { retn = CALL_OPT_FUN_CALL; } else { retn = CALL_OPT_NONE; } } else if( NodeIsBinaryOp( right, CO_COPY_OBJECT ) ) { PTREE tgt = NodeRemoveCastsCommas( right->u.subtree[0] ); if( tgt->op == PT_SYMBOL && SymIsTemporary( tgt->u.symcg.symbol ) ) { retn = CALL_OPT_BIN_COPY; } else { retn = CALL_OPT_NONE; } } else { retn = CALL_OPT_NONE; } } else { retn = CALL_OPT_NONE; } return retn; }
static CNV_RETN propogateNonZero( // PROPOGATE PTF_PTR_NONZERO TO COMMON CNV_RETN retn, // - return: CNV_... PTREE expr ) // - expression { if( NodeIsBinaryOp( expr, CO_COLON ) ) { if( ( PTreeOpLeft( expr )->flags & PTF_PTR_NONZERO ) && ( PTreeOpRight( expr )->flags & PTF_PTR_NONZERO ) ) { expr->flags |= PTF_PTR_NONZERO; } } return( retn ); }
static bool isCondDecor( // TEST IF CONDITIONALLY DECORATED PTREE node ) // - the expression { bool retb; // - true ==> conditionally decorated retb = false; if( NodeIsBinaryOp( node, CO_COMMA ) ) { node = node->u.subtree[0]; if( node->op == PT_IC ) { if( node->u.ic.opcode == IC_COND_TRUE || node->u.ic.opcode == IC_COND_FALSE ) { retb = true; } } } return( retb ); }
PTREE AnalyseReturnClassVal // RETURN CLASS VALUE ( PTREE expr ) // - expression for return { TYPE retn_type; // - return type TYPE retn_class; // - class for return PTREE tgt; // - target expression CNV_DIAG* diag; // - diagnosis retn_type = expr->u.subtree[0]->type; retn_class = StructType( retn_type ); DbgVerify( retn_class != NULL, "AnalyseReturnClassVal -- not class" ); if( ClassCorrupted( retn_class ) ) { PTreeErrorNode( expr ); } else if( TypeAbstract( retn_class ) ) { PTreeErrorExprType( expr, ERR_CONVERT_TO_ABSTRACT_TYPE, retn_class ); ScopeNotePureFunctions( retn_class ); } else { diag = DefargBeingCompiled() ? &diagDefarg : &diagReturn; tgt = NodeFetchReference( getReturnSym() ); expr = removeReturnNode( expr ); expr = CopyClassRetnVal( expr, tgt, retn_type, diag ); if( expr->op != PT_ERROR ) { if( NodeIsBinaryOp( expr, CO_DTOR ) ) { PTREE node = expr->u.subtree[0]; if( SymFunctionReturn() == node->u.symcg.symbol ) { PTreeFree( node ); node = expr; expr = expr->u.subtree[1]; PTreeFree( node ); } } } #if 0 // this is just so we can do some checking expr = CastImplicit( expr , retn_type , CNV_EXPR , DefargBeingCompiled() ? &diagDefarg : &diagReturn ); } #endif }
static void checkAutoReturn( // CHECK IF AUTOMATIC BEING RETURNED PTREE node, // - node to be checked TYPE ret_type ) // - return type { TYPE func_ret; // - type of function return SYMBOL func; // - function called SYMBOL comped; // - function being compiled PTREE expr; // - node for error TYPE refed; // - NULL ==> not reference comped = ScopeFunctionInProgress(); if( SymIsGenedFunc( comped ) ) { return; } expr = node; refed = TypeReference( ret_type ); for( ; ; ) { node = NodeRemoveCastsCommas( node ); if( ( node->op == PT_SYMBOL ) &&( SymIsAutomatic( node->u.symcg.symbol ) ) ) { if( NULL == refed ) { PTreeWarnExpr( expr, WARN_RET_ADDR_OF_AUTO ); } else { PTreeErrorExpr( expr, ERR_RET_AUTO_REF ); } break; } else if( NodeIsBinaryOp( node, CO_DOT ) || NodeIsBinaryOp( node, CO_DOT_STAR ) ) { node = PTreeOpLeft( node ); } else if( NodeIsUnaryOp( node, CO_ADDR_OF ) ) { node = PTreeOpLeft( node ); } else if( NULL != refed ) { if( NodeIsBinaryOp( node, CO_DTOR ) ) { node = PTreeOpRight( node ); } else if( NodeIsBinaryOp( node, CO_CALL_EXEC ) ) { node = PTreeOpLeft( PTreeOpLeft( node ) ); if( node->op == PT_SYMBOL ) { func = node->u.symcg.symbol; if( SymIsCtor( func ) ) { PTreeErrorExpr( expr, ERR_RET_AUTO_REF ); } else { func_ret = SymFuncReturnType( func ); if( NULL != StructType( func_ret ) ) { PTreeErrorExpr( expr, ERR_RET_AUTO_REF ); } } } break; } else if( NodeIsBinaryOp( node, CO_CALL_EXEC_IND ) ) { func_ret = TypeFunctionCalled( NodeFuncForCall( node )->type ); func_ret = func_ret->of; if( NULL != StructType( func_ret ) ) { PTreeErrorExpr( expr, ERR_RET_AUTO_REF ); } break; } else { break; } } else { break; } } }
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; }