void ModelSimSegmExit( void ) /***************************/ { /* a model is set. Close current segment if one is open. */ if ( CurrSeg ) { NewLineQueue(); close_currseg(); RunLineQueue(); } }
/* set memory model, called by ModelDirective() * also set predefined symbols: * - @CodeSize (numeric) * - @code (text) * - @DataSize (numeric) * - @data (text) * - @stack (text) * - @Model (numeric) * - @Interface (numeric) * inactive: * - @fardata (text) * - @fardata? (text) * Win64 only: * - @ReservedStack (numeric) */ static void SetModel( void ) /**************************/ { int value; const char *textvalue; //struct asym *sym; DebugMsg1(("SetModel() enter (model=%u)\n", ModuleInfo.model )); /* if model is set, it disables OT_SEGMENT of -Zm switch */ if ( ModuleInfo.model == MODEL_FLAT ) { ModuleInfo.offsettype = OT_FLAT; #if AMD64_SUPPORT SetDefaultOfssize( ((ModuleInfo.curr_cpu & P_CPU_MASK) >= P_64 ) ? USE64 : USE32 ); #else SetDefaultOfssize( USE32 ); #endif } else ModuleInfo.offsettype = OT_GROUP; NewLineQueue(); ModelSimSegmInit( ModuleInfo.model ); /* create segments in first pass */ ModelAssumeInit(); if ( ModuleInfo.list ) LstWriteSrcLine(); RunLineQueue(); if ( Parse_Pass != PASS_1 ) return; /* Set @CodeSize */ if ( SIZE_CODEPTR & ( 1 << ModuleInfo.model ) ) { value = 1; /* v2.06: SimpleType[] is obsolete */ //SimpleType[ST_PROC].mem_type = MT_FAR; } else { value = 0; // SimpleType[ST_PROC].mem_type = MT_NEAR; /* this is default */ } sym_CodeSize = AddPredefinedConstant( "@CodeSize", value ); AddPredefinedText( "@code", SimGetSegName( SIM_CODE ) ); /* Set @DataSize */ switch( ModuleInfo.model ) { case MODEL_COMPACT: case MODEL_LARGE: value = 1; break; case MODEL_HUGE: value = 2; break; default: value = 0; break; } sym_DataSize = AddPredefinedConstant( "@DataSize", value ); textvalue = ( ModuleInfo.model == MODEL_FLAT ? "FLAT" : szDgroup ); AddPredefinedText( "@data", textvalue ); if ( ModuleInfo.distance == STACK_FAR ) textvalue = "STACK"; AddPredefinedText( "@stack", textvalue ); #if 0 AddPredefinedText( "@fardata", ( ModuleInfo.model == MODEL_FLAT ? "FLAT" : SimGetSegName( SIM_FARDATA ) ) ); AddPredefinedText( "@fardata?", ( ModuleInfo.model == MODEL_FLAT ? "FLAT" : SimGetSegName( SIM_FARDATA_UN ) ) ); #endif /* Set @Model and @Interface */ sym_Model = AddPredefinedConstant( "@Model", ModuleInfo.model ); sym_Interface = AddPredefinedConstant( "@Interface", ModuleInfo.langtype ); #if AMD64_SUPPORT if ( ModuleInfo.defOfssize == USE64 && ModuleInfo.fctype == FCT_WIN64 ) { ReservedStack.mem_type = MT_EMPTY; ReservedStack.state = SYM_INTERNAL; ReservedStack.isdefined = TRUE; ReservedStack.predefined = TRUE; #if FASTMEM==0 ReservedStack.staticmem = TRUE; #endif ReservedStack.variable = TRUE; ReservedStack.name_size = 14; /* sizeof( "@ReservedStack" ) */ SymAddGlobal( &ReservedStack ); } #endif }
/* set memory model, called by ModelDirective() * also set predefined symbols: * - @CodeSize (numeric) * - @code (text) * - @DataSize (numeric) * - @data (text) * - @stack (text) * - @Model (numeric) * - @Interface (numeric) * inactive: * - @fardata (text) * - @fardata? (text) * Win64 only: * - @ReservedStack (numeric) */ static void SetModel( void ) /**************************/ { int value; const char *textvalue; //struct asym *sym; DebugMsg1(("SetModel() enter (model=%u)\n", ModuleInfo.model )); /* if model is set, it disables OT_SEGMENT of -Zm switch */ if ( ModuleInfo.model == MODEL_FLAT ) { ModuleInfo.offsettype = OT_FLAT; #if AMD64_SUPPORT SetDefaultOfssize( ((ModuleInfo.curr_cpu & P_CPU_MASK) >= P_64 ) ? USE64 : USE32 ); /* v2.03: if cpu is x64 and language is fastcall, * set fastcall type to win64. * This is rather hackish, but currently there's no other possibility * to enable the win64 ABI from the source. */ if ( ( ModuleInfo.curr_cpu & P_CPU_MASK ) == P_64 ) if ( ModuleInfo.langtype == LANG_FASTCALL ) { if ( Options.output_format != OFORMAT_ELF ) { DebugMsg(("SetModel: FASTCALL type set to WIN64\n")); ModuleInfo.fctype = FCT_WIN64; } } #else SetDefaultOfssize( USE32 ); #endif /* v2.11: define symbol FLAT - after default offset size has been set! */ DefineFlatGroup(); } else ModuleInfo.offsettype = OT_GROUP; ModelSimSegmInit( ModuleInfo.model ); /* create segments in first pass */ ModelAssumeInit(); if ( ModuleInfo.list ) LstWriteSrcLine(); RunLineQueue(); if ( Parse_Pass != PASS_1 ) return; /* Set @CodeSize */ if ( SIZE_CODEPTR & ( 1 << ModuleInfo.model ) ) { value = 1; /* v2.06: SimpleType[] is obsolete */ //SimpleType[ST_PROC].mem_type = MT_FAR; } else { value = 0; // SimpleType[ST_PROC].mem_type = MT_NEAR; /* this is default */ } sym_CodeSize = AddPredefinedConstant( "@CodeSize", value ); AddPredefinedText( "@code", SimGetSegName( SIM_CODE ) ); /* Set @DataSize */ switch( ModuleInfo.model ) { case MODEL_COMPACT: case MODEL_LARGE: value = 1; break; case MODEL_HUGE: value = 2; break; default: value = 0; break; } sym_DataSize = AddPredefinedConstant( "@DataSize", value ); textvalue = ( ModuleInfo.model == MODEL_FLAT ? "FLAT" : szDgroup ); AddPredefinedText( "@data", textvalue ); if ( ModuleInfo.distance == STACK_FAR ) textvalue = "STACK"; AddPredefinedText( "@stack", textvalue ); #if 0 AddPredefinedText( "@fardata", ( ModuleInfo.model == MODEL_FLAT ? "FLAT" : SimGetSegName( SIM_FARDATA ) ) ); AddPredefinedText( "@fardata?", ( ModuleInfo.model == MODEL_FLAT ? "FLAT" : SimGetSegName( SIM_FARDATA_UN ) ) ); #endif /* Set @Model and @Interface */ sym_Model = AddPredefinedConstant( "@Model", ModuleInfo.model ); sym_Interface = AddPredefinedConstant( "@Interface", ModuleInfo.langtype ); #if AMD64_SUPPORT if ( ModuleInfo.defOfssize == USE64 && ModuleInfo.fctype == FCT_WIN64 ) { sym_ReservedStack = AddPredefinedConstant( "@ReservedStack", 0 ); } #endif #if PE_SUPPORT if ( ModuleInfo.sub_format == SFORMAT_PE ) pe_create_PE_header(); #endif #ifdef DEBUG_OUT if ( Options.dump_reswords ) DumpResWords(); #endif }
ret_code HllEndDef( int i ) /*************************/ { //struct asm_sym *sym; struct hll_list *hll; int cmd = AsmBuffer[i]->value; char buffer[MAX_ID_LEN+1+64]; DebugMsg(("HllEndDef(%s) enter\n", AsmBuffer[i]->string_ptr )); if ( HllStack == NULL ) { DebugMsg(("HllEndDef: hll stack is empty\n")); AsmError( DIRECTIVE_MUST_BE_IN_CONTROL_BLOCK ); return( ERROR ); } hll = HllStack; HllStack = hll->next; PushLineQueue(); switch (cmd) { case T_DOT_ENDIF: if ( hll->cmd != HLL_IF ) { DebugMsg(("HllEndDef no .IF on the hll stack\n")); AsmErr( BLOCK_NESTING_ERROR, AsmBuffer[i]->string_ptr ); return( ERROR ); } /* if a test label isn't created yet, create it */ if ( hll->symtest ) { MakeLabel( buffer, hll->symtest ); AddLineQueue( buffer ); } /* create the exit label if it exists */ if ( hll->symexit ) { MakeLabel( buffer, hll->symexit ); AddLineQueue( buffer ); } i++; break; case T_DOT_ENDW: if ( hll->cmd != HLL_WHILE ) { DebugMsg(("HllEndDef no .WHILE on the hll stack\n")); AsmErr( BLOCK_NESTING_ERROR, AsmBuffer[i]->string_ptr ); return( ERROR ); } /* create test label */ if ( hll->symtest ) { MakeLabel( buffer, hll->symtest ); DebugMsg(("HllEndDef: created: %s\n", buffer)); AddLineQueue( buffer ); } HllPushTestLines( hll ); MakeLabel( buffer, hll->symexit ); AddLineQueue( buffer ); i++; break; case T_DOT_UNTILCXZ: if ( hll->cmd != HLL_REPEAT ) { DebugMsg(("HllEndDef no .REPEAT on the hll stack\n")); AsmErr( BLOCK_NESTING_ERROR, AsmBuffer[i]->string_ptr ); return( ERROR ); } MakeLabel( buffer, hll->symtest ); AddLineQueue( buffer ); i++; /* read in optional (simple) expression */ if ( AsmBuffer[i]->token != T_FINAL ) { if ( ERROR == EvaluateHllExpression( hll, &i, LABELFIRST, FALSE ) ) { return( ERROR ); } if ( HllCheckTestLines(hll) == ERROR ) { AsmError( EXPR_TOO_COMPLEX_FOR_UNTILCXZ ); return( ERROR ); } /* write condition lines */ HllPushTestLines( hll ); } else { sprintf( buffer, " loop %s", hll->symfirst ); AddLineQueue( buffer ); } MakeLabel( buffer, hll->symexit ); AddLineQueue( buffer ); break; case T_DOT_UNTIL: if ( hll->cmd != HLL_REPEAT ) { DebugMsg(("HllEndDef no .REPEAT on the hll stack\n")); AsmErr( BLOCK_NESTING_ERROR, AsmBuffer[i]->string_ptr ); return( ERROR ); } MakeLabel( buffer, hll->symtest ); AddLineQueue( buffer ); i++; /* read in (optional) expression */ /* if expression is missing, just generate nothing */ if ( AsmBuffer[i]->token != T_FINAL ) { if ( ERROR == EvaluateHllExpression( hll, &i, LABELFIRST, FALSE ) ) { return( ERROR ); } /* write condition lines */ HllPushTestLines( hll ); } #if 0 sprintf( buffer, " jmp %s", hll->symfirst ); AddLineQueue( buffer ); #endif MakeLabel( buffer, hll->symexit ); AddLineQueue( buffer ); break; } AsmFree( hll->symfirst ); AsmFree( hll->symtest ); AsmFree( hll->symexit ); AsmFree( hll->condlines ); AsmFree( hll ); if ( AsmBuffer[i]->token != T_FINAL ) { AsmErr( SYNTAX_ERROR_EX, AsmBuffer[i]->string_ptr ); return( ERROR ); } if ( ModuleInfo.list ) LstWrite( LSTTYPE_DIRECTIVE, GetCurrOffset(), NULL ); if ( line_queue ) RunLineQueue(); return( NOT_ERROR ); }
ret_code HllStartDef( int i ) /***************************/ { struct hll_list *hll; int cmd = AsmBuffer[i]->value; char buffer[MAX_ID_LEN+1+64]; DebugMsg(("HllStartDef(%u [=%s]) enter\n", i, AsmBuffer[i]->string_ptr )); #if FASTPASS /* make sure the directive is stored */ if ( StoreState == FALSE && Parse_Pass == PASS_1 ) { SaveState(); } #endif switch (cmd) { case T_DOT_REPEAT: if ( AsmBuffer[i+1]->token != T_FINAL ) { DebugMsg(("HllStartDef: unexpected tokens behind .REPEAT\n" )); AsmError( SYNTAX_ERROR ); return( ERROR ); } break; case T_DOT_IF: case T_DOT_WHILE: #if 0 /* Masm allows a missing expression! */ if ( AsmBuffer[i+1]->token == T_FINAL ) { AsmError( SYNTAX_ERROR ); return( ERROR ); } #endif break; } hll = AsmAlloc( sizeof(hll_list) ); hll->cmd = HLL_UNDEF; /* create labels which are always needed */ /* for .IF -.ENDIF without .ELSE no symexit label is needed. */ hll->symfirst = NULL; hll->symexit = NULL; hll->symtest = MakeAnonymousLabel(); hll->condlines = NULL; // structure for .IF .ELSE .ENDIF // cond jump to symtest // ... // jmp symexit // symtest: // ... // symexit: // structure for .IF .ELSEIF // cond jump to symtest // ... // jmp symexit // symtest: // cond jump to (new) symtest // ... // jmp symexit // symtest: // ... // structure for .WHILE and .REPEAT: // jmp symtest (for .WHILE only) // symfirst: // ... // symtest: (jumped to by .continue) // test end condition, cond jump to symfirst // symexit: (jumped to by .break) PushLineQueue(); switch (cmd) { case T_DOT_IF: hll->cmd = HLL_IF; /* get the C-style expression, convert to ASM code lines */ i++; if ( ERROR == EvaluateHllExpression( hll, &i, LABELTEST, FALSE ) ) { return( ERROR ); } HllPushTestLines( hll ); #if 1 /* if no lines have been created, the symtest label isn't needed */ if ( line_queue == NULL ) { AsmFree( hll->symtest ); hll->symtest = NULL; } #endif break; case T_DOT_WHILE: case T_DOT_REPEAT: /* create the label to loop start */ hll->symfirst = MakeAnonymousLabel(); hll->symexit = MakeAnonymousLabel(); if ( cmd == T_DOT_WHILE ) { i++; hll->cmd = HLL_WHILE; if ( AsmBuffer[i]->token != T_FINAL ) { if ( ERROR == EvaluateHllExpression( hll, &i, LABELFIRST, TRUE ) ) { return( ERROR ); } } else hll->condlines = ""; /* create a jump to second label */ /* optimisation: if second label is just a jump, dont jump! */ if ( hll->condlines && _memicmp(hll->condlines, "jmp", 3) ) { sprintf( buffer, " jmp %s", hll->symtest ); AddLineQueue( buffer ); } else { AsmFree( hll->symtest ); hll->symtest = NULL; } } else { i++; hll->cmd = HLL_REPEAT; } MakeLabel( buffer, hll->symfirst ); AddLineQueue( buffer ); break; } if ( AsmBuffer[i]->token != T_FINAL ) { DebugMsg(("HllStartDef: unexpected token %u [%s]\n", AsmBuffer[i]->token, AsmBuffer[i]->string_ptr )); AsmErr( SYNTAX_ERROR_EX, AsmBuffer[i]->string_ptr ); return( ERROR ); } hll->next = HllStack; HllStack = hll; if ( ModuleInfo.list ) LstWrite( LSTTYPE_DIRECTIVE, GetCurrOffset(), NULL ); if ( line_queue ) /* might be NULL! (".if 1") */ RunLineQueue(); return( NOT_ERROR ); }
ret_code HllExitDef( int i ) /**************************/ { //int level; //struct asm_sym *sym; struct hll_list *hll; char *savedlines; hll_cmd savedcmd; int cmd = AsmBuffer[i]->value; char buffer[MAX_ID_LEN+1+64]; DebugMsg(("HllExitDef(%s) enter\n", AsmBuffer[i]->string_ptr )); hll = HllStack; if ( hll == NULL ) { DebugMsg(("HllExitDef stack error\n")); AsmError( DIRECTIVE_MUST_BE_IN_CONTROL_BLOCK ); return( ERROR ); } PushLineQueue(); switch (cmd) { case T_DOT_ELSE: case T_DOT_ELSEIF: if ( hll->cmd != HLL_IF ) { DebugMsg(("HllExitDef(%s): symtest=%X\n", AsmBuffer[i]->string_ptr, hll->symtest)); AsmErr( BLOCK_NESTING_ERROR, AsmBuffer[i]->string_ptr ); return( ERROR ); } /* the "symexit" label is only needed if an .ELSE branch exists. That's why it is created delayed. */ if ( hll->symexit == NULL) hll->symexit = MakeAnonymousLabel(); sprintf( buffer," jmp %s", hll->symexit ); AddLineQueue( buffer ); if ( hll->symtest ) { MakeLabel( buffer, hll->symtest ); AddLineQueue( buffer ); AsmFree( hll->symtest ); hll->symtest = NULL; } i++; if (cmd == T_DOT_ELSEIF) { /* create new symtest label */ hll->symtest = MakeAnonymousLabel(); if ( ERROR == EvaluateHllExpression( hll, &i, LABELTEST, FALSE ) ) { return( ERROR ); } HllPushTestLines( hll ); } break; case T_DOT_BREAK: case T_DOT_CONTINUE: for ( ; hll && hll->cmd == HLL_IF; hll = hll->next ); if ( hll == NULL ) { AsmError( DIRECTIVE_MUST_BE_IN_CONTROL_BLOCK ); return( ERROR ); } /* .BREAK .IF ... or .CONTINUE .IF ? */ i++; if ( AsmBuffer[i]->token != T_FINAL ) { if ( AsmBuffer[i]->token == T_DIRECTIVE && AsmBuffer[i]->value == T_DOT_IF ) { savedlines = hll->condlines; savedcmd = hll->cmd; hll->condlines = NULL; hll->cmd = HLL_BREAK; i++; if ( cmd == T_DOT_BREAK ) { if ( ERROR == EvaluateHllExpression( hll, &i, LABELEXIT, TRUE ) ) { return( ERROR ); } } else { /* T_DOT_CONTINUE */ if ( ERROR == EvaluateHllExpression( hll, &i, LABELTEST, TRUE ) ) { return( ERROR ); } } HllPushTestLines( hll ); AsmFree( hll->condlines ); hll->condlines = savedlines; hll->cmd = savedcmd; } } else { if ( cmd == T_DOT_BREAK ) { sprintf( buffer," jmp %s", hll->symexit ); } else { if ( hll->symtest ) sprintf( buffer," jmp %s", hll->symtest ); else sprintf( buffer," jmp %s", hll->symfirst ); } AddLineQueue( buffer ); } break; } if ( AsmBuffer[i]->token != T_FINAL ) { AsmErr( SYNTAX_ERROR_EX, AsmBuffer[i]->string_ptr ); return( ERROR ); } if ( ModuleInfo.list ) LstWrite( LSTTYPE_DIRECTIVE, GetCurrOffset(), NULL ); RunLineQueue(); return( NOT_ERROR ); }
ret_code SimplifiedSegDir( int i, struct asm_tok tokenarray[] ) /*************************************************************/ /* Handles simplified segment directives: .CODE, .STACK, .DATA, .DATA?, .FARDATA, .FARDATA?, .CONST */ { const char *name = NULL; char init; int type; struct expr opndx; DebugMsg1(("SimplifiedSegDir(%s) enter\n", tokenarray[i].string_ptr )); LstWrite( LSTTYPE_DIRECTIVE, 0, NULL ); if( ModuleInfo.model == MODEL_NONE ) { EmitError( MODEL_IS_NOT_DECLARED ); return( ERROR ); } //type = tokenarray[i].value; type = GetSflagsSp( tokenarray[i].tokval ); i++; /* get past the directive token */ if( type == SIM_STACK ) { if ( EvalOperand( &i, tokenarray, Token_Count, &opndx, 0 ) == ERROR ) return( ERROR ); if( opndx.kind == EXPR_EMPTY ) opndx.value = DEFAULT_STACK_SIZE; else if( opndx.kind != EXPR_CONST ) { EmitError( CONSTANT_EXPECTED ); return( ERROR ); } } else { /* Masm accepts a name argument for .CODE and .FARDATA[?] only. * JWasm also accepts this for .DATA[?] and .CONST unless * option -Zne is set. */ if( tokenarray[i].token == T_ID && ( type == SIM_CODE || type == SIM_FARDATA || type == SIM_FARDATA_UN || ( Options.strict_masm_compat == FALSE && ( type == SIM_DATA || type == SIM_DATA_UN || type == SIM_CONST )))) { name = tokenarray[i].string_ptr; i++; } } if ( tokenarray[i].token != T_FINAL ) { EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr ); return( ERROR ); } NewLineQueue(); if( type != SIM_STACK ) close_currseg(); /* emit a "xxx ENDS" line to close current seg */ if ( name == NULL ) init = ( ModuleInfo.simseg_init & ( 1 << type ) ); switch( type ) { case SIM_CODE: /* .code */ SetSimSeg( SIM_CODE, name ); if( ModuleInfo.model == MODEL_TINY ) { /* v2.05: add the named code segment to DGROUP */ if ( name ) AddToDgroup( SIM_CODE, name ); name = szDgroup; } else if( ModuleInfo.model == MODEL_FLAT ) { name = "FLAT"; } else { if( name == NULL ) name = SegmNames[SIM_CODE]; } AddLineQueueX( "%r %r:%s", T_ASSUME, T_CS, name ); break; case SIM_STACK: /* .stack */ /* if code is generated which does "emit" bytes, * the original source line has to be saved. * v2.05: must not be done after LstWrite() has been called! * Also, there are no longer bytes "emitted". */ //FStoreLine(); SetSimSeg( SIM_STACK, NULL ); AddLineQueueX( "ORG 0%xh", NUMQUAL opndx.value ); EndSimSeg( SIM_STACK ); /* add stack to dgroup for some segmented models */ if ( !init ) if ( ModuleInfo.distance != STACK_FAR ) AddToDgroup( SIM_STACK, NULL ); break; case SIM_DATA: /* .data */ case SIM_DATA_UN: /* .data? */ case SIM_CONST: /* .const */ SetSimSeg( type, name ); AddLineQueueX( "%r %r:ERROR", T_ASSUME, T_CS ); if ( name || (!init) ) AddToDgroup( type, name ); break; case SIM_FARDATA: /* .fardata */ case SIM_FARDATA_UN: /* .fardata? */ SetSimSeg( type, name ); AddLineQueueX( "%r %r:ERROR", T_ASSUME, T_CS ); break; default: /* shouldn't happen */ /**/myassert( 0 ); break; } RunLineQueue(); DebugMsg1(("SimplifiedSegDir exit\n")); return( NOT_ERROR ); }