fe_seg_id CgSegIdData( SYMBOL sym, SEGID_CONTROL control ) /********************************************************/ { fe_seg_id id; type_flag flags; if( SymIsAutomatic( sym ) ) { id = cgSegIdAuto( sym ); } else if( SymIsFunction( sym ) ) { id = CgSegIdFunction( sym ); } else { id = sym->segid; if( id == SEG_NULL ) { TypeGetActualFlags( sym->sym_type, &flags ); if( flags & TF1_THREAD ) { id = cgSegIdThread( sym, flags ); } else if( flags & TF1_BASED ) { id = cgSegIdBased( sym, flags ); #if _CPU == _AXP || COMP_CFG_COFF == 1 } else if( SymIsComdatData( sym ) ) { id = SegmentAddComdatData( sym, control ); #endif } else { id = cgSegIdVariable( sym, flags, control ); } sym->segid = id; } SegmentMarkUsed( id ); } return( id ); }
TYPE TypeAutoDefault( // ADD NEAR QUALIFIER FOR AUTO SYMBOL TYPE type, // - a type PTREE expr ) // - possible PT_SYMBOL of SC_AUTO { #if 0 if( PtreeOpFlags( expr ) & PTO_RVALUE ) { type = augmentWithNear( type ); } else if( expr->op == PT_SYMBOL ) { #else if( expr->op == PT_SYMBOL ) { #endif SYMBOL sym = expr->u.symcg.symbol; if( sym->id == SC_AUTO ) { type_flag flags; TypeGetActualFlags( sym->sym_type, &flags ); if( 0 == ( flags & TF1_MEM_MODEL ) ) { type = augmentWithNear( type ); } } } return( type ); } TYPE TypeForLvalue // GET TYPE FOR LVALUE ( PTREE expr ) // - lvalue expression { TYPE type_expr; // - expression type TYPE type_lv; // - type of LVALUE type_expr = NodeType( expr ); type_lv = TypeReference( type_expr ); DbgVerify( type_lv != NULL, "TypeForLvalue -- not lvalue" ); return( type_lv ); }
fe_seg_id CgSegIdFunction( SYMBOL sym ) /*************************************/ { fe_seg_id id; type_flag flags; id = sym->segid; if( id == SEG_NULL ) { if( SymIsInitialized( sym ) ) { // defined in this compilation unit id = SegmentForDefinedFunc( sym ); } else { TypeGetActualFlags( sym->sym_type, &flags ); if( flags & TF1_FAR ) { id = SegmentImport(); } else if( IsBigCode() ) { id = SegmentImport(); } else { id = SegmentDefaultCode(); } } sym->segid = id; } return( id ); }
TYPE TypeMergeForMember( // CREATE MERGED TYPE FOR A MEMBER TYPE owner, // - type on left (.), type pointed at (->) TYPE member ) // - type for member { type_flag owner_flags; // - modifier flags for owner type_flag member_flags; // - modifier flags for member type_flag result_flags; // - modifier flags for result void *owner_base; // - base for owner TypeModExtract( owner , &owner_flags , &owner_base , TC1_NOT_ENUM_CHAR ); member = TypeGetActualFlags( member, &member_flags ); if( owner_flags & TF1_CONST ) { if( member_flags & TF1_MUTABLE ) { owner_flags &= ~TF1_CONST; } } result_flags = owner_flags | member_flags; if( result_flags != TF1_NULL ) { member = MakeBasedModifierOf( member, result_flags, owner_base ); } return( member ); }
static TYPE augmentWithNear( // AUGMENT TYPE WITH TF1_NEAR, IF REQ'D TYPE type ) // - type to be augmented { type_flag flags; // - existing flags TypeGetActualFlags( type, &flags ); if( 0 == ( flags & TF1_MEM_MODEL ) ) { type = MakeModifiedType( type, TF1_NEAR ); } return( type ); }
bool TypeTruncByMemModel( // TEST TYPE TRUNCATION FOR DEF. MEMORY MODEL TYPE type ) // - the type { bool ok; // - true ==> type matches default mem. model type_flag flags; // - flags for the type type_flag mflags; // - memory-model flags for the type type = TypeGetActualFlags( type, &flags ); mflags = flags & TF1_MEM_MODEL; if( 0 == mflags ) { ok = false; } else { if( type->id == TYP_FUNCTION ) { ok = ( !IsBigCode() && (TF1_NEAR & mflags) == 0 ); } else { ok = ( !IsBigData() && (TF1_NEAR & mflags) == 0 ); } } return( ok ); }
bool PtrCnvInfo( // FILL IN PTR-CONVERSION INFORMATION TYPE ptr_src, // - source type TYPE ptr_tgt, // - target pointer type PTRCNV* info ) // - pointer-conversion information { bool ok; // - return: true ==> can convert trivially bool first_level; // - true ==> at first level bool const_always; // - true ==> const on all preceding levels TYPE orig_src; // - original src type info->converts = false; info->to_base = false; info->to_derived = false; info->to_void = false; info->ptr_integral_ext = false; info->cv_err_0 = false; info->reint_cast_ok = false; orig_src = ptr_src; ptr_src = TypePointedAtModified( ptr_src ); ptr_tgt = TypePointedAtModified( ptr_tgt ); if( ptr_src == NULL ) { info->pted_src = NULL; info->flags_src = 0; ptr_tgt = TypeGetActualFlags( ptr_tgt, &info->flags_tgt ); info->pted_tgt = ptr_tgt; if( ptr_tgt->id == TYP_VOID ) { info->to_void = true; } if( NULL != orig_src && IntegralType( orig_src ) ) { info->reint_cast_ok = true; } ok = false; } else { first_level = true; const_always = true; info->reint_cast_ok = true; for( ; ; ) { type_flag flags_src; // source flags type_flag flags_tgt; // target flags type_flag cv_src; // source CV flags type_flag cv_tgt; // target CV flags ptr_src = TypeGetActualFlags( ptr_src, &flags_src ); ptr_tgt = TypeGetActualFlags( ptr_tgt, &flags_tgt ); cv_src = flags_src & TF1_CV_MASK; cv_tgt = flags_tgt & TF1_CV_MASK; if( cv_src != ( cv_tgt & cv_src ) ) { // test cv-containment if( first_level ) { info->cv_err_0 = true; // - diagnose elsewhere } else { ok = false; break; } } if( first_level ) { TYPE cl_src; // class for source TYPE cl_tgt; // class for target ok = true; info->pted_src = ptr_src; info->pted_tgt = ptr_tgt; info->flags_src = flags_src; info->flags_tgt = flags_tgt; cl_src = StructType( ptr_src ); if( ptr_tgt->id == TYP_VOID ) { info->to_void = true; // ok = (ptr_src == TYP_VOID); // break; } else if( NULL != cl_src ) { cl_tgt = StructType( ptr_tgt ); if( NULL != cl_tgt && cl_tgt != cl_src ) { if( TypeDerived( ptr_src, ptr_tgt ) ) { info->to_base = true; ok = false; // break; } else if( TypeDerived( ptr_tgt, ptr_src ) ) { info->to_derived = true; ok = false; // break; } } } else if( ( ptr_src->id != ptr_tgt->id ) && IntegralType( ptr_src ) && IntegralType( ptr_tgt ) && ( CgMemorySize( ptr_src ) == CgMemorySize( ptr_tgt ) ) ) { info->ptr_integral_ext = true; } if( !ok ) { if( info->cv_err_0 ) { info->reint_cast_ok = false; } break; } first_level = false; } if( cv_tgt != cv_src ) { // test const'ed to here if( ! const_always ) { info->reint_cast_ok = false; ok = false; break; } } if( (cv_tgt & TF1_CONST) == 0 ) { const_always = false; } if( ptr_src == ptr_tgt ) { ok = true; break; } if( TYP_FUNCTION == ptr_src->id || TYP_FUNCTION == ptr_tgt->id ) { ok = TypeCompareExclude( ptr_src , ptr_tgt , TC1_FUN_LINKAGE | TC1_NOT_ENUM_CHAR ); break; } ptr_src = TypePointedAtModified( ptr_src ); ptr_tgt = TypePointedAtModified( ptr_tgt ); if( NULL == ptr_src ) { if( NULL != ptr_tgt && NULL != FunctionDeclarationType( ptr_tgt ) ) { info->reint_cast_ok = false; } ok = false; break; } if( NULL == ptr_tgt ) { ok = false; break; } } } return( ok ); }
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 boolean convertEllipsisArg(// CONVERT AN ELLIPSIS (...) ARGUMENT PTREE arg ) // - argument { boolean retn; // - return: TRUE ==> ok PTREE right; // - argument PTREE afun; // - &[ function ] TYPE type; // - node type switch( NodeAddrOfFun( PTreeOpRight( arg ), &afun ) ) { case ADDR_FN_MANY : case ADDR_FN_MANY_USED : PTreeErrorExpr( arg->u.subtree[1], ERR_ELLIPSE_ADDR_OVERLOAD ); retn = FALSE; break; default : right = NodeRvalue( arg->u.subtree[1] ); arg->u.subtree[1] = right; type = TypedefModifierRemove( right->type ); switch( type->id ) { case TYP_CHAR : case TYP_SCHAR : case TYP_UCHAR : case TYP_SSHORT : case TYP_WCHAR : case TYP_USHORT : type = TypeUnArithResult( type ); right = NodeConvert( type, right ); arg_finish( right, arg ); retn = TRUE; break; case TYP_FLOAT : type = GetBasicType( TYP_DOUBLE ); right = NodeConvert( type, right ); arg_finish( right, arg ); retn = TRUE; break; case TYP_ARRAY : type = PointerTypeForArray( right->type ); right = NodeConvert( type, right ); arg_finish( right, arg ); retn = TRUE; break; case TYP_MEMBER_POINTER : ConvertMembPtrConst( &arg->u.subtree[1] ); arg_fillout( arg ); retn = TRUE; break; case TYP_POINTER : if( NULL == FunctionDeclarationType( type->of ) ) { type_flag def_flags; type_flag act_flags; type_flag arg_flags; TYPE base_type; PTREE cnv; base_type = TypeGetActualFlags( type->of, &arg_flags ); act_flags = arg_flags & TF1_MEM_MODEL; def_flags = DefaultMemoryFlag( type->of ); if( ( ( def_flags & TF1_FAR ) &&( act_flags != TF1_HUGE ) &&( act_flags != TF1_FAR ) ) ||( ( def_flags & TF1_HUGE ) &&( act_flags != TF1_HUGE ) ) ) { type = MakeModifiedType( base_type , ( arg_flags & ~TF1_MEM_MODEL ) | def_flags ); type = MakePointerTo( type ); cnv = CastImplicit( arg->u.subtree[1] , type , CNV_EXPR , NULL ); arg->u.subtree[1] = cnv; DbgVerify( PT_ERROR != cnv->op , "convertEllipsisArg -- failed ptr.cnv" ); arg_fillout( arg ); retn = TRUE; } else { arg_fillout( arg ); retn = TRUE; } } else { arg_fillout( arg ); retn = TRUE; } break; case TYP_CLASS : retn = passStructOnStack( arg, WARN_ELLIPSIS_CLASS_ARG ); break; default : arg_fillout( arg ); retn = TRUE; break; } break; } return retn; }