cmdlnx86.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 1,273 行 · 第 1/3 页

        DefSwitchMacro( "3" );
        break;
    case CPU_486:
        DefSwitchMacro( "4" );
        break;
    case CPU_586:
        DefSwitchMacro( "5" );
        break;
    case CPU_686:
        DefSwitchMacro( "6" );
        break;
    }
    switch( GET_FPU_LEVEL( CpuSwitches ) ) {
    case FPU_NONE:
        CompFlags.op_switch_used = 0;
        DefSwitchMacro( "FPC" );
        break;
    case FPU_87:
        DefSwitchMacro( "FP287" );
        defEmu();
        break;
    case FPU_387:
        DefSwitchMacro( "FP387" );
        defEmu();
        break;
    case FPU_586:
        DefSwitchMacro( "FP5" );
        defEmu();
        break;
    case FPU_686:
        DefSwitchMacro( "FP6" );
        defEmu();
        break;
    }
    if( CompFlags.op_switch_used ) {
        DefSwitchMacro( "OP" );
    }
#if _CPU == 386
    PreDefineStringMacro( "_STDCALL_SUPPORTED" );
    PreDefineStringMacro( "_INTEGRAL_MAX_BITS=64" );
    if( CompFlags.extensions_enabled ) {
        PreDefineStringMacro( "SOMLINK=_Syscall" );
        PreDefineStringMacro( "SOMDLINK=_Syscall" );
    }
#endif
#if _CPU == 8086
    PreDefineStringMacro( "_INTEGRAL_MAX_BITS=64" );
    if( CompFlags.extensions_enabled ) {
        if( TargetSwitches & WINDOWS ) {
            PreDefineStringMacro( "SOMLINK=__cdecl" );
            PreDefineStringMacro( "SOMDLINK=__far" );
        }
    }
#endif
}

static void miscAnalysis( OPT_STORAGE *data )
{
#if _CPU == 8086
    if( data->bd || data->zu ) {
        if( TargetSwitches & SMART_WINDOWS ) {
            CErr1( ERR_ZWS_MUST_HAVE_SS_DS_SAME );
        }
    }
#endif
    if( GET_CPU( CpuSwitches ) < CPU_386 ) {
        /* issue warning message if /zf[f|p] or /zg[f|p] spec'd? */
        TargetSwitches &= ~( FLOATING_FS | FLOATING_GS );
    }
    if( ! CompFlags.save_restore_segregs ) {
        if( TargetSwitches & FLOATING_DS ) {
            HW_CTurnOff( WatcallInfo.save, HW_DS );
        }
        if( TargetSwitches & FLOATING_ES ) {
            HW_CTurnOff( WatcallInfo.save, HW_ES );
        }
        if( TargetSwitches & FLOATING_FS ) {
            HW_CTurnOff( WatcallInfo.save, HW_FS );
        }
        if( TargetSwitches & FLOATING_GS ) {
            HW_CTurnOff( WatcallInfo.save, HW_GS );
        }
    }
    if( GET_FPU( CpuSwitches ) > FPU_NONE ) {
        PreDefineStringMacro( "__FPI__" );
    }
#if _CPU == 386
    if( ! CompFlags.register_conventions ) {
        SetAuxStackConventions();
    }
#endif
    if( data->zx ) {
        HW_CTurnOff( WatcallInfo.save, HW_FLTS );
    }
}

void CmdSysAnalyse( OPT_STORAGE *data )
/*************************************/
{
    char *target_name = NULL;
    mem_model_control mmc = MMC_NULL;

    GenSwitches &= ~( DBG_CV | DBG_DF | DBG_PREDEF );
    switch( data->dbg_output ) {
    case OPT_dbg_output_hc:
        GenSwitches |= DBG_CV;
        break;
    case OPT_dbg_output_hda:
        if( data->fhd ) {
            CompFlags.pch_debug_info_opt = 1;
        }
        GenSwitches |= DBG_DF | DBG_PREDEF;
        break;
    case OPT_dbg_output_hw:
        break;
    case OPT_dbg_output_hd:
    default:
        if( data->fhd ) {
            CompFlags.pch_debug_info_opt = 1;
        }
        GenSwitches |= DBG_DF;
        break;
    }
    switch( data->ds_peg ) {
    case OPT_ds_peg_zdp:
        TargetSwitches &= ~ FLOATING_DS;
        mmc |= MMC_DS;
        break;
    case OPT_ds_peg_zdf:
        TargetSwitches |= FLOATING_DS;
        mmc |= MMC_DS;
        break;
    }

    if( data->zfw ) {
        TargetSwitches |= GEN_FWAIT_386;
    }
#if _CPU == 386
    if( data->zro && data->zri ) {
//        DbgDefault( "invalid fp rounding flags - ignored" );
        data->zro = data->zri = 0;
    }
    if( data->zri ) {
        GenSwitches |= FPU_ROUNDING_INLINE;
    } else if( data->zro ) {
        GenSwitches |= FPU_ROUNDING_OMIT;
    }
#else
    if( data->zro ) {
        GenSwitches |= FPU_ROUNDING_OMIT;
    }
#endif

#if _CPU == 386
    if( data->zdl ) {
        TargetSwitches |= LOAD_DS_DIRECTLY;
        mmc |= MMC_DS;
    }
#endif
    switch( data->fs_peg ) {
    case OPT_fs_peg_zfp:
        TargetSwitches &= ~ FLOATING_FS;
        mmc |= MMC_FS;
        break;
    case OPT_fs_peg_zff:
        TargetSwitches |= FLOATING_FS;
        mmc |= MMC_FS;
        break;
    }
    switch( data->gs_peg ) {
    case OPT_gs_peg_zgp:
        TargetSwitches &= ~ FLOATING_GS;
        mmc |= MMC_GS;
        break;
    case OPT_gs_peg_zgf:
        TargetSwitches |= FLOATING_GS;
        mmc |= MMC_GS;
        break;
    }
    // -zw overrides a build target setting
    if( data->bt ) {
        char *target = SetStringOption( NULL, &(data->bt_value) );
        SetTargetLiteral( &target_name, target );
        if( target_name != NULL ) {
            if( strcmp( target_name, "WINDOWS" ) == 0 ||
                  strcmp( target_name, "CHEAP_WINDOWS" ) == 0 ) {
                mmc |= MMC_WIN;
            } else if( strcmp( target_name, "NETWARE" ) == 0 ) {
                mmc |= MMC_NETWARE;
            } else if( strcmp( target_name, "NETWARE5" ) == 0 ) {
                mmc |= MMC_NETWARE;
            }
        }
        CMemFree( target );
    }
#if _CPU == 8086
    switch( data->win ) {
    case OPT_win_zw:
        SetTargetLiteral( &target_name, "windows" );
        mmc |= MMC_WIN;
        break;
    case OPT_win_zW:
        SetTargetLiteral( &target_name, "cheap_windows" );
        mmc |= MMC_WIN;
        break;
    case OPT_win_zws:
        SetTargetLiteral( &target_name, "windows" );
        TargetSwitches |= SMART_WINDOWS;
        mmc |= MMC_WIN;
        break;
    case OPT_win_zWs:
        SetTargetLiteral( &target_name, "cheap_windows" );
        TargetSwitches |= SMART_WINDOWS;
        mmc |= MMC_WIN;
        break;
    }
#else
    switch( data->win ) {
    case OPT_win_zw:
        SetTargetLiteral( &target_name, "windows" );
        mmc |= MMC_WIN;
        break;
    }
#endif
    // depends on 'mmc' being set fully
    setIntelArchitecture( data, mmc );

    switch( data->intel_fpu_model ) {
    case OPT_intel_fpu_model_fpi:
        SET_FPU_EMU( CpuSwitches );
        break;
#ifdef OPT_intel_fpu_model__7
    case OPT_intel_fpu__7:
        /* fall through */
#endif
    case OPT_intel_fpu_model_fpi87:
        SET_FPU_INLINE( CpuSwitches );
        break;
    case OPT_intel_fpu_model_fpc:
        SET_FPU( CpuSwitches, FPU_NONE );
        break;
    case OPT_intel_fpu_model__87d:
        if( data->_87d_value ) {
            Stack87 = data->_87d_value;
        }
        break;
    }

    switch( data->intel_fpu_level ) {
    case OPT_intel_fpu_level_fp6:
        SET_FPU_LEVEL( CpuSwitches, FPU_686 );
        break;
    case OPT_intel_fpu_level_fp5:
        SET_FPU_LEVEL( CpuSwitches, FPU_586 );
        break;
    case OPT_intel_fpu_level_fp3:
        SET_FPU_LEVEL( CpuSwitches, FPU_387 );
        break;
    case OPT_intel_fpu_level_fp2:
        SET_FPU_LEVEL( CpuSwitches, FPU_87 );
        break;
    }

    // depends on architecture and fpu being set
    setMemoryModel( data, mmc );
    if( data->fpd ) {
        TargetSwitches |= P5_DIVIDE_CHECK;
    }
    /*
    //  Changed the ordering.
    //      Always set Stack87 if fpr switch is used.
    //      If fpr switch is not present but are using NetWare then set Stack87
    //      unless the target is NetWare 5 or above.
    */
    if( data->fpr ) {
        Stack87 = 4;
    } else {
        if( mmc & MMC_NETWARE ) {
            if(TS_NETWARE5 != TargetSystem){
                Stack87 = 4;    /* no fpr for netware 5 */
            }
        }
    }
    if( data->g ) {
        SetStringOption( &GenCodeGroup, &(data->g_value) );
    }
    if( data->nc ) {
        SetStringOption( &CodeClassName, &(data->nc_value) );
    }
    if( data->nd ) {
        SetStringOption( &DataSegName, &(data->nd_value) );
    }
    if( data->nm ) {
        SetStringOption( &ModuleName, &(data->nm_value) );
    }
    if( data->nt ) {
        SetStringOption( &TextSegName, &(data->nt_value) );
    }
    if( data->oc ) {
        TargetSwitches |= NO_CALL_RET_TRANSFORM;
    }
    if( data->of ) {
        TargetSwitches |= NEED_STACK_FRAME;
    }
    if( data->of_plus ) {
        TargetSwitches |= NEED_STACK_FRAME;
        WatcallInfo.cclass |= GENERATE_STACK_FRAME;
    }
    if( data->om ) {
        TargetSwitches |= I_MATH_INLINE;
    }
    if( data->r ) {
        CompFlags.save_restore_segregs = 1;
    }
    if( data->ri ) {
        CompFlags.returns_promoted = 1;
    }
    if( data->sg ) {
        CompFlags.sg_switch_used = 1;
    }
    if( data->st ) {
        CompFlags.st_switch_used = 1;
    }
    if( data->zc ) {
        CompFlags.strings_in_code_segment = 1;
        CompFlags.zc_switch_used = 1;
        TargetSwitches |= CONST_IN_CODE;
    }
    if( data->zm ) {
        CompFlags.zm_switch_used = 1;
    }
    if( data->zmf ) {
        CompFlags.zm_switch_used = 1;
        CompFlags.zmf_switch_used = 1;
    }
    if( data->zu ) {
        CompFlags.zu_switch_used = 1;
        TargetSwitches |= FLOATING_SS;
    }
    if( data->zx ) {
        CompFlags.zx_switch_used = 1;
    }
    if( data->zt ) {
        DataThreshold = data->zt_value;
    }
#if _CPU == 386
    if( data->vcap ) {
        CompFlags.vc_alloca_parm = 1;
    }
    if( data->br ) {
        CompFlags.br_switch_used = 1;
    }
    if( data->ez ) {
        TargetSwitches |= EZ_OMF;
    }
    if( data->etp ) {
        TargetSwitches |= NEW_P5_PROFILING;
    }
    if( data->esp ) {
        TargetSwitches |= STATEMENT_COUNTING;
    }
    if( data->et ) {
        TargetSwitches |= P5_PROFILING;
    }
    if( data->et0 ) {
        TargetSwitches |= P5_PROFILING | P5_PROFILING_CTR0;
    }
    if( data->xgv ) {
        TargetSwitches |= INDEXED_GLOBALS;
    }
    if( data->zo ) {
        CompFlags.zo_switch_used = 1;
    }
    if( data->zz ) {
        CompFlags.use_stdcall_at_number = 0;
    }
#else
    if( data->xgls ) {
        TargetSwitches |= NULL_SELECTOR_BAD;
    }
#endif
    if( data->iso == OPT_iso_za ) {
        TargetSwitches &= ~I_MATH_INLINE;
    }
    switch( data->intel_call_conv ) {
#if ( _CPU == 8086 ) || ( _CPU == 386 )
    case OPT_intel_call_conv_ecc:
        DftCallConv = &CdeclInfo;
        break;
    case OPT_intel_call_conv_ecd:
        DftCallConv = &StdcallInfo;
        break;
    case OPT_intel_call_conv_ecf:
        DftCallConv = &FastcallInfo;
        break;
#ifndef NDEBUG
    case OPT_intel_call_conv_eco:
        DftCallConv = &OptlinkInfo;
        break;
#endif
    case OPT_intel_call_conv_ecp:
        DftCallConv = &PascalInfo;
        break;
    case OPT_intel_call_conv_ecr:
        DftCallConv = &SyscallInfo;
        break;
    case OPT_intel_call_conv_ecs:
        DftCallConv = &FortranInfo;
        break;
    case OPT_intel_call_conv_ecw:
#endif
    case OPT_intel_call_conv_default:
    default:
        DftCallConv = &WatcallInfo;
        break;
    }
    // frees 'target_name' memory
    setFinalTargetSystem( data, target_name );
    miscAnalysis( data );
    defineFSRegistration();
    macroDefs();
}