Список говнокодов пользователя j123123

Всего: 332

Assembler / Говнокод #20423

−715

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

return instruction emitted twice with branch target inbetween

function

unsigned int fact( unsigned int n) { return n < 1 ? 1 : n*fact(n-1); }

produces

fact:
.LFB0:
        .cfi_startproc
        testl   %edi, %edi
        movl    $1, %eax
        je      .L4
        .p2align 4,,10
        .p2align 3
.L3:
        imull   %edi, %eax
        subl    $1, %edi
        jne     .L3
        rep ret # <-- this instruction can be removed
.L4:
        rep ret
        .cfi_endproc
.LFE0:
        .size   fact, .-fact
        .section        .text.unlikely

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71923 даже факториал не могут скомпилировать нормально

j123123, 25 Июля 2016

Комментарии (56)

Си / Говнокод #20418

−47

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17

Имеем приблизительно такой код

#define XXX(n) ar[n]=s._field_##n;
XXX(01);
XXX(02);
XXX(03);
XXX(04);
XXX(05);
XXX(06);
XXX(07);
XXX(08);

Естесвенно при при компиляции получаем ошибку, т.к. 08 это неправильная восмеричная константа. Обойти можно так

#define XXX(n) ar[1##n-100]=s._field_##n;

Но как-то это некрасиво. Может есть более красивый подход?

https://www.linux.org.ru/forum/development/12607523

j123123, 24 Июля 2016

Комментарии (45)

Си / Говнокод #20402

−50

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

Timer_Overflow_Interrupt(void)
{
switch(TMR_State)			// Обработчик прерывания по переполнению
	{
	case 0:	
		{ 
		Clr_Pin();		// Вывод в 0
		TCNT = 255-100; 	// Задержка в 100 (до переполнения)
		TMR_State = 1; 		// Следующая стадия 1
		Break;			// Выход
		}
 
	case 1:	
		{ 
		Set_Pin();
		TCNT = 255-1; 
		TMR_State = 2; 
		Break;
		}
 
	case 2:	
		{ 
		Clr_Pin();
		TCNT = 255-5; 
		TMR_State = 3; 
		Break;
		}
 
	case 3:	
		{ 
		Set_Pin();
		TCNT = 255-2; 
		TMR_State = 4; 
		Break;
		}
 
	case 4:	
		{ 
		Clr_Pin();
		TCNT = 255-3; 
		TMR_State = 5; 
		Break;
		}
 
	case 5:	
		{ 
		Set_Pin();
		TCNT = 255-4; 
		TMR_State = 6; 
		Break;
		}
 
	case 6:
		{ 
		Clr_Pin();
		Timer_OFF(); 		// Выключаем таймер. Работа окончена
		TMR_State = 0; 		// Обнуляем состояние
		Break;			
		}
 
	default: 	break;		
	}
}

http://easyelectronics.ru/avr-uchebnyj-kurs-konechnyj-avtomat.html

А не лучше ли сделать массив указателей на функции, каждая из которых будет соответствовать case-у, и пусть там оно вызывает из массива фукнцию под номером TMR_State? Притом вот эту хню TMR_State = 1; TMR_State = 2; TMR_State = 3; которая дублируется во всех этих case-ах, ее ж можно хуйнуть всего один раз, типа TMR_State = (TMR_state+1)%7. Хотя для AVR контроллеров это скорее всего будет дорогая операция, так что можно хуйнуть TMR_State = TMR_state == 7 ? 0 : TMR_state+1;

j123123, 20 Июля 2016

Комментарии (52)

Си / Говнокод #20350

−47

1

while((*dst++ = *src++));

двойные скобки, чтоб заткнуть ворнинг

warning: suggest parentheses around assignment used as truth value [-Wparentheses]

j123123, 08 Июля 2016

Комментарии (23)

Си / Говнокод #20309

−46

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

#include <stdio.h>
#include <inttypes.h>

#define REORDER3(b1,b2,b3,a1,a2,a3) do {uint32_t b1_tmp = a1; uint32_t b2_tmp = a2; b3 = a3; b1 = b1_tmp; b2 = b2_tmp;} while (0)
 
void uintprint3(uint32_t *a)
{
  printf("%u %u %u\n", a[0], a[1], a[2]);
}

void sort3(uint32_t a[3] )
{
  if (a[0] > a[1])
  {
    if (a[1] > a[2])
    {
      REORDER3 (
        a[0], a[1], a[2],
        a[2], a[1], a[0]);
      return;
    }
    else
    {
      if (a[0] > a[2])
      {
        REORDER3 (
          a[0], a[1], a[2],
          a[1], a[2], a[0]);
        return;
      }
      else
      {
        REORDER3 (
          a[0], a[1], a[2],
          a[1], a[0], a[2]);
        return;
      }
    }
  }
  else
  {
    if (a[1] <= a[2])
    {
      return; //NO REORDER
    }
    else
    {
      if (a[0] <= a[2])
      {
        REORDER3 (
          a[0], a[1], a[2],
          a[0], a[2], a[1] );
        return;
      }
      else
      {
        REORDER3 (
          a[0], a[1], a[2],
          a[2], a[0], a[1] );
        return;
      }
    }
  }
}
 
int main(void)
{
  uint32_t a[] = {0, 1, 2};
  uint32_t b[] = {0, 2, 1};
  uint32_t c[] = {1, 2, 0};
  uint32_t d[] = {1, 0, 2};
  uint32_t e[] = {2, 0, 1};
  uint32_t f[] = {2, 1, 0};
  sort3(a); sort3(b); sort3(c); sort3(d); sort3(e); sort3(f);
 
  uintprint3(a);
  uintprint3(b);
  uintprint3(c);
  uintprint3(d);
  uintprint3(e);
  uintprint3(f);
  return 0;
}

Вот как сортировать надо. А то всякие жабаскриптики http://govnokod.ru/20308 непонятные.

Это говно кстати можно автосгенерировать для произвольной длины, но мне что-то западло этим заниматься

j123123, 01 Июля 2016

Комментарии (10)

Си / Говнокод #20289

−47

1

http://ache.vniz.net/demos.html

> Cвоеобразный программисткий подвиг совершил Дима Бурков. В то время начали появляться первые PC. Unix на них выглядел неубедительно. Linux еще не появился, зато повился Venix. Хачить его было невозможно - не было исходных текстов ядра. Дима Бурков реассемблировал ядро, потом писал программы на Си, которые давали тот же текст ассемблера - так появились тексты ядра на Си ... работа не для слабонервных.

А вот интересно, можно ли сделать декомпилятор таким способом? Например, если известна точная версия GCC и флаги компиляции, которые использовались (ну и естественно исходники компилятора должны быть в наличии) то перебирать с эвристиками некий Си-код, пользуясь дизасм-листингом для подсказки и сравнения. Какой подход использует Hex-Rays например? Вряд ли они исходники GCC ковыряли

j123123, 28 Июня 2016

Комментарии (12)

Си / Говнокод #20245

−47

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

//                   ПРЕОБРАЗОВАНИЕ КОДА И КОНЕЧНЫЕ АВТОМАТЫ
//                   ---------------------------------------
//               (проектируем очень хуево дизассемблируемый код)

int T[256] =
{
  4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  //                      , -      0 1 2 3 4 5 6 7 8 9
  0,0,0,0,0,0,0,0,0,0,0,0,2,3,0,0, 1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
};

for(;;)
{
  int A;
  switch( S )
  {
    case 0:
            switch( T[*c] )
            {
              case 1:  { S=1; A=1; }; break;
              default: { S=5; A=2; }; break;
            }
            break;
    case 1:
            switch( T[*c] )
            {
              case 2:  { S=0; A=2; }; break;
              case 1:  { S=1; A=3; }; break;
              case 3:  { S=2;      }; break;
              case 4:  { S=4; A=2; }; break;
              case 0:  { S=5;      }; break;
            }
            break;
    case 2:
            switch( T[*c] )
            {
              case 1:  { S=3; A=4; }; break;
              default: { S=5;      }; break;
            }
            break;
    case 3:
            switch( T[*c] )
            {
              case 2:  { S=0; A=5; }; break;
              case 1:  { S=3; A=6; }; break;
              case 4:  { S=4; A=5; }; break;
              default: { S=5;      }; break;
            }
            break;
    case 4:
            A = 7;
            break;
    case 5:
            A = 8;
            break;
  }
  switch( A )
  {
    case 1: { l=*c-'0';      c++; }; break;
    case 2: { store(l,l);    c++; }; break;
    case 3: { l=l*10+*c-'0'; c++; }; break;
    case 4: { h=*c-'0';      c++; }; break;
    case 5: { store(l,h);    c++; }; break;
    case 6: { h=h*10+*c-'0'; c++; }; break;
    case 7: { exit();             }; break;
    case 8: { error();            }; break;
  }
}

http://z0mbie.daemonlab.org/automaton.txt отсюда

Мне это напомнило вот эту вот ебанутейшую хуиту https://src.chromium.org/viewvc/native_client/trunk/src/native_client/src/trusted/validator_ragel/gen/validator_x86_64.c из хрома, которая делает валидацию опкодов из-под NaCl, его через какой-то ragel делают

j123123, 22 Июня 2016

Комментарии (15)

Assembler / Говнокод #20234

+70

1

https://youtu.be/hB6eY73sLV0?t=241

Исполнение произвольного кода(в данном случае Flappy Bird) в Super Mario World. Запись инструкций в память происходит посредством прыжков в нужных координатах.

j123123, 20 Июня 2016

Комментарии (7)

Си / Говнокод #20200

−47

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

int hardinfo_updata( struct UPINFO * headinfo, struct HARDINFO * hardinfo )
{
	char sbuf[128] ;
	int sn_len = 0 ;
	char *psn ;
	
	printf("%s\n",__FUNCTION__  ) ;
	memset( sbuf, 0xFF, 128 ) ;
	if( strcmp( hardinfo->flag, "hardinfo") != 0 )
	{
		psn = (char *)hardinfo ;
		sn_len = *psn ;
		psn += 1;
		memcpy( sbuf, psn , 127 ) ;
	}
	else
	{
		sn_len = hardinfo->sn_len ;
		memcpy(sbuf, hardinfo->sn, 128 ) ;
	}

	memcpy( hardinfo, &(headinfo->hardinfo), sizeof( struct HARDINFO ) ) ;
	hardinfo->sn_len = sn_len ;
	if( hardinfo->sn_len > 128 ) hardinfo->sn_len = 128 ;
	memcpy( hardinfo->sn, sbuf, hardinfo->sn_len ) ;
	
	memset( 0x30008000, 0xFF, 0x20000 ) ;
	memcpy( 0x30008000, hardinfo, sizeof( struct HARDINFO ) ) ;
	memset( sbuf, 0xFF, 128 ) ;
	sprintf( sbuf, "%s %x %x\0", "nand erase 80000 80000 ;nand write 0x30008000", 0x80000, 0x20000) ;
	run_command( sbuf,0);

	memset( sbuf, 0, 128 ) ;
	sprintf( sbuf, "%s %x\0", "nand read  0x31000000 80000 ", 0x20000 ) ;
	run_command(sbuf, 0 ) ;

	if( memcmp( 0x30008000, 0x31000000, sizeof( struct HARDINFO) ) != 0 )
	{
		printf("bootloader data crc error\n") ;
		return 0 ;
	}
	else
	{
		printf("update hardinfo is ok\n") ;
	}

	return 1 ;
}

CRC через memcpy. Из пропатченного китайцами u-boot

j123123, 15 Июня 2016

Комментарии (65)

Си / Говнокод #20170

−49

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

bool decode_hex(void *p, size_t max_len, const char *hexstr, size_t *out_len_)
{
static const unsigned char hexdigit_val[256] = {
        ['0'] = 0,
        ['1'] = 1,
        ['2'] = 2,
        ['3'] = 3,
        ['4'] = 4,
        ['5'] = 5,
        ['6'] = 6,
        ['7'] = 7,
        ['8'] = 8,
        ['9'] = 9,
        ['a'] = 0xa,
        ['b'] = 0xb,
        ['c'] = 0xc,
        ['d'] = 0xd,
        ['e'] = 0xe,
        ['f'] = 0xf,
        ['A'] = 0xa,
        ['B'] = 0xb,
        ['C'] = 0xc,
        ['D'] = 0xd,
        ['E'] = 0xe,
        ['F'] = 0xf,};

        if (!p || !hexstr)
                return false;
        if (!strncmp(hexstr, "0x", 2))
                hexstr += 2;
        if (strlen(hexstr) > (max_len * 2))
                return false;

        unsigned char *buf = p;
        size_t out_len = 0;

        while (*hexstr) {
                unsigned char c1 = (unsigned char) hexstr[0];
                unsigned char c2 = (unsigned char) hexstr[1];

                unsigned char v1 = hexdigit_val[c1];
                unsigned char v2 = hexdigit_val[c2];

                if (!v1 && (c1 != '0'))
                        return false;
                if (!v2 && (c2 != '0'))
                        return false;

                *buf = (v1 << 4) | v2;

                out_len++;
                buf++;
                hexstr += 2;
        }

        if (out_len_)
                *out_len_ = out_len;
        return true;
}

https://gist.github.com/aido/9490244#file-der_test-L16 оптимизция!

j123123, 09 Июня 2016

Комментарии (48)

Говнокод: по колено в коде.