wie mach ich einen aritmethic shift?

[Memnarch]

Nabend,
In C++ gibt es ja folgende operatoren:

<< = shl
>>> = shr
>> = ?

was ist das equivalent zum >> Aritmethic shift? in asm müsste es dafür eigentlich asr geben, aber er kennt asr nicht >.<

Kann mir da jemand helfen?

PS:
Delphi XE

MFG
Memnarch

[Assarbad]

Zitat von Memnarch:

>>> = shr

Der war mir noch nicht bekannt. Und meinem Compiler auch nicht.

Code:

$ gcc -o test test.cpp
test.cpp: In function ‘int main(int, char**)’:
test.cpp:21: error: expected primary-expression before ‘>=’ token

Was genau würdest du auch von einem Arithmetic Shift erwarten? Ich meine wenn ich die Bits nach links rausschiebe, macht es Sinn daß Flags gesetzt werden. Bei dem Verschieben nach rechts erschließt sich mir nicht was der Unterschied sein würde.

[Bummi]

suchst Du das ?

http://www.i8086.de/asm/8086-88-asm-sar.html

[Memnarch]

ach es ist SAR, jetzt versteht mich auch der inlineassembler

ein SAR darf nicht so einfach das vorzeichen bit mitverschieben, wie es das SHR macht.

kann auch sien das ich was verwechselt habe und in C++ der >>> automatisch erkannt wird.(hatte den C den operator?)

[Assarbad]

Zitat von Memnarch:

ach es ist SAR, jetzt versteht mich auch der inlineassembler

ein SAR darf nicht so einfach das vorzeichen bit mitverschieben, wie es das SHR macht.

Aha? Dann hast du ein echtes Problem

Zitat:

Dieser Befehl ist identisch mit dem SAR-Kommando und stellt nur eine alternative Schreibweise dar. Der Assembler übersetzt SAR und SHR in den gleichen Maschinencode.

Zitat von Memnarch:

kann auch sien das ich was verwechselt habe und in C++ der >>> automatisch erkannt wird.(hatte den C den operator?)

Nein, wär mir neu.

[Namenloser]

Zitat von Assarbad:

Zitat von Memnarch:

ach es ist SAR, jetzt versteht mich auch der inlineassembler

ein SAR darf nicht so einfach das vorzeichen bit mitverschieben, wie es das SHR macht.

Aha? Dann hast du ein echtes Problem

Zitat:

Dieser Befehl ist identisch mit dem SAR-Kommando und stellt nur eine alternative Schreibweise dar. Der Assembler übersetzt SAR und SHR in den gleichen Maschinencode.

Also mein Delphi übersetzt die Befehle nicht in den selben Code, und die Ergebnisse unterscheiden sich auch.

Delphi-Quellcode:

var
  a,b,c,d: integer;
begin
  a := 4242;
  b := -4242;
  c := a;
  d := b;

  asm
    shr a, 8;
    shr b, 8;
    sar c, 8;
    sar d, 8;
    nop;
  end;
end;

Ergebnis:

a = 16
b = 16777199
c = 16
d = -17

CPU-Ansicht:

Code:

Unit1.pas.36: shr a, 8;
00453364 C16DFC08         shr dword ptr [ebp-$04],$08
Unit1.pas.37: shr b, 8;
00453368 C16DF808         shr dword ptr [ebp-$08],$08
Unit1.pas.38: sar c, 8;
0045336C C17DF408         sar dword ptr [ebp-$0c],$08
Unit1.pas.39: sar d, 8;
00453370 C17DF008         sar dword ptr [ebp-$10],$08

Oder hab ich dich missverstanden?

Meintest du vielleicht den Shift-Left-Befehl? Denn da sollte es logischerweise keinen Unterschied machen...

[Memnarch]

@Assarbard:
kann ich mir nicht vorstellen
edit@Assarbard: Wo hast du den das Zitat her? denkdran das in Delphi shr was anderes ist als in C. Delphi macht hier nen logic shift, während in den c sprachen nen arithmetic shift gemacht wird.

shr = logic shift
sar = arithmetic shift

´@NamenLozer: Danke für die gegenüberstellung

[Assarbad]

Zitat von NamenLozer:

Oder hab ich dich missverstanden?

Nee, ich glaub ich steh nur aufm Schlauch ...

Zitat von Memnarch:

Wo hast du den das Zitat her?

Obiger Link.

[Neutral General]

ein normales shr füllt links immer mit 0en auf.
Ein sar dem Vorzeichen entsprechend (2er Komplement):

Zitat:

1001 sar 1 = 1100 // Ne negative Zahl --> Vorzeichen (also das Minus, also die 1) wird beibehalten
1001 shr 1 = 0100

0100 shr 1 = 0010
0100 sar 1 = 0010 // Ne positive Zahl --> Vorzeichen (in dem Fall + = 0) wird beibehalten

=> Bei positiven Zahlen ist shr = sar

[himitsu]

aritmethic?
arithmetic

Delphi unterscheidet leider nicht so wirklich, zwischen arithmetisch und logisch/binär.
Obwohl es z.B. in den Record-Opertaoren vorgesehn ist, wird dennoch standardmäßig überall nur das logische/binäre Shift verwendet.

Nur bei den Booleans wird logisch gearbeitet, aber sonst eben überall nur binär. (and, or, not und xor)

Du könntest jetzt zwar mit den Operatoren versuchen dir ein arithmetisches Shift zu basteln oder du nutzt eben Funktionen dafür.

Delphi-Quellcode:

function {sal}AritmethicShiftLeft(i: Integer; Count: Byte): Integer;
asm
  SAL EAX, DL
end;

function {sar}AritmethicShiftRighti: Integer; Count: Byte): Integer;
asm
  SAR EAX, DL
end;

(nur für Win32 ... bei Win64 wurden ja die Register verschoben)

In Pascal würde der Code zwar plattformunabhängig, aber optimal würde der Code nicht wirklich.

Delphi-Quellcode:

function {sal}AritmethicShiftLeft(i, Count: Integer): Integer;
begin
  if Count < 0 then
    Exit(AritmethicShiftRight(i, -Count));
  Result := (i and $80000000) or ((i shl Count) and not $80000000);
end;

function {sar}AritmethicShiftRight(i, Count: Integer): Integer;
begin
  if Count < 0 then
    Exit(AritmethicShiftLeft(i, -Count));
  Result := (i and $80000000) or ((i shr Count) or (Integer(-1) shl (32 - Max(Count, 32))));
end;

(läßt sich aber bestimmt noch etwas optimieren)