1. Assembler / Говнокод #25867

    +1

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    #include <stdbool.h>
    
    bool impl(bool a, bool b) // ->
    {
        return (!a || b);
    }
    
    bool always_true(bool a, bool b)
    {
        return (impl(a,b) == impl(b,a)) == (a == b); // ( (a -> b) = (b -> a) ) = (a = b) tautology
    }
    
    /*
    GCC не хочет мне тавтологию оптимизировать!
    https://godbolt.org/z/kgFMpR
    always_true:
            movl    %esi, %eax
            xorl    %edi, %eax
            cmpb    %dil, %sil
            sete    %dl
            xorl    %edx, %eax
            ret
    Но Clang может
    https://godbolt.org/z/YcOat-
    always_true:                            # @always_true
            movb    $1, %al
            retq
    */

    ГОВНО!

    Запостил: j123123, 24 Сентября 2019

    Комментарии (46) RSS

    • Давайте еще тавтологию проверим
      https://en.wikipedia.org/wiki/Frege%27s_theorem
      (P → (Q→R)) → ((P→Q) → (P→R))
      bool always_true2(bool P, bool Q, bool R)
      {
          return impl( impl(P, impl(Q, R)), impl(impl(P, Q), impl(P, R)); 
      }


      GCC опять хрени нагенерил.
      always_true2:
              movl    %esi, %eax
              movl    %edi, %ecx
              andl    %edi, %esi
              xorl    $1, %eax
              xorl    $1, %ecx
              orl     %edx, %ecx
              andl    %edi, %eax
              xorl    $1, %edx
              orl     %ecx, %eax
              andl    %edx, %esi
              orl     %esi, %eax
              ret

      а clang норм сделал:
      always_true2:                           # @always_true2
              movb    $1, %al
              retq
      Ответить
    • показать все, что скрытоvanished
      Ответить
      • Я ж компилятор тестирую. Эта тавтология может в раскрытии каких-то макросов проявиться.
        Ответить
    • #include <stdbool.h>
      
      bool bxor(bool a, bool b)
      {
        return a^b;
      }
      
      // http://us.metamath.org/ileuni/df-xor.html
      // ((φ ⊻ ψ) ↔ ((φ ∨ ψ) ∧ ¬ (φ ∧ ψ)))
      bool bxor2(bool a, bool b) 
      {
        return ((a || b) && !(a && b));
      }
      
      bool bxor_always_true(bool a, bool b)
      {
        return (bxor(a, b) == bxor2(a, b));
      }

      А вот эту хуйню ни один компилятор не оптимизирует
      Ответить
    • показать все, что скрытоvanished
      Ответить
    • Спасибо, что напомнил мне, что такое импликация. Я ее со второго курса не видел.
      Ответить
    • Вы ещё не видели, какую гадость генерирует «Фрипаскаль». Импликация:
      function impl(a, b: boolean): boolean; inline;
      begin
          impl := not a or b
      end;
      Выхлоп кодогенератора:
      P$PROGRAM_$$_IMPL$BOOLEAN$BOOLEAN$$BOOLEAN:
      	testb	%al,%al
      	je	.Lj5
      .Lj7:
      	testb	%dl,%dl
      	je	.Lj6
      .Lj5:
      	movb	$1,%al
      	jmp	.Lj8
      .Lj6:
      	movb	$0,%al
      .Lj8:
      	ret
      Он зачем-то чистит булеву переменную, чтобы на выходе точно не было ничего, кроме нуля и единицы. В функции always_true и always_true2 он подставляет именно этот фрагмент кода, не оптимизируя.

      Если же сделать каст к байту, то выхлоп уже без ветвлений:
      function impl(a, b: boolean): boolean; inline;
      begin
          impl := boolean(not byte(a) or byte(b))
      end;
      P$PROGRAM_$$_IMPL$BOOLEAN$BOOLEAN$$BOOLEAN:
      	movb	%dl,%al
      	notb	%cl
      	orb	%cl,%al
      	andl 	$255,%eax
      	ret
      Ответить
    • Фортеры не умеют в алгебру лолгики:
      SP-FORTH - ANS FORTH 94 for Win95/98/Me/NT/2k/XP/Vista
      Open source project at http://spf.sf.net
      Russian FIG at http://www.forth.org.ru ; Started by A.Cherezov
      Version 4.20 Build 001 at 21.Jan.2009
      
      >/lib/ext/disasm.f
      
      Loading Intel Pentium MMX disassembler... Ok
       Ok
      >: impl  ( a b -- c )  swap invert or ;
       Ok
      >0 0 impl . 0 1 impl . 1 0 impl . 1 1 impl .
      -1 -1 -2 -1  Ok
      >( ой операция побитловая ) 0 0 impl . 0 -1 impl . -1 0 impl . -1 -1 impl .
      -1 -1 0 -1  Ok
      >: always-true  { a b -- true }  a b impl b a impl = a b = = ;
       Ok
      >0 0 always-true . 0 -1 always-true . -1 0 always-true . -1 -1 always-true .
      -1 -1 -1 -1  Ok
      >SEE impl
      
      59C367 8B5500		MOV     EDX , 0 [EBP] 
      59C36A 8BCA		MOV     ECX , EDX 
      59C36C F7D1		NOT     ECX 
      59C36E 0BC1		OR      EAX , ECX 
      59C370 8D6D04		LEA     EBP , 4 [EBP] 
      59C373 C3		RET     NEAR 
      END-CODE   Ok
      >SEE always-true
      
      59C38F FF7500		PUSH    0 [EBP] 
      59C392 50		PUSH    EAX 
      59C393 8B442404		MOV     EAX , 4 [ESP] 
      59C397 8BD0		MOV     EDX , EAX 
      59C399 8B0424		MOV     EAX , [ESP] 
      59C39C 8BCA		MOV     ECX , EDX 
      59C39E F7D1		NOT     ECX 
      59C3A0 0BC1		OR      EAX , ECX 
      59C3A2 894500		MOV     0 [EBP] , EAX 
      59C3A5 8B0424		MOV     EAX , [ESP] 
      59C3A8 8BD0		MOV     EDX , EAX 
      59C3AA 8B442404		MOV     EAX , 4 [ESP] 
      59C3AE 8BCA		MOV     ECX , EDX 
      59C3B0 F7D1		NOT     ECX 
      59C3B2 0BC1		OR      EAX , ECX 
      59C3B4 334500		XOR     EAX , 0 [EBP] 
      59C3B7 83E801		SUB     EAX , # 1 
      59C3BA 1BC0		SBB     EAX , EAX 
      59C3BC 894500		MOV     0 [EBP] , EAX 
      59C3BF 8B442404		MOV     EAX , 4 [ESP] 
      59C3C3 8B0C24		MOV     ECX , [ESP] 
      59C3C6 33C1		XOR     EAX , ECX 
      59C3C8 83E801		SUB     EAX , # 1 
      59C3CB 1BC0		SBB     EAX , EAX 
      59C3CD 334500		XOR     EAX , 0 [EBP] 
      59C3D0 83E801		SUB     EAX , # 1 
      59C3D3 1BC0		SBB     EAX , EAX 
      59C3D5 8D6D04		LEA     EBP , 4 [EBP] 
      59C3D8 83C408		ADD     ESP , # 8 
      59C3DB C3		RET     NEAR 
      END-CODE   Ok
      >


      Какой позор (((
      Ответить
      • У SwiftForth все гораздое хужее:
        : impl  ( a b -- c )  swap invert or ;  ok
        : always-true  {: a b -- true :}  a b impl b a impl = a b = = ;  ok
        see impl
        47A14F   0 [EBP] EAX MOV                8B4500
        47A152   EBX 0 [EBP] MOV                895D00
        47A155   EAX EBX MOV                    8BD8
        47A157   EBX NOT                        F7D3
        47A159   0 [EBP] EBX OR                 0B5D00
        47A15C   4 # EBP ADD                    83C504
        47A15F   RET                            C3 ok
        see always-true
        47A17F   4 # EBP SUB                    83ED04
        47A182   EBX 0 [EBP] MOV                895D00
        47A185   8 # EBX MOV                    BB08000000
        47A18A   42974F ( LSPACE ) CALL         E8C0F5FAFF
        47A18F   A0 [ESI] EAX MOV               8B86A0000000
        47A195   EBX 4 [EAX] MOV                895804
        47A198   0 [EBP] EBX MOV                8B5D00
        47A19B   4 # EBP ADD                    83C504
        47A19E   A0 [ESI] EAX MOV               8B86A0000000
        47A1A4   EBX 0 [EAX] MOV                8918
        47A1A6   0 [EBP] EBX MOV                8B5D00
        47A1A9   4 # EBP ADD                    83C504
        47A1AC   4 # EBP SUB                    83ED04
        47A1AF   EBX 0 [EBP] MOV                895D00
        47A1B2   A0 [ESI] EBX MOV               8B9EA0000000
        47A1B8   0 [EBX] EBX MOV                8B1B
        47A1BA   4 # EBP SUB                    83ED04
        47A1BD   EBX 0 [EBP] MOV                895D00
        47A1C0   A0 [ESI] EBX MOV               8B9EA0000000
        47A1C6   4 [EBX] EBX MOV                8B5B04
        47A1C9   47A14F ( impl ) CALL           E881FFFFFF
        47A1CE   4 # EBP SUB                    83ED04
        47A1D1   EBX 0 [EBP] MOV                895D00
        47A1D4   A0 [ESI] EBX MOV               8B9EA0000000
        47A1DA   4 [EBX] EBX MOV                8B5B04
        47A1DD   4 # EBP SUB                    83ED04
        47A1E0   EBX 0 [EBP] MOV                895D00
        47A1E3   A0 [ESI] EBX MOV               8B9EA0000000
        47A1E9   0 [EBX] EBX MOV                8B1B
        Продолжение следует...
        Ответить
        • Продолжение:
          47A1EB   47A14F ( impl ) CALL           E85FFFFFFF
          47A1F0   405F1F ( = ) CALL              E82ABDF8FF
          47A1F5   4 # EBP SUB                    83ED04
          47A1F8   EBX 0 [EBP] MOV                895D00
          47A1FB   A0 [ESI] EBX MOV               8B9EA0000000
          47A201   0 [EBX] EBX MOV                8B1B
          47A203   4 # EBP SUB                    83ED04
          47A206   EBX 0 [EBP] MOV                895D00
          47A209   A0 [ESI] EBX MOV               8B9EA0000000
          47A20F   4 [EBX] EBX MOV                8B5B04
          47A212   405F1F ( = ) CALL              E808BDF8FF
          47A217   405F1F ( = ) JMP               E903BDF8FF ok
          Какие $399 )))
          Ответить
      • показать все, что скрытоvanished
        Ответить
    • Где здесь "Assembler", j123123?
      Ответить
    • показать все, что скрытоBSF/BSR на каком ЧПУ появились?
      Ответить

    Добавить комментарий