Integer Operations

Many operations in Turbo Pascal can be calculated as integer operations. This applies to pointers, Boolean values, enumerated values and Char values. Constant integer operations are checked for possible overflow.
  Procedure ConstantIntegerOperations;
  Var Overflow: Boolean;
      Result: LongInt;
      BoolResult: LongBool absolute Result;
  begin
    If Operation < Calc_IsEqual then
      begin
        Overflow := False;
        Case Operation of
          Calc_Add:      Result := LeftExpression.Value.Longint + RightExpression.Value.Longint;
          Calc_Subtract: Result := LeftExpression.Value.Longint - RightExpression.Value.Longint;
          Calc_Multiply: Result := LeftExpression.Value.Longint * RightExpression.Value.Longint;
          Calc_DIV: begin
                      If RightExpression.Value.Longint = 0 then Error (DivisionByZero);
                      Result := LeftExpression.Value.Longint div RightExpression.Value.Longint;
                    end;
          Calc_MOD: begin
                      If RightExpression.Value.Longint = 0 then Error (DivisionByZero);
                      Result := LeftExpression.Value.Longint mod RightExpression.Value.Longint;
                    end;
          Calc_SHL: Result := LeftExpression.Value.Longint shl RightExpression.Value.Byte;
          Calc_SHR: Result := LeftExpression.Value.Longint shr RightExpression.Value.Byte;
          Calc_AND: Result := LeftExpression.Value.Longint and RightExpression.Value.Longint;
          Calc_OR:  Result := LeftExpression.Value.Longint  or RightExpression.Value.Longint;
          Calc_XOR: Result := LeftExpression.Value.Longint xor RightExpression.Value.Longint;
        end;
        Asm
          JNO   @1
          INC   Overflow
      @1:
        end;
          If Overflow then Error (OverflowInArithmeticOperation);
          LeftExpression.Value.Longint := Result;
          LowestIntegerType (Result, LeftExpression.DataType);
      end else begin
                 Case Operation of
                   Calc_IsEqual:          BoolResult := LeftExpression.Value.Longint  = RightExpression.Value.Longint;
                   Calc_IsNotEqual:       BoolResult := LeftExpression.Value.Longint <> RightExpression.Value.Longint;
                   Calc_IsGreater:        BoolResult := LeftExpression.Value.Longint  > RightExpression.Value.Longint;
                   Calc_IsLower:          BoolResult := LeftExpression.Value.Longint  < RightExpression.Value.Longint;
                   Calc_IsGreaterOrEqual: BoolResult := LeftExpression.Value.Longint >= RightExpression.Value.Longint;
                   Calc_IsLowerOrEqual:   BoolResult := LeftExpression.Value.Longint <= RightExpression.Value.Longint;
                 end;
                 SetLeftExpressionToConstantBooleanValue (BoolResult);
               end;
  end;
Non-constant integer expressions are prepared a little bit and the operation is performed by general routine for integer operations.
  Procedure GenerateCodeForIntegerOperations;
  Var CommonDataType: TIntegerTypeSet;
  Label GeneralIntegerOperations;

  begin
    If not ((LeftExpression.Location = elPointerToMemory) and (RightExpression.Location = elConstant)) then
      begin
        If (LeftExpression.Location = elConstant) and (RightExpression.Location = elPointerToMemory) and
             (Operation = Calc_Add) then ExchangeLeftAndRightExpression else GoTo GeneralIntegerOperations;
      end;
    If not (efSegment in LeftExpression.LocationData.Flags) and not (it32Bit in RightExpression.DataType) then
      begin
        Case Operation of
          Calc_Add:      Inc (LeftExpression.Value.Word, RightExpression.Value.Word);
          Calc_Subtract: Dec (LeftExpression.Value.Word, RightExpression.Value.Word);
          else GoTo GeneralIntegerOperations;
        end;
        Exit;
      end;

GeneralIntegerOperations:
    LeftExpression.LoadPointerToMemoryTo_DX_AX;
    RightExpression.LoadPointerToMemoryTo_DX_AX;
    SetLowestCommonIntegerType (LeftExpression.DataType, RightExpression.DataType, CommonDataType);
    If (Operation <= Calc_SHR) and not (it16Bit in CommonDataType) then
      CommonDataType := CommonDataType * [itSigned] + [it16Bit];
    LeftExpression.ExtendInteger (CommonDataType);
    RightExpression.ExtendInteger (CommonDataType);
    IntegerOperations;
  end;
This is the main routine for integer operations. It takes care for some special cases where shorter code can be generated, processes both expressions and generates code for all possible integer operations: +, -, *, DIV, MOD, SHL, SHR, OR, XOR and AND.
  Procedure IntegerOperations;
  Const IntegerOpCodes: Array [Calc_Add..Calc_XOR] of WordRec = (
          (ByteL: mod_ADD_rm; ByteH: INC_AX),
          (ByteL: mod_SUB_rm; ByteH: DEC_AX),
          (ByteL: Unary_16Bit_Operations; ByteH: mod_MUL_rm),
          (ByteL: Unary_16Bit_Operations; ByteH: mod_IDIV_rm),
          (ByteL: Unary_16Bit_Operations; ByteH: mod_IDIV_rm),
          (ByteL: ShiftRotateOperationsBy1_16Bit; ByteH: SHL_AX),
          (ByteL: ShiftRotateOperationsBy1_16Bit; ByteH: SHR_AX),
          (ByteL: mod_AND_rm),
          (ByteL: mod_OR_rm),
          (ByteL: mod_XOR_rm));

        LongIntOpCodes: Array [Calc_Add..Calc_XOR] of WordRec = (
          (ByteL: ADD_Operations; ByteH: ADC_Operations),
          (ByteL: SUB_Operations; ByteH: SBB_Operations),
          (Word:  SysProc_LongMul),
          (Word:  SysProc_LongDiv),
          (Word:  SysProc_LongDiv),
          (Word:  SysProc_LongShl),
          (Word:  SysProc_LongShr),
          (ByteL: AND_Operations; ByteH: 0),
          (ByteL: OR_Operations;  ByteH: 0),
          (ByteL: XOR_Operations; ByteH: 0));
  begin
    RearrangeOperands;
    If Operation >= Calc_IsEqual then
      begin
        If it32Bit in LeftExpression.DataType then
          GenerateCodeForLongIntComparisons else GenerateCodeForIntegerComparisons;
        LeftExpression.EndIntermediateCodeSubroutine;
        LeftExpression.UsedRegisters := LeftExpression.UsedRegisters + RightExpression.UsedRegisters;
        Exit;
      end;
    Case it32Bit in LeftExpression.DataType of
      True: begin
              LoadBothExpressionsToRegisters (LeftExpression, RightExpression, [urDX, urAX]);
              Case Operation of
                Calc_Add,
                Calc_Subtract,
                Calc_AND,
                Calc_OR,
                Calc_XOR: begin
                            RightExpression.GenerateArithmeticInstructionWith_ACC (
                              LongIntOpCodes [Operation].ByteL);
                            RightExpression.SwitchBetweenLoWordAndHiWord (2);
                            Case LongIntOpCodes [Operation].ByteH of
                              0: Case RightExpression.Location of
                                   elConstant: begin
                                                 GenerateInstruction_TwoBytes (ArithmeticOperation_16Bit,
                                                                    Operation_Register_DX or LongIntOpCodes [Operation].ByteL);
                                                 GenerateInstruction_Word (RightExpression.Value.Word);
                                               end;
                                   else RightExpression.GenerateInstructionWithExpressionInMemOrReg (
                                                                 LongIntOpCodes [Operation].ByteL or reg__mod_rm_16Bit, regDX);
                                 end;
                              else begin
                                     RightExpression.GenerateArithmeticInstructionWith_DX (
                                       LongIntOpCodes [Operation].ByteH);
                                     GenerateOverflowCheckingCode (RightExpression)
                                   end;
                            end;
                          end;
                Calc_Multiply: begin
                                 RightExpression.LoadExpressionToRegisters (urCX);
                                 Case OverflowChecking in StatementCompilerSwitches of
                                   True: GenerateInstruction_CALL_FAR (SysProc_LongMulOvf);
                                   else GenerateInstruction_CALL_FAR (SysProc_LongMul);
                                 end;
                               end;
                Calc_DIV,
                Calc_SHL,
                Calc_SHR: begin
                            RightExpression.LoadExpressionToRegisters (urCX);
                            GenerateInstruction_CALL_FAR (LongIntOpCodes [Operation].Word);
                          end;
                Calc_MOD: begin
                            RightExpression.LoadExpressionToRegisters (urCX);
                            GenerateInstruction_CALL_FAR (SysProc_LongDiv);
                            GenerateInstruction_TwoBytes (MOV_16Bit, MOV_AX_CX);
                            GenerateInstruction_TwoBytes (MOV_16Bit, MOV_DX_BX);
                          end;
              end;
            end;
      else begin
             If (Operation = Calc_Multiply) and (RightExpression.Location = elConstant) and
                not (OverflowChecking in StatementCompilerSwitches) then
                  begin
                    LeftExpression.Calculate;
                    LeftExpression.IntegerMultiplicationWithConstant (rAX, RightExpression.Value.Word);
                    LeftExpression.EndIntermediateCodeSubroutine;
                    LeftExpression.UsedRegisters := LeftExpression.UsedRegisters + RightExpression.UsedRegisters;
                    Exit;
                  end;
             Case Operation of
               Calc_DIV,
               Calc_MOD: LoadBothExpressionsToRegisters (LeftExpression, RightExpression, [urDX, urAX]);
               else  LoadBothExpressionsToRegisters (LeftExpression, RightExpression, [urAX]);
             end;
             Case Operation of
               Calc_Add,
               Calc_Subtract: Case OverflowChecking in StatementCompilerSwitches of
                                True: begin
                                        RightExpression.GenerateArithmeticInstructionWith_ACC (
                                                                             IntegerOpCodes [Operation].ByteL);
                                        GenerateOverflowCheckingCode (RightExpression);
                                      end;
                                else If RightExpression.Location = elConstant then
                                       Case RightExpression.Value.Word of
                                         1: GenerateInstruction_Byte (IntegerOpCodes [Operation].ByteH);
                                         2: begin
                                              GenerateInstruction_Byte (IntegerOpCodes [Operation].ByteH);
                                              GenerateInstruction_Byte (IntegerOpCodes [Operation].ByteH);
                                            end;
                                         else RightExpression.GenerateArithmeticInstructionWith_ACC (
                                                                               IntegerOpCodes [Operation].ByteL);
                                       end else RightExpression.GenerateArithmeticInstructionWith_ACC (
                                                                                 IntegerOpCodes [Operation].ByteL);
                              end;
               Calc_Multiply: Case OverflowChecking in StatementCompilerSwitches of
                                True: begin
                                        If itSigned in RightExpression.DataType then
                                          GenerateCodeForDivisionOrMultiplication (IntegerOpCodes [Operation].ByteL,
                                                                                   mod_IMUL_rm)
                                            else GenerateCodeForDivisionOrMultiplication (IntegerOpCodes [Operation].ByteL,
                                                                                          mod_MUL_rm);
                                        GenerateOverflowCheckingCode (RightExpression);
                                      end;
                                else begin
                                       RightExpression.GenerateInstructionWithExpressionInMemOrReg (
                                         IntegerOpCodes [Operation].ByteL, IntegerOpCodes [Operation].ByteH);
                                       Include (RightExpression.UsedRegisters, urDX);
                                     end;
                              end;
               Calc_DIV: begin
                           If RightExpression.Location = elConstant then
                             begin
                               If RightExpression.Value.Word = 0 then Error (DivisionByZero);
                               IntegerConstantDivision (RightExpression.Value.Word);
                             end else GeneralIntegerDivision;
                         end;
               Calc_MOD: begin
                           GeneralIntegerDivision;
                           GenerateInstruction_Byte (XCHG_DX_AX);
                         end;
               Calc_SHL,
               Calc_SHR: If RightExpression.Location = elConstant then
                           begin
                             If RightExpression.Value.Word = 1 then
                               GenerateInstruction_Word (IntegerOpCodes [Operation].Word) else
                                 Case Instructions80286 in StatementCompilerSwitches of
                                   True: begin
                                           GenerateInstruction_TwoBytes (ShiftRotateOperationsByValue_16Bit,
                                                               IntegerOpCodes [Operation].ByteH);
                                           GenerateInstruction_Byte (RightExpression.Value.Byte);
                                         end;
                                   else begin
                                          RightExpression.LoadExpressionToRegisters (urCX);
                                          GenerateInstruction_TwoBytes (ShiftRotateOperationsByCL_16Bit,
                                                                        IntegerOpCodes [Operation].ByteH);
                                        end;
                                 end;
                           end else begin
                                      RightExpression.LoadExpressionToRegisters (urCX);
                                      GenerateInstruction_TwoBytes (ShiftRotateOperationsByCL_16Bit,
                                                                    IntegerOpCodes [Operation].ByteH);
                                    end;
               Calc_AND,
               Calc_OR,
               Calc_XOR:
                 RightExpression.GenerateArithmeticInstructionWith_ACC (IntegerOpCodes [Operation].ByteL);
             end;
           end;
    end;
    LeftExpression.EndIntermediateCodeSubroutine;
    LeftExpression.UsedRegisters := LeftExpression.UsedRegisters + RightExpression.UsedRegisters;
  end;
In some cases more efficient code can be generated if expressions are in certain registers. This procedure exchanges left and right expressions if such case is identified.
    Procedure RearrangeOperands;
    begin
      Case Operation of
        Calc_IsEqual..Calc_Divide,
        Calc_Add,
        Calc_Multiply,
        Calc_AND,
        Calc_OR,
        Calc_XOR:
        else Exit;
      end;
    If RightExpression.Location = elConstant then Exit else
      If LeftExpression.Location = elConstant then ExchangeLeftAndRightExpression else
        If RightExpression.UsedRegisters = [] then Exit else
          If LeftExpression.UsedRegisters = [] then ExchangeLeftAndRightExpression else
            If RightExpression.UsedRegisters = [urBX, urDX, urCX, urAX] then Exit else
              If LeftExpression.UsedRegisters = [urBX, urDX, urCX, urAX] then ExchangeLeftAndRightExpression;
    end;
This procedure exchanges left and right expressions and inverts operation if necessary.
  Procedure ExchangeLeftAndRightExpression;
  Var TempExpression: TExpression;
  begin
    TempExpression := LeftExpression;
    LeftExpression := RightExpression;
    RightExpression := TempExpression;
    If Operation in [Calc_IsGreater, Calc_IsLower, Calc_IsGreaterOrEqual, Calc_IsLowerOrEqual] then
      Operation := TCalcOperation (Ord (Operation) xor 1);
  end;
 
 
 
© 2017 Turbo Pascal | Privacy Policy