static boolean passStructOnStack( // PASS A STRUCT/CLASS ON STACK PTREE arg, // - argument (CO_LIST) unsigned warning ) // - internal-data warning { PTREE right; // - right operand TYPE type; // - class type right = NodeRvalue( arg->u.subtree[1] ); type = right->type; if( right->flags & PTF_CLASS_RVREF ) { if( right->op != PT_ERROR ) { PTREE temp = NodeTemporary( type ); right = ClassDefaultCopyDiag( temp, right, &diagEllConv ); if( right->op != PT_ERROR ) { right = NodeDtorExpr( right, temp->u.symcg.symbol ); if( right->op != PT_ERROR ) { right->type = type; right = NodeFetch( right ); right->flags &= ~PTF_LVALUE; } } } if( right->op == PT_ERROR ) { arg->u.subtree[1] = right; PTreeErrorNode( arg ); return FALSE; } } arg_finish( right, arg ); if( TypeHasSpecialFields( type ) ) { PTreeWarnExpr( arg, warning ); } return TRUE; }
static boolean arg_convert( // CONVERT AN ARGUMENT PTREE arg, // - argument node TYPE proto ) // - prototype type { boolean retn; // - return: TRUE ==> ok if( NodeConvertArgument( &arg->u.subtree[1], proto ) ) { arg_fillout( arg ); retn = TRUE; } else { PTreeErrorNode( arg ); retn = FALSE; } return( retn ); }
CNV_RETN ConversionDiagnose( // DIAGNOSE RETURN FROM A CONVERSION CNV_RETN retn, // - return value: CNV_... PTREE expr, // - current expression CNV_DIAG *diagnosis ) // - diagnosis information { switch( retn ) { case CNV_OK_TRUNC : NodeWarnPtrTrunc( expr ); retn = CNV_OK; break; case CNV_OK_TRUNC_CAST : NodeWarnPtrTruncCast( expr ); retn = CNV_OK; break; case CNV_ERR : PTreeErrorNode( expr ); ConversionDiagnoseInf(); retn = CNV_ERR; break; case CNV_IMPOSSIBLE : retn = conversionErr( expr, diagnosis->msg_impossible ); break; case CNV_AMBIGUOUS : retn = conversionErr( expr, diagnosis->msg_ambiguous ); break; case CNV_PRIVATE : retn = conversionErr( expr, diagnosis->msg_private ); break; case CNV_PROTECTED : retn = conversionErr( expr, diagnosis->msg_protected ); break; case CNV_VIRT_DER : retn = conversionErr( expr, diagnosis->msg_virt_der ); break; case CNV_TRUNC_THIS : ConversionInfDisable(); retn = conversionErr( expr, ERR_THIS_OBJ_MEM_MODEL ); break; case CNV_OK : break; DbgDefault( "ConversionDiagnose: unexpected 'retn' value" ); } return retn; }
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 PTREE convertVaStart( // CONVERT va_start function call PTREE expr, // - expression arg_list *alist, // - arguments for caller TYPE type ) // - function type { PTREE arg; arg_list *plist; // - prototype arguments PTREE right; // - right operand if( alist->num_args != 3 ) { return expr; } plist = TypeArgList( type ); // va_list symbol arg = expr->u.subtree[1]; if( ! arg_convert( arg, plist->type_list[0] ) ) { PTreeErrorNode( expr ); return expr; } // second argument -- must be parameter to current function // - here we check for symbol // - we check that it is a parameter in transformVaStart arg = arg->u.subtree[0]; right = PTreeOp( &arg->u.subtree[1] ); if( right->op != PT_SYMBOL ) { if( ! canCoaxVAStartSym( &arg->u.subtree[1] ) ) { PTreeErrorExpr( expr, ERR_INVALID_VASTART_SYMBOL ); return expr; } } // third argument -- must be 0 or one arg = arg->u.subtree[0]; right = PTreeOp( &arg->u.subtree[1] ); if( right->op != PT_INT_CONSTANT ) { PTreeErrorExpr( expr, ERR_INVALID_VASTART_SYMBOL ); return expr; } return expr; }
PTREE CopyOptimize // COPY OPTIMIZATION ( PTREE right // - base source operand (function call) , PTREE src // - original source operand , PTREE left // - target operand , PTREE dtor // - NULL or CO_DTOR expression , CALL_OPT opt ) // - type of optimization { PTREE expr; // - resultant expression PTREE parm; // - parameter node to be replaced switch( opt ) { case CALL_OPT_NONE : DbgVerify( 0, "CopyOptimize -- CALL_OPT_NONE" ); break; case CALL_OPT_CTOR : for( parm = right->u.subtree[1] ; 0 == ( parm->flags & PTF_ARG_THIS ) ; parm = parm->u.subtree[0] ) ; expr = doCopyElimination( parm, src, left, dtor ); break; case CALL_OPT_FUN_CALL : for( parm = right->u.subtree[1] ; 0 == ( parm->flags & PTF_ARG_RETURN ) ; parm = parm->u.subtree[0] ) ; expr = doCopyElimination( parm, src, left, dtor ); break; case CALL_OPT_BIN_COPY : expr = doCopySubstitution( &right->u.subtree[0], src, left, dtor ); break; case CALL_OPT_ERR : PTreeErrorNode( left ); NodeFreeDupedExpr( src ); expr = left; break; DbgDefault( "CopyOptimize -- impossible optimization" ); } return expr; }
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; }
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 ); }