Форум ELECTRONIX

kreker 0

Posted April 19, 2021 (edited) · Report post

Доброго дня. Спрошу тут, авось кто-нибудь поможет.

IDE, эклипсо-подобная: Simplicity Studio v5

МК: EFM32GG11B120F2048GM64

В своей поделке использую cJSON библиотеку.

Спустя пару минут работы программного цикла ловлю Hardfault, похоже, связанный именно с этой либой: каким-то образом output_size увеличилось до 13618, хотя на выходе размер строки не должен быть больше 200+ символов.

Вместе с формированием \ отправкой строк постоянно рабоает таймер по прерыванию (раз в секунду) и GPIO прерывание (раз в 8 миллисекунд каждые 100 миллисекунд).

Каким образом можно определить, почему происходит переполнение буфера?

Если что-то не указал - скажите, дополню.

Быстрые ссылки на код в либе: printf_string_ptr(), print_object(), print_value(), print_array(), print_value(), print_object(), print_value(), print(), cJSON_PrintUnformatted()

Регистры состояния:

HardFault:
SCB->CFSR   0x00008200
SCB->HFSR   0x40000000
SCB->MMFAR  0x20083399
SCB->BFAR   0x20083399

SP          0x2007fe08
R0          0x2007fe67
R1          0x20002adb
R2          0x20002adb
R3          0x00003533
R12         0x00000000
LR          0x0000a0af
PC          0x0000a0b0
PSR         0x01000000


[HardFault]
SP        = 2007fe08
R0        = 2007fe67
R1        = 20002adb
R2        = 20002adb
R3        = 00003533
R12       = 00000000
LR [R14]  = 0000a0af - Subroutine Call return address
PC [R15]  = 0000a0b0 - Program Counter
PSR       = 01000000
BFAR      = 20083399 - Bus Fault SR/Address causing bus fault
CFSR      = 00008200 - Config. Fault SR
HFSR      = 40000000 - Hard Fault SR
  :FORCED, Bus fault/Memory management fault/usage fault
DFSR      = 00000000 - Debug Fault SR
MMAR      = 20083399 - Memory Manage Address R
AFSR      = 00000000 - Auxilirary Fault SR
SCB->SHCSR= 00000000 - System Handler Control and State R (exception)

Дизассемблер, ошибку проставляет по строке: 0000a0b0: strb r6,[r7,r3]

Spoiler

0000a020:   str     r3,[r5]
 512                  return NULL;
0000a022:   b       0x0000000000009fca
 446              return NULL;
0000a024:   movs    r6,#0x0
0000a026:   b       0x0000000000009fca
 452              return NULL;
0000a028:   movs    r6,#0x0
0000a02a:   b       0x0000000000009fca
 458              return NULL;
0000a02c:   movs    r6,#0x0
0000a02e:   b       0x0000000000009fca
 468              return NULL;
0000a030:   movs    r6,#0x0
0000a032:   b       0x0000000000009fca
 907          if (output_buffer == NULL)
          print_string_ptr:
0000a034:   cmp     r1,#0x0
0000a036:   beq.w   0x000000000000a13e
 899      {
0000a03a:   push    {r3,r4,r5,r6,r7,lr}
0000a03c:   mov     r5,r0
0000a03e:   mov     r0,r1
 913          if (input == NULL)
0000a040:   cbz     r5,0x000000000000a048
 926          for (input_pointer = input; *input_pointer; input_pointer++)
0000a042:   mov     r2,r5
 905          size_t escape_characters = 0;
0000a044:   movs    r6,#0x0
0000a046:   b       0x000000000000a068
 915              output = ensure(output_buffer, sizeof("\"\""));
0000a048:   movs    r1,#0x3
0000a04a:   bl      0x0000000000009f8e
 916              if (output == NULL)
0000a04e:   cmp     r0,#0x0
0000a050:   beq     0x000000000000a142
 920              strcpy((char*)output, "\"\"");
0000a052:   ldr     r1,[pc,#0xf8] ; 0xa148
0000a054:   bl      0x000000000000d7b8
 922              return true;
0000a058:   movs    r0,#0x1
0000a05a:   b       0x000000000000a13c
 928              switch (*input_pointer)
0000a05c:   cmp     r3,#0x22
0000a05e:   beq     0x000000000000a064
0000a060:   cmp     r3,#0x5c
0000a062:   bne     0x000000000000a07c
 938                      escape_characters++;
0000a064:   adds    r6,#0x1
 926          for (input_pointer = input; *input_pointer; input_pointer++)
0000a066:   adds    r2,#0x1
0000a068:   ldrb    r3,[r2]
0000a06a:   cbz     r3,0x000000000000a084
 928              switch (*input_pointer)
0000a06c:   cmp     r3,#0xd
0000a06e:   bhi     0x000000000000a05c
0000a070:   cmp     r3,#0xc
0000a072:   bcs     0x000000000000a064
0000a074:   sub.w   r1,r3,#0x8
0000a078:   cmp     r1,#0x2
0000a07a:   bls     0x000000000000a064
 941                      if (*input_pointer < 32)
0000a07c:   cmp     r3,#0x1f
0000a07e:   bhi     0x000000000000a066
 944                          escape_characters += 5;
0000a080:   adds    r6,#0x5
0000a082:   b       0x000000000000a066
 949          output_length = (size_t)(input_pointer - input) + escape_characters;
0000a084:   subs    r2,r2,r5
0000a086:   adds    r4,r2,r6
 951          output = ensure(output_buffer, output_length + sizeof("\"\""));
0000a088:   adds    r1,r4,#3
0000a08a:   bl      0x0000000000009f8e
 952          if (output == NULL)
0000a08e:   mov     r7,r0
0000a090:   cmp     r0,#0x0
0000a092:   beq     0x000000000000a146
 958          if (escape_characters == 0)
0000a094:   cbz     r6,0x000000000000a0a0
 968          output[0] = '\"';
0000a096:   mov     r6,r0
0000a098:   movs    r3,#0x22
0000a09a:   strb    r3,[r6],#0x1
 971          for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++)
0000a09e:   b       0x000000000000a0fa
 960              output[0] = '\"';
0000a0a0:   movs    r6,#0x22
0000a0a2:   strb    r6,[r0],#0x1
 961              memcpy(output + 1, input, output_length);
0000a0a6:   mov     r2,r4
0000a0a8:   mov     r1,r5
0000a0aa:   bl      0x000000000000cb6c
 962              output[output_length + 1] = '\"';
0000a0ae:   adds    r3,r4,#1
0000a0b0:   strb    r6,[r7,r3]
 963              output[output_length + 2] = '\0';
0000a0b2:   adds    r4,#0x2
0000a0b4:   movs    r3,#0x0
0000a0b6:   strb    r3,[r7,r4]
 965              return true;
0000a0b8:   movs    r0,#0x1
0000a0ba:   b       0x000000000000a13c
 981                  *output_pointer++ = '\\';
0000a0bc:   adds    r0,r6,#1
0000a0be:   movs    r3,#0x5c
0000a0c0:   strb    r3,[r6]
 982                  switch (*input_pointer)
0000a0c2:   ldrb    r2,[r5]
0000a0c4:   cmp     r2,#0xc
0000a0c6:   beq     0x000000000000a11c
0000a0c8:   bhi     0x000000000000a0e0
0000a0ca:   cmp     r2,#0x9
0000a0cc:   beq     0x000000000000a128
0000a0ce:   cmp     r2,#0xa
0000a0d0:   beq     0x000000000000a122
0000a0d2:   cmp     r2,#0x8
0000a0d4:   beq     0x000000000000a116
1007                          sprintf((char*)output_pointer, "u%04x", *input_pointer);
0000a0d6:   ldr     r1,[pc,#0x78] ; 0xa14c
0000a0d8:   bl      0x000000000000d66c
1008                          output_pointer += 4;
0000a0dc:   adds    r0,r6,#5
1009                          break;
0000a0de:   b       0x000000000000a0f6
 982                  switch (*input_pointer)
0000a0e0:   cmp     r2,#0x22
0000a0e2:   beq     0x000000000000a110
0000a0e4:   cmp     r2,#0x5c
0000a0e6:   beq     0x000000000000a0f2
0000a0e8:   cmp     r2,#0xd
0000a0ea:   bne     0x000000000000a0d6
1000                          *output_pointer = 'r';
0000a0ec:   movs    r3,#0x72
0000a0ee:   strb    r3,[r6,#0x1]
1001                          break;
0000a0f0:   b       0x000000000000a0f6
 985                          *output_pointer = '\\';
0000a0f2:   movs    r3,#0x5c
0000a0f4:   strb    r3,[r6,#0x1]
 971          for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++)
0000a0f6:   adds    r5,#0x1
0000a0f8:   adds    r6,r0,#1
0000a0fa:   ldrb    r3,[r5]
0000a0fc:   cbz     r3,0x000000000000a12e
 973              if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\'))
0000a0fe:   cmp     r3,#0x1f
0000a100:   bls     0x000000000000a0bc
0000a102:   cmp     r3,#0x22
0000a104:   beq     0x000000000000a0bc
0000a106:   cmp     r3,#0x5c
0000a108:   beq     0x000000000000a0bc
 976                  *output_pointer = *input_pointer;
0000a10a:   strb    r3,[r6]
0000a10c:   mov     r0,r6
0000a10e:   b       0x000000000000a0f6
 988                          *output_pointer = '\"';
0000a110:   movs    r3,#0x22
0000a112:   strb    r3,[r6,#0x1]
 989                          break;
0000a114:   b       0x000000000000a0f6
 991                          *output_pointer = 'b';
0000a116:   movs    r3,#0x62
0000a118:   strb    r3,[r6,#0x1]
 992                          break;
0000a11a:   b       0x000000000000a0f6
 994                          *output_pointer = 'f';
0000a11c:   movs    r3,#0x66
0000a11e:   strb    r3,[r6,#0x1]
 995                          break;
0000a120:   b       0x000000000000a0f6
 997                          *output_pointer = 'n';
0000a122:   movs    r3,#0x6e
0000a124:   strb    r3,[r6,#0x1]
 998                          break;
0000a126:   b       0x000000000000a0f6
1003                          *output_pointer = 't';
0000a128:   movs    r3,#0x74
0000a12a:   strb    r3,[r6,#0x1]
1004                          break;
0000a12c:   b       0x000000000000a0f6
1013          output[output_length + 1] = '\"';
0000a12e:   adds    r3,r4,#1
0000a130:   movs    r2,#0x22
0000a132:   strb    r2,[r7,r3]
1014          output[output_length + 2] = '\0';
0000a134:   adds    r4,#0x2
0000a136:   movs    r3,#0x0
0000a138:   strb    r3,[r7,r4]
1016          return true;
0000a13a:   movs    r0,#0x1
1017      }
0000a13c:   pop     {r3,r4,r5,r6,r7,pc}
 909              return false;
0000a13e:   movs    r0,#0x0
1017      }
0000a140:   bx      lr
 918                  return false;
0000a142:   movs    r0,#0x0
0000a144:   b       0x000000000000a13c
 954              return false;
0000a146:   movs    r0,#0x0
0000a148:   b       0x000000000000a13c

Немного кода.

Spoiler

char sendbuf[2048]; // промежуточный буфер, объявленный глобально

void packer(char * buffer); // конструктор-json сообщения

packer(sendbuf);

char vartosend[][5] = { // двумерный массив, содержащий имена переменных
  "p0",
  ...
  "p51",
};
 
uint8_t vartosend_elemcount = sizeof(vartosend) / sizeof(vartosend[0]);
 
void packer(char * buffer)
{
  int temp_i = 0;
  char temp_s[50];
  
  cJSON *temp = NULL;
  cJSON *datas = NULL;
  cJSON *data = NULL;
 
  memset(&buffer[0], 0, sizeof(buffer)); // очищаем выбранный буфер, i.e. sendbuf
  
  cJSON *dtsRoot = cJSON_CreateObject(); // создаём коренной JSON объект
  if (dtsRoot == NULL) {
    goto jsonPacExit;
  }
 
  datas = cJSON_CreateArray(); // создаём массив
  if (datas == NULL) {
    goto jsonPacExit;
  }
 
  data = cJSON_CreateObject(); // создаём объект, который станет членом массива datas
  if (data == NULL) {
    goto jsonPacExit;
  }
 
  for (uint8_t k = 0; k < vartosend_elemcount; k++) {
    /* misc code */
 
    switch (k) {
    /* misc code */
 
      default:
        break;
 
    }
 
        temp = cJSON_CreateNumber(temp_i); // создаём число
        if (temp == NULL) {
          goto jsonPacExit;
  }
 
        cJSON_AddItemToObject(data, vartosend[k], temp); // помещаем созданное число в обект дата с нужным именем поля, i.e. "p40":100500
  }
 
  cJSON_AddItemToArray(datas, data); // помещаем объект data в массив datas
  cJSON_AddItemToObject(dtsRoot, "dts", datas); // помещаем массив 'datas' в коренной 'dtsRoot' объект с именем "dts"
  
  char *json = cJSON_PrintUnformatted(dtsRoot); // вывод JSON строки // Должно выглядеть как {"dts":[{"p25":100500, "p50": 500100, ...}]}
  if (json == NULL)
  {
    printf("Failed to print JSON into char string.\n");
    goto jsonPacExit;
  }
 
  if ((json[0] != '{') || (json[(strlen(json) - 1)] != '}')) {
    printf("JSON string is invalid: no { or }.\n");
    goto jsonPacExit;
  }
 
  memcpy(buffer, json, strlen(json) + 1); // копируем JSON строку в указанный буфер, i.e. 'sendbuf'
  
  //printf("JSON: %s\n", json);
  //printf("Packed JSON: %s\n", (char *) sendbuf);
  #if (SPI_DEBUG == 1)
    printf("buffer: %s, strlen: %d\n", buffer, strlen(buffer) + 1); // debug string output
  #endif
 
  jsonPacExit: cJSON_Delete(dtsRoot);
}

Edited April 19, 2021 by kreker

Share this post

Link to post

Share on other sites

jcxz 4

Posted April 19, 2021 · Report post

2 часа назад, kreker сказал:

Каким образом можно определить, почему происходит переполнение буфера?

Очевидно - открыть мануал на ядро и расшифровать причину fault-а по приведённым регистрам (тем более, что нужные регистры Вы уже привели).

Судя по SCB->HFSR, SCB->CFSR, SCB->BFAR у Вас точная ошибка при обращении к данным по адресу 0x20083399, произошедшая при PC==0xA0B0 (если конечно правильно снят дамп стекинга).

В этой точке видимо R7+R3=0x20083399 (R3 вы привели, а R7 - нет). Лень листать даташит на ваш МК, вангую выход на пределы физической памяти.

Почему обращение произошло по этому адресу - ищите.

PS: Всё-таки открыл даташит: так и есть - выход за пределы RAM2 (>= 0x20080000).

PPS: Советую в проблемной точке поставить условный бряк на условие R7+R3 >= 0x20080000 и исследовать отладчиком.

Share this post

Link to post

Share on other sites

kreker 0

Posted April 19, 2021 · Report post

8 minutes ago, jcxz said:

Очевидно

Очевидно для тех, кто на этом собаку съел :) Опыта в таких делах - нуль, первый раз на такое напарываюсь.

17 minutes ago, jcxz said:

открыть мануал на ядро и расшифровать причину fault-а по приведённым регистрам

18 minutes ago, jcxz said:

Почему обращение произошло по этому адресу - ищите.

Можно, пожалуйста, подробнее. Если не трудно.

Share this post

Link to post

Share on other sites

jcxz 4

Posted April 19, 2021 · Report post

3 минуты назад, kreker сказал:

Можно, пожалуйста, подробнее. Если не трудно.

Так я же уже написал ранее:

21 минуту назад, jcxz сказал:

PPS: Советую в проблемной точке поставить условный бряк на условие R7+R3 >= 0x20080000 и исследовать отладчиком.

PS: А ещё совет - написать автоматический расшифровщик причины HF. В ISR HF. Чтобы каждый раз врукопашную по регистрам не лазить.

Share this post

Link to post

Share on other sites

kreker 0

Posted April 19, 2021 · Report post

58 minutes ago, jcxz said:

Так я же уже написал ранее:

Проверьте, пожалуйста, ЛС.

Share this post

Link to post

Share on other sites

jcxz 4

Posted April 19, 2021 · Report post

Непонятно - как memcpy(output + 1, input, output_length);

выполняется без HF, хотя должно вылететь уже на нём.

Поэтому я бы например проверил стеки на предмет переполнения. В этой точке (после memcpy()).

Также - ISR-ы на предмет неразрушения регистров не участвующих в стекинге (был тут недавно один деятель, который не сохранял R8,R9 в ассемблерном ISR и аргументируя "и так ведь работает" :biggrin: ).

Ну и другие подобные места проверить.

Share this post

Link to post

Share on other sites

kreker 0

Posted April 19, 2021 (edited) · Report post

5 hours ago, jcxz said:

я бы например проверил стеки на предмет переполнения

Если не трудно - подскажите как это правильно делается.

5 hours ago, jcxz said:

ISR-ы на предмет неразрушения регистров не участвующих в стекинге

Про это я вобще молчу...

Попробую полазить по дебаггеру с ловушкой на условие по выходу за пределы адреса.

Edited April 19, 2021 by kreker

Share this post

Link to post

Share on other sites

kreker 0

Posted April 20, 2021 · Report post

Добрался до дома.

По брекпойнту сразу срабатывает.

if ((unsigned int) &output[output_length + 1] >= 0x20080000u) {
  __ISB();
}

Даже огромных значений в output_length нет. Есть ли что-нибудь криминальное на скриншотах? Или как это определить?

Spoiler

......... ...
 739          switch (k) {
00001078:   mov     r10,r4
0000107a:   cmp     r4,#0x33
0000107c:   bhi.w   0x00000c18
00001080:   add     r3,pc,#0x4
00001082:   ldr.w   pc,[r3,r4,lsl #2]
00001086:   nop
00001088:   lsrs    r3,r0,#16
0000108a:   movs    r0,r0
0000108c:   lsrs    r1,r6,#17
0000108e:   movs    r0,r0
00001090:   lsrs    r1,r1,#18
00001092:   movs    r0,r0
00001094:   lsrs    r1,r4,#18
00001096:   movs    r0,r0
00001098:   lsrs    r1,r7,#18
0000109a:   movs    r0,r0
0000109c:   lsrs    r1,r2,#19
0000109e:   movs    r0,r0
000010a0:   lsrs    r7,r2,#19
000010a2:   movs    r0,r0
000010a4:   lsrs    r5,r3,#19
000010a6:   movs    r0,r0
000010a8:   lsrs    r5,r6,#19
000010aa:   movs    r0,r0
000010ac:   lsrs    r5,r1,#20
000010ae:   movs    r0,r0
000010b0:   lsrs    r5,r4,#20
000010b2:   movs    r0,r0
000010b4:   lsrs    r5,r7,#20
000010b6:   movs    r0,r0
000010b8:   lsrs    r5,r2,#21
000010ba:   movs    r0,r0
000010bc:   lsrs    r5,r5,#21
000010be:   movs    r0,r0
000010c0:   lsrs    r5,r0,#22
000010c2:   movs    r0,r0
000010c4:   lsrs    r5,r3,#22
000010c6:   movs    r0,r0
000010c8:   lsrs    r5,r6,#22
000010ca:   movs    r0,r0
000010cc:   lsrs    r5,r1,#23
000010ce:   movs    r0,r0
000010d0:   lsrs    r5,r4,#23
000010d2:   movs    r0,r0
000010d4:   lsrs    r5,r7,#23
000010d6:   movs    r0,r0
000010d8:   lsrs    r5,r2,#24
000010da:   movs    r0,r0
000010dc:   lsrs    r5,r5,#24
000010de:   movs    r0,r0
000010e0:   lsrs    r5,r0,#25
000010e2:   movs    r0,r0
000010e4:   lsrs    r5,r3,#25
000010e6:   movs    r0,r0
000010e8:   lsrs    r3,r4,#25
000010ea:   movs    r0,r0
000010ec:   lsrs    r1,r5,#25
000010ee:   movs    r0,r0
000010f0:   lsrs    r1,r6,#25
000010f2:   movs    r0,r0
000010f4:   lsrs    r7,r6,#25
000010f6:   movs    r0,r0
000010f8:   lsrs    r5,r7,#25
000010fa:   movs    r0,r0
000010fc:   lsrs    r3,r0,#26
000010fe:   movs    r0,r0
00001100:   lsrs    r1,r1,#26
00001102:   movs    r0,r0
00001104:   lsrs    r7,r1,#26
00001106:   movs    r0,r0
00001108:   lsrs    r7,r2,#26
0000110a:   movs    r0,r0
0000110c:   lsrs    r7,r3,#26
0000110e:   movs    r0,r0
00001110:   lsrs    r7,r4,#26
00001112:   movs    r0,r0
00001114:   lsrs    r5,r5,#26
00001116:   movs    r0,r0
00001118:   lsrs    r3,r6,#26
0000111a:   movs    r0,r0
0000111c:   lsrs    r1,r7,#26
0000111e:   movs    r0,r0
00001120:   lsrs    r7,r7,#26
00001122:   movs    r0,r0
00001124:   lsrs    r7,r0,#27
00001126:   movs    r0,r0
00001128:   lsrs    r5,r1,#27
0000112a:   movs    r0,r0
0000112c:   lsrs    r3,r2,#27
0000112e:   movs    r0,r0
00001130:   lsrs    r1,r3,#27
00001132:   movs    r0,r0
00001134:   lsrs    r7,r3,#27
00001136:   movs    r0,r0
00001138:   lsrs    r5,r4,#27
0000113a:   movs    r0,r0
0000113c:   lsrs    r3,r5,#27
0000113e:   movs    r0,r0
00001140:   lsrs    r1,r6,#27
00001142:   movs    r0,r0
00001144:   lsrs    r7,r6,#27
00001146:   movs    r0,r0
00001148:   lsrs    r5,r3,#29
0000114a:   movs    r0,r0
0000114c:   lsrs    r3,r4,#29
0000114e:   movs    r0,r0
00001150:   lsrs    r1,r5,#29
00001152:   movs    r0,r0
00001154:   lsrs    r5,r2,#30
00001156:   movs    r0,r0
 960            k == 50 ? strlcpy(stringlastVal[0], temp_s, strlen(temp_s) + 1) : strlcpy(stringlastVal[1], temp_s, strlen(temp_s) + 1);
00001158:   add     r0,sp,#0x1c
0000115a:   bl      0x0000d7f6
0000115e:   adds    r2,r0,#1
00001160:   add     r1,sp,#0x1c
00001162:   ldr     r0,[pc,#0xa0] ; 0x1200
00001164:   bl      0x0000d7cc
00001168:   b       0x00001032
 963          } else if ( ( (temp_i != lastVal[k]) || (fullStrCnt != 0) || (paramState & 0x02) ) && (k != 50 && k != 51) ) {
0000116a:   ldr     r2,[pc,#0xa0] ; 0x1208
0000116c:   ldrb    r2,[r2]
0000116e:   cmp     r2,#0x0
00001170:   bne.w   0x00000c42
00001174:   ldr     r2,[pc,#0x98] ; 0x120c
00001176:   ldrb    r2,[r2]
00001178:   tst     r2,#0x2
0000117c:   bne.w   0x00000c42
 974          skip: continue;
00001180:   b       0x0000103c
 977        cJSON_AddItemToArray(datas, data);
00001182:   mov     r1,r9
00001184:   mov     r0,r8
00001186:   bl      0x0000ae3a
 978        if (paramState & 0x02) {
0000118a:   ldr     r3,[pc,#0x84] ; 0x120c
0000118c:   ldrb    r3,[r3]
0000118e:   tst     r3,#0x2
00001192:   beq     0x000011b6
 979          cJSON_AddItemToObject(dtsRoot, "dtr", datas);
00001194:   mov     r2,r8
00001196:   ldr     r1,[pc,#0x84] ; 0x1218
00001198:   mov     r0,r5
0000119a:   bl      0x0000ae44
 984        char *json = cJSON_PrintUnformatted(dtsRoot);
0000119e:   mov     r0,r5
000011a0:   bl      0x0000ae10
 985        if (json == NULL)
000011a4:   mov     r4,r0
000011a6:   cbz     r0,0x000011c2
 991        if ((json[0] != '{') || (json[(strlen(json) - 1)] != '}')) {
000011a8:   ldrb    r3,[r0]
000011aa:   cmp     r3,#0x7b
000011ac:   beq     0x000011ca
 992      	printf("JSON string is invalid: no { or }.\n");
000011ae:   ldr     r0,[pc,#0x70] ; 0x121c
000011b0:   bl      0x0000d5a8
 993      	goto jsonPacExit;
000011b4:   b       0x00000ff4
 981          cJSON_AddItemToObject(dtsRoot, "dts", datas);
000011b6:   mov     r2,r8
000011b8:   ldr     r1,[pc,#0x68] ; 0x1220
000011ba:   mov     r0,r5
000011bc:   bl      0x0000ae44
000011c0:   b       0x0000119e
 987          printf("Failed to print JSON into char string.\n");
000011c2:   ldr     r0,[pc,#0x64] ; 0x1224
000011c4:   bl      0x0000d5a8
 988          goto jsonPacExit;
000011c8:   b       0x00000ff4
 991        if ((json[0] != '{') || (json[(strlen(json) - 1)] != '}')) {
000011ca:   bl      0x0000d7f6
000011ce:   add     r0,r4
000011d0:   ldrb    r3,[r0,#-0x1]
000011d4:   cmp     r3,#0x7d
000011d6:   bne     0x000011ae
 996        memcpy(buffer, json, strlen(json) + 1);
000011d8:   mov     r0,r4
000011da:   bl      0x0000d7f6
000011de:   adds    r2,r0,#1
000011e0:   mov     r1,r4
000011e2:   mov     r0,r7
000011e4:   bl      0x0000cb70
000011e8:   b       0x00000ff4
000011ea:   nop
000011ec:   subs    r4,r0,#1
000011ee:   movs    r0,#0x0
000011f0:   movs    r0,#0x14
000011f2:   movs    r0,#0x0
000011f4:   adds    r0,r3,#7
000011f6:   movs    r0,#0x0
000011f8:   subs    r4,r5,r4
000011fa:   movs    r1,r0
000011fc:   adds    r4,r7,r5
000011fe:   movs    r0,#0x0
00001200:   adds    r4,r3,r4
......... ...
1964          } else if ( (!(stateFlags & 0x04) || (!(stateFlags & 0x02) && !(pidTunes & 0x20)) ) && cooling_firstRun) {
00002542:   ldr     r3,[pc,#0x260] ; 0x27a0
00002544:   ldrb    r3,[r3]
00002546:   tst     r3,#0x4
0000254a:   beq     0x0000255c
0000254c:   tst     r3,#0x2
00002550:   bne     0x00002578
00002552:   ldr     r3,[pc,#0x254] ; 0x27a4
00002554:   ldrb    r3,[r3]
00002556:   tst     r3,#0x20
0000255a:   bne     0x00002578
0000255c:   ldr     r3,[pc,#0x24c] ; 0x27a8
0000255e:   ldrb    r3,[r3]
00002560:   cbz     r3,0x00002578
1190        GPIO->P[port].DOUT = (GPIO->P[port].DOUT & ~mask) | (val & mask);
00002562:   ldr     r1,[pc,#0x24c] ; 0x27ac
00002564:   ldr.w   r2,[r1,#0x9c]
00002568:   bic     r2,r2,#0x78
0000256c:   str.w   r2,[r1,#0x9c]
1966              cooling_firstRun ^= true;
00002570:   eor     r3,r3,#0x1
00002574:   ldr     r2,[pc,#0x234] ; 0x27a8
00002576:   strb    r3,[r2]
1974          if (spi_rx_req || (!(GPIO_PinInGet(ESP32_HANDSHAKE_PORT, ESP32_HANDSHAKE_PIN)))) {
00002578:   ldr     r3,[pc,#0x238] ; 0x27b0
0000257a:   ldrb    r3,[r3]
0000257c:   cbnz    r3,0x00002584
193         return *(volatile uint32_t *)aliasAddr;
0000257e:   ldr     r3,[pc,#0x238] ; 0x27b4
00002580:   ldr     r3,[r3]
1974          if (spi_rx_req || (!(GPIO_PinInGet(ESP32_HANDSHAKE_PORT, ESP32_HANDSHAKE_PIN)))) {
00002582:   cbnz    r3,0x0000259a
1975            ESP32_Recieve(230, recvbuf);
00002584:   ldr     r4,[pc,#0x234] ; 0x27b8
00002586:   mov     r1,r4
00002588:   movs    r0,#0xe6
0000258a:   bl      0x00009312
1976            spi_rx_req = false;
0000258e:   ldr     r3,[pc,#0x224] ; 0x27b0
00002590:   movs    r2,#0x0
00002592:   strb    r2,[r3]
1978            parser((void *) recvbuf);
00002594:   mov     r0,r4
00002596:   bl      0x00001244
1981          if (ws_opened) {
0000259a:   ldr     r3,[pc,#0x224] ; 0x27bc
0000259c:   ldrb    r3,[r3]
0000259e:   cbz     r3,0x000025d2
1982              !(fullStrCnt % 2) && (fullStrCnt != 0) ? temperatureProfilesPacker(sendbuf) : packer(sendbuf);
000025a0:   ldr     r3,[pc,#0x220] ; 0x27c0
000025a2:   ldrb    r3,[r3]
000025a4:   tst     r3,#0x1
000025a8:   bne     0x000025b0
000025aa:   cmp     r3,#0x0
000025ac:   bne.w   0x00002954
000025b0:   ldr     r0,[pc,#0x214] ; 0x27c4
000025b2:   bl      0x00000bc8
1987              ESP32_SPI_Tx(sendbuf);
000025b6:   ldr     r0,[pc,#0x210] ; 0x27c4
000025b8:   bl      0x000006f4
1988              fullStrCnt = ((fullStrCnt < 4) && (fullStrCnt != 0)) ? fullStrCnt + 1 : 0;
000025bc:   ldr     r3,[pc,#0x204] ; 0x27c0
000025be:   ldrb    r3,[r3]
000025c0:   subs    r2,r3,#1
000025c2:   uxtb    r2,r2
000025c4:   cmp     r2,#0x2
000025c6:   bhi.w   0x0000295c
000025ca:   adds    r3,#0x1
000025cc:   uxtb    r3,r3
000025ce:   ldr     r2,[pc,#0x1f4] ; 0x27c0
000025d0:   strb    r3,[r2]
1992          printf("*\n");
000025d2:   ldr     r0,[pc,#0x1f8] ; 0x27c8
000025d4:   bl      0x0000d5a8
1702          if ((WTIMER2->STATUS & TIMER_STATUS_RUNNING) && !(stateFlags & 0x07) && (pidTunes == 0x00)) {
000025d8:   ldr     r3,[pc,#0x1f4] ; 0x27cc
000025da:   ldr     r3,[r3,#0x8]
000025dc:   tst     r3,#0x1
000025e0:   beq     0x00002614
000025e2:   ldr     r3,[pc,#0x1c0] ; 0x27a0
000025e4:   ldrb    r3,[r3]
000025e6:   tst     r3,#0x7
000025ea:   bne     0x00002614
000025ec:   ldr     r3,[pc,#0x1b8] ; 0x27a4
000025ee:   ldrb    r3,[r3]
000025f0:   cbnz    r3,0x00002614
 841          timer->CMD = TIMER_CMD_STOP;
000025f2:   ldr     r3,[pc,#0x1dc] ; 0x27cc
000025f4:   movs    r2,#0x2
000025f6:   str     r2,[r3,#0x4]
1704            GPIO_PortOutSetVal(TRIACDRV_PORT, 0x3F00, used_heaters);
000025f8:   ldr     r3,[pc,#0x1d8] ; 0x27d0
000025fa:   ldr     r0,[r3]
000025fc:   ldr     r2,[pc,#0x1b0] ; 0x27ac
000025fe:   ldr.w   r1,[r2,#0xcc]
00002602:   eor     r3,r1,#0x3f00
00002606:   ands    r3,r0
00002608:   eors    r3,r1
0000260a:   str.w   r3,[r2,#0xcc]
1705            i = 0;
0000260e:   ldr     r3,[pc,#0x1c8] ; 0x27d4
00002610:   movs    r2,#0x0
00002612:   strb    r2,[r3]
1708          if( (strlen(logBuf) > 0) && ws_opened) {
00002614:   ldr     r0,[pc,#0x1c4] ; 0x27d8
00002616:   bl      0x0000d7f6
0000261a:   cbz     r0,0x00002626
0000261c:   ldr     r3,[pc,#0x1a0] ; 0x27bc
0000261e:   ldrb    r3,[r3]
00002620:   cmp     r3,#0x0
00002622:   bne.w   0x00001e2e
1713      	if (updUsedFans) {
00002626:   ldr     r3,[pc,#0x1b8] ; 0x27dc
00002628:   ldrb    r3,[r3]
0000262a:   cmp     r3,#0x0
0000262c:   bne.w   0x00001e3c
1718      	if (updFanCfg) {
00002630:   ldr     r3,[pc,#0x1b0] ; 0x27e0
00002632:   ldrb    r3,[r3]
00002634:   cmp     r3,#0x0
00002636:   bne.w   0x00001e4c
1723      	switch (paramState & 0xFF) {
0000263a:   ldr     r3,[pc,#0x1ac] ; 0x27e4
0000263c:   ldrb    r3,[r3]
0000263e:   subs    r3,#0x1
00002640:   cmp     r3,#0x3f
00002642:   bhi.w   0x00001ee0
00002646:   add     r2,pc,#0x4
00002648:   ldr.w   pc,[r2,r3,lsl #2]
0000264c:   subs    r5,r3,#3
0000264e:   movs    r0,r0
00002650:   subs    r1,r7,#7
00002652:   movs    r0,r0
00002654:   subs    r1,r4,#3
00002656:   movs    r0,r0
00002658:   movs    r0,#0x1
0000265a:   movs    r0,r0
0000265c:   subs    r1,r4,#3
0000265e:   movs    r0,r0
00002660:   subs    r1,r4,#3
00002662:   movs    r0,r0
00002664:   subs    r1,r4,#3
00002666:   movs    r0,r0
00002668:   movs    r0,#0x7
0000266a:   movs    r0,r0
0000266c:   subs    r1,r4,#3
0000266e:   movs    r0,r0
00002670:   subs    r1,r4,#3
00002672:   movs    r0,r0
00002674:   subs    r1,r4,#3
00002676:   movs    r0,r0
00002678:   subs    r1,r4,#3
0000267a:   movs    r0,r0
0000267c:   subs    r1,r4,#3
0000267e:   movs    r0,r0
00002680:   subs    r1,r4,#3
00002682:   movs    r0,r0
00002684:   subs    r1,r4,#3
00002686:   movs    r0,r0
00002688:   movs    r0,#0xd
0000268a:   movs    r0,r0
0000268c:   subs    r1,r4,#3
0000268e:   movs    r0,r0
00002690:   subs    r1,r4,#3
00002692:   movs    r0,r0
00002694:   subs    r1,r4,#3
00002696:   movs    r0,r0
00002698:   subs    r1,r4,#3
0000269a:   movs    r0,r0
0000269c:   subs    r1,r4,#3
0000269e:   movs    r0,r0
000026a0:   subs    r1,r4,#3
000026a2:   movs    r0,r0
000026a4:   subs    r1,r4,#3
000026a6:   movs    r0,r0
000026a8:   subs    r1,r4,#3
000026aa:   movs    r0,r0
000026ac:   subs    r1,r4,#3
000026ae:   movs    r0,r0
000026b0:   subs    r1,r4,#3
000026b2:   movs    r0,r0
000026b4:   subs    r1,r4,#3
000026b6:   movs    r0,r0
000026b8:   subs    r1,r4,#3
000026ba:   movs    r0,r0
000026bc:   subs    r1,r4,#3
000026be:   movs    r0,r0
000026c0:   subs    r1,r4,#3
000026c2:   movs    r0,r0
000026c4:   subs    r1,r4,#3
000026c6:   movs    r0,r0
000026c8:   movs    r0,#0x13
000026ca:   movs    r0,r0
000026cc:   subs    r1,r4,#3
000026ce:   movs    r0,r0
000026d0:   subs    r1,r4,#3
000026d2:   movs    r0,r0
000026d4:   subs    r1,r4,#3
000026d6:   movs    r0,r0
......... ...
 901      {
0000a032:   push    {r3,r4,r5,r6,r7,lr}
0000a034:   mov     r5,r0
0000a036:   mov     r0,r1
 915          if (input == NULL)
0000a038:   cbz     r5,0x0000a040
 928          for (input_pointer = input; *input_pointer; input_pointer++)
0000a03a:   mov     r2,r5
 907          size_t escape_characters = 0;
0000a03c:   movs    r6,#0x0
0000a03e:   b       0x0000a060
 917              output = ensure(output_buffer, sizeof("\"\""));
0000a040:   movs    r1,#0x3
0000a042:   bl      0x00009f86
 918              if (output == NULL)
0000a046:   cmp     r0,#0x0
0000a048:   beq     0x0000a148
 922              strcpy((char*)output, "\"\"");
0000a04a:   ldr     r1,[pc,#0x104] ; 0xa14c
0000a04c:   bl      0x0000d7bc
 924              return true;
0000a050:   movs    r0,#0x1
0000a052:   b       0x0000a0b6
 930              switch (*input_pointer)
0000a054:   cmp     r3,#0x22
0000a056:   beq     0x0000a05c
0000a058:   cmp     r3,#0x5c
0000a05a:   bne     0x0000a074
 940                      escape_characters++;
0000a05c:   adds    r6,#0x1
 928          for (input_pointer = input; *input_pointer; input_pointer++)
0000a05e:   adds    r2,#0x1
0000a060:   ldrb    r3,[r2]
0000a062:   cbz     r3,0x0000a07c
 930              switch (*input_pointer)
0000a064:   cmp     r3,#0xd
0000a066:   bhi     0x0000a054
0000a068:   cmp     r3,#0xc
0000a06a:   bcs     0x0000a05c
0000a06c:   sub.w   r1,r3,#0x8
0000a070:   cmp     r1,#0x2
0000a072:   bls     0x0000a05c
 943                      if (*input_pointer < 32)
0000a074:   cmp     r3,#0x1f
0000a076:   bhi     0x0000a05e
 946                          escape_characters += 5;
0000a078:   adds    r6,#0x5
0000a07a:   b       0x0000a05e
 951          output_length = (size_t)(input_pointer - input) + escape_characters;
0000a07c:   subs    r2,r2,r5
0000a07e:   adds    r4,r2,r6
 953          output = ensure(output_buffer, output_length + sizeof("\"\""));
0000a080:   adds    r1,r4,#3
0000a082:   bl      0x00009f86
 954          if (output == NULL)
0000a086:   mov     r7,r0
0000a088:   cmp     r0,#0x0
0000a08a:   beq     0x0000a14c
 960          if (escape_characters == 0)
0000a08c:   cbnz    r6,0x0000a0b8
 962              output[0] = '\"';
0000a08e:   movs    r3,#0x22
0000a090:   strb    r3,[r0]
 964              if ((unsigned int) &output[output_length + 1] >= 0x20080000u) {
0000a092:   adds    r6,r4,#1
0000a094:   adds    r2,r0,r6
0000a096:   ldr     r3,[pc,#0xbc] ; 0xa150
0000a098:   cmp     r2,r3
0000a09a:   bls     0x0000a0a0
 871        __ASM volatile ("isb 0xF":::"memory");
0000a09c:   isb     sy
 968              memcpy(output + 1, input, output_length);
0000a0a0:   mov     r2,r4
0000a0a2:   mov     r1,r5
0000a0a4:   adds    r0,r7,#1
0000a0a6:   bl      0x0000cb70
 970              output[output_length + 1] = '\"';
0000a0aa:   movs    r3,#0x22
0000a0ac:   strb    r3,[r7,r6]
 971              output[output_length + 2] = '\0';
0000a0ae:   adds    r4,#0x2
0000a0b0:   movs    r3,#0x0
0000a0b2:   strb    r3,[r7,r4]
 973              return true;
0000a0b4:   movs    r0,#0x1
1025      }
0000a0b6:   pop     {r3,r4,r5,r6,r7,pc}
 976          output[0] = '\"';
0000a0b8:   mov     r6,r0
0000a0ba:   movs    r3,#0x22
0000a0bc:   strb    r3,[r6],#0x1
 979          for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++)
0000a0c0:   b       0x0000a100
 989                  *output_pointer++ = '\\';
0000a0c2:   adds    r0,r6,#1
0000a0c4:   movs    r3,#0x5c
0000a0c6:   strb    r3,[r6]
 990                  switch (*input_pointer)
0000a0c8:   ldrb    r2,[r5]
0000a0ca:   cmp     r2,#0xc
0000a0cc:   beq     0x0000a122
0000a0ce:   bhi     0x0000a0e6
0000a0d0:   cmp     r2,#0x9
0000a0d2:   beq     0x0000a12e
0000a0d4:   cmp     r2,#0xa
0000a0d6:   beq     0x0000a128
0000a0d8:   cmp     r2,#0x8
0000a0da:   beq     0x0000a11c
1015                          sprintf((char*)output_pointer, "u%04x", *input_pointer);
0000a0dc:   ldr     r1,[pc,#0x78] ; 0xa154
0000a0de:   bl      0x0000d670
1016                          output_pointer += 4;
0000a0e2:   adds    r0,r6,#5
1017                          break;
0000a0e4:   b       0x0000a0fc
 990                  switch (*input_pointer)
0000a0e6:   cmp     r2,#0x22
0000a0e8:   beq     0x0000a116
0000a0ea:   cmp     r2,#0x5c
0000a0ec:   beq     0x0000a0f8
0000a0ee:   cmp     r2,#0xd
0000a0f0:   bne     0x0000a0dc
1008                          *output_pointer = 'r';
0000a0f2:   movs    r3,#0x72
0000a0f4:   strb    r3,[r6,#0x1]
1009                          break;
0000a0f6:   b       0x0000a0fc
 993                          *output_pointer = '\\';
0000a0f8:   movs    r3,#0x5c
0000a0fa:   strb    r3,[r6,#0x1]
 979          for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++)
0000a0fc:   adds    r5,#0x1
0000a0fe:   adds    r6,r0,#1
0000a100:   ldrb    r3,[r5]
0000a102:   cbz     r3,0x0000a134
 981              if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\'))
0000a104:   cmp     r3,#0x1f
0000a106:   bls     0x0000a0c2
0000a108:   cmp     r3,#0x22
0000a10a:   beq     0x0000a0c2
0000a10c:   cmp     r3,#0x5c
0000a10e:   beq     0x0000a0c2
 984                  *output_pointer = *input_pointer;
0000a110:   strb    r3,[r6]
0000a112:   mov     r0,r6
0000a114:   b       0x0000a0fc
 996                          *output_pointer = '\"';
0000a116:   movs    r3,#0x22
0000a118:   strb    r3,[r6,#0x1]
 997                          break;
0000a11a:   b       0x0000a0fc
 999                          *output_pointer = 'b';
0000a11c:   movs    r3,#0x62
0000a11e:   strb    r3,[r6,#0x1]
1000                          break;
0000a120:   b       0x0000a0fc
1002                          *output_pointer = 'f';
0000a122:   movs    r3,#0x66
0000a124:   strb    r3,[r6,#0x1]
1003                          break;
0000a126:   b       0x0000a0fc
1005                          *output_pointer = 'n';
0000a128:   movs    r3,#0x6e
0000a12a:   strb    r3,[r6,#0x1]
1006                          break;
0000a12c:   b       0x0000a0fc
1011                          *output_pointer = 't';
0000a12e:   movs    r3,#0x74
0000a130:   strb    r3,[r6,#0x1]
1012                          break;
0000a132:   b       0x0000a0fc
1021          output[output_length + 1] = '\"';
0000a134:   adds    r3,r4,#1
0000a136:   movs    r2,#0x22
0000a138:   strb    r2,[r7,r3]
1022          output[output_length + 2] = '\0';
0000a13a:   adds    r4,#0x2
0000a13c:   movs    r3,#0x0
0000a13e:   strb    r3,[r7,r4]
1024          return true;
0000a140:   movs    r0,#0x1
0000a142:   b       0x0000a0b6
 911              return false;
0000a144:   movs    r0,#0x0
1025      }
0000a146:   bx      lr
 920                  return false;
0000a148:   movs    r0,#0x0
0000a14a:   b       0x0000a0b6
 956              return false;
0000a14c:   movs    r0,#0x0
......... ...
1380          switch ((item->type) & 0xFF)
0000a570:   cmp     r3,#0x2
0000a572:   beq     0x0000a5b2
0000a574:   cmp     r3,#0x4
0000a576:   beq     0x0000a58a
0000a578:   cmp     r3,#0x1
0000a57a:   beq     0x0000a59e
1440                  return false;
0000a57c:   movs    r0,#0x0
0000a57e:   b       0x0000a5de
1380          switch ((item->type) & 0xFF)
0000a580:   cmp     r3,#0x10
0000a582:   bne     0x0000a57c
1431                  return print_string(item, output_buffer);
0000a584:   bl      0x0000a15c
0000a588:   b       0x0000a5de
1383                  output = ensure(output_buffer, 5);
0000a58a:   movs    r1,#0x5
0000a58c:   mov     r0,r4
0000a58e:   bl      0x00009f86
1384                  if (output == NULL)
0000a592:   cbz     r0,0x0000a5a0
1388                  strcpy((char*)output, "null");
0000a594:   ldr     r1,[pc,#0x5c] ; 0xa5f0
0000a596:   bl      0x0000d7bc
1389                  return true;
0000a59a:   movs    r0,#0x1
0000a59c:   b       0x0000a5de
1392                  output = ensure(output_buffer, 6);
0000a59e:   movs    r1,#0x6
0000a5a0:   mov     r0,r4
0000a5a2:   bl      0x00009f86
1393                  if (output == NULL)
0000a5a6:   cbz     r0,0x0000a5e4
1397                  strcpy((char*)output, "false");
0000a5a8:   ldr     r1,[pc,#0x4c] ; 0xa5f4
0000a5aa:   bl      0x0000d7bc
1398                  return true;
0000a5ae:   movs    r0,#0x1
0000a5b0:   b       0x0000a5de
1401                  output = ensure(output_buffer, 5);
0000a5b2:   movs    r1,#0x5
0000a5b4:   mov     r0,r4
0000a5b6:   bl      0x00009f86
1402                  if (output == NULL)
0000a5ba:   cbz     r0,0x0000a5e8
1406                  strcpy((char*)output, "true");
0000a5bc:   ldr     r1,[pc,#0x3c] ; 0xa5f8
0000a5be:   bl      0x0000d7bc
1407                  return true;
0000a5c2:   movs    r0,#0x1
0000a5c4:   b       0x0000a5de
1410                  return print_number(item, output_buffer);
0000a5c6:   bl      0x0000a414
0000a5ca:   b       0x0000a5de
1434                  return print_array(item, output_buffer);
0000a5cc:   bl      0x0000a6a0
0000a5d0:   b       0x0000a5de
1437                  return print_object(item, output_buffer);
0000a5d2:   bl      0x0000a746
0000a5d6:   b       0x0000a5de
1377              return false;
0000a5d8:   movs    r0,#0x0
1442      }
0000a5da:   bx      lr
1377              return false;
0000a5dc:   movs    r0,#0x0
1442      }
0000a5de:   pop     {r4,r5,r6,pc}
1386                      return false;
0000a5e0:   movs    r0,#0x0
0000a5e2:   b       0x0000a5de
1395                      return false;
0000a5e4:   movs    r0,#0x0
0000a5e6:   b       0x0000a5de
1404                      return false;
0000a5e8:   movs    r0,#0x0
0000a5ea:   b       0x0000a5de
1417                      return false;
0000a5ec:   movs    r0,#0x0
0000a5ee:   b       0x0000a5de
1424                      return false;
0000a5f0:   movs    r0,#0x0
0000a5f2:   b       0x0000a5de
0000a5f4:   cmp     r1,#0x44
0000a5f6:   movs    r1,r0
0000a5f8:   asrs    r0,r7,#0x1e
0000a5fa:   movs    r1,r0
0000a5fc:   asrs    r0,r6,#0x1e
0000a5fe:   movs    r1,r0
1192      {
          print:
0000a600:   push    {r4,r5,r6,r7,lr}
0000a602:   sub     sp,sp,#0x2c
0000a604:   mov     r7,r0
0000a606:   mov     r6,r1
0000a608:   mov     r5,r2
1197          memset(buffer, 0, sizeof(buffer));
0000a60a:   movs    r2,#0x24
0000a60c:   movs    r1,#0x0
0000a60e:   add     r0,sp,#0x4
0000a610:   bl      0x0000cb86
1200          buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size);
0000a614:   ldr     r3,[r5]
0000a616:   mov.w   r0,#0x100
0000a61a:   blx     r3
0000a61c:   mov     r4,r0
0000a61e:   str     r0,[sp,#0x4]
1201          buffer->length = default_buffer_size;
0000a620:   mov.w   r3,#0x100
0000a624:   str     r3,[sp,#0x8]
1202          buffer->format = format;
0000a626:   str     r6,[sp,#0x18]
1203          buffer->hooks = *hooks;
0000a628:   ldm.w   r5,{r0,r1,r2}
0000a62c:   add     r3,sp,#0x28
0000a62e:   stmdb   r3,{r0,r1,r2}
1204          if (buffer->buffer == NULL)
0000a632:   cbz     r4,0x0000a640
1210          if (!print_value(item, buffer))
0000a634:   add     r1,sp,#0x4
0000a636:   mov     r0,r7
0000a638:   bl      0x0000a528
0000a63c:   cbnz    r0,0x0000a658
1195          unsigned char *printed = NULL;
0000a63e:   movs    r4,#0x0
1242          if (buffer->buffer != NULL)
0000a640:   ldr     r0,[sp,#0x4]
0000a642:   cbz     r0,0x0000a648
1244              hooks->deallocate(buffer->buffer);
0000a644:   ldr     r3,[r5,#0x4]
0000a646:   blx     r3
1247          if (printed != NULL)
0000a648:   cbz     r4,0x0000a652
1249              hooks->deallocate(printed);
0000a64a:   ldr     r3,[r5,#0x4]
0000a64c:   mov     r0,r4
0000a64e:   blx     r3
1252          return NULL;
0000a650:   movs    r4,#0x0
1253      }
0000a652:   mov     r0,r4
0000a654:   add     sp,sp,#0x2c
0000a656:   pop     {r4,r5,r6,r7,pc}
1214          update_offset(buffer);
0000a658:   add     r0,sp,#0x4
0000a65a:   bl      0x00009ed4
1217          if (hooks->reallocate != NULL)
0000a65e:   ldr     r3,[r5,#0x8]
0000a660:   cbz     r3,0x0000a672
1219              printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1);
0000a662:   ldr     r1,[sp,#0xc]
0000a664:   adds    r1,#0x1
0000a666:   ldr     r0,[sp,#0x4]
0000a668:   blx     r3
1220              if (printed == NULL) {
0000a66a:   mov     r4,r0
0000a66c:   cmp     r0,#0x0
0000a66e:   bne     0x0000a652
0000a670:   b       0x0000a640
1227              printed = (unsigned char*) hooks->allocate(buffer->offset + 1);
0000a672:   ldr     r3,[r5]
0000a674:   ldr     r0,[sp,#0xc]
0000a676:   adds    r0,#0x1
0000a678:   blx     r3
1228              if (printed == NULL)
0000a67a:   mov     r4,r0
0000a67c:   cmp     r0,#0x0
0000a67e:   beq     0x0000a640
1232              memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1));
0000a680:   ldr     r2,[sp,#0xc]
0000a682:   adds    r2,#0x1
0000a684:   ldr     r3,[sp,#0x8]
0000a686:   cmp     r2,r3
0000a688:   it      cs
0000a68a:   mov     r2,r3
0000a68c:   ldr     r1,[sp,#0x4]
0000a68e:   bl      0x0000cb70
1233              printed[buffer->offset] = '\0'; /* just to be sure */
0000a692:   ldr     r3,[sp,#0xc]
0000a694:   movs    r2,#0x0
0000a696:   strb    r2,[r4,r3]
1236              hooks->deallocate(buffer->buffer);
0000a698:   ldr     r3,[r5,#0x4]
......... ...
1741              *output_pointer++ = '\n';
0000a774:   movs    r3,#0xa
0000a776:   strb    r3,[r0,#0x1]
1743          output_buffer->offset += length;
0000a778:   ldr     r3,[r4,#0x8]
0000a77a:   add     r3,r6
0000a77c:   str     r3,[r4,#0x8]
1745          while (current_item)
0000a77e:   b       0x0000a7ca
1730          length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */
0000a780:   movs    r6,#0x1
0000a782:   b       0x0000a758
1750                  output_pointer = ensure(output_buffer, output_buffer->depth);
0000a784:   ldr     r1,[r4,#0xc]
0000a786:   mov     r0,r4
0000a788:   bl      0x00009f86
1751                  if (output_pointer == NULL)
0000a78c:   mov     r2,r0
0000a78e:   cmp     r0,#0x0
0000a790:   beq.w   0x0000a8a6
1755                  for (i = 0; i < output_buffer->depth; i++)
0000a794:   movs    r3,#0x0
0000a796:   b       0x0000a7a0
1757                      *output_pointer++ = '\t';
0000a798:   movs    r1,#0x9
0000a79a:   strb    r1,[r2]
1755                  for (i = 0; i < output_buffer->depth; i++)
0000a79c:   adds    r3,#0x1
1757                      *output_pointer++ = '\t';
0000a79e:   adds    r2,#0x1
1755                  for (i = 0; i < output_buffer->depth; i++)
0000a7a0:   ldr     r1,[r4,#0xc]
0000a7a2:   cmp     r1,r3
0000a7a4:   bhi     0x0000a798
1759                  output_buffer->offset += output_buffer->depth;
0000a7a6:   ldr     r3,[r4,#0x8]
0000a7a8:   add     r1,r3
0000a7aa:   str     r1,[r4,#0x8]
0000a7ac:   b       0x0000a7d4
1769              length = (size_t) (output_buffer->format ? 2 : 1);
0000a7ae:   movs    r6,#0x1
0000a7b0:   b       0x0000a7f0
1790              length = ((size_t)(output_buffer->format ? 1 : 0) + (size_t)(current_item->next ? 1 : 0));
0000a7b2:   movs    r6,#0x0
0000a7b4:   b       0x0000a82a
0000a7b6:   movs    r3,#0x0
0000a7b8:   b       0x0000a832
1791              output_pointer = ensure(output_buffer, length + 1);
0000a7ba:   mov     r3,r0
0000a7bc:   b       0x0000a84c
1805              *output_pointer = '\0';
0000a7be:   movs    r2,#0x0
0000a7c0:   strb    r2,[r3]
1806              output_buffer->offset += length;
0000a7c2:   ldr     r3,[r4,#0x8]
0000a7c4:   add     r6,r3
0000a7c6:   str     r6,[r4,#0x8]
1808              current_item = current_item->next;
0000a7c8:   ldr     r5,[r5]
1745          while (current_item)
0000a7ca:   cmp     r5,#0x0
0000a7cc:   beq     0x0000a85a
1747              if (output_buffer->format)
0000a7ce:   ldr     r3,[r4,#0x14]
0000a7d0:   cmp     r3,#0x0
0000a7d2:   bne     0x0000a784
1763              if (!print_string_ptr((unsigned char*)current_item->string, output_buffer))
0000a7d4:   mov     r1,r4
0000a7d6:   ldr     r0,[r5,#0x20]
0000a7d8:   bl      0x0000a02c
0000a7dc:   mov     r3,r0
0000a7de:   cmp     r0,#0x0
0000a7e0:   beq     0x0000a89e
1767              update_offset(output_buffer);
0000a7e2:   mov     r0,r4
0000a7e4:   bl      0x00009ed4
0000a7e8:   ldr     r3,[r4,#0x14]
0000a7ea:   cmp     r3,#0x0
0000a7ec:   beq     0x0000a7ae
0000a7ee:   movs    r6,#0x2
1770              output_pointer = ensure(output_buffer, length);
0000a7f0:   mov     r1,r6
0000a7f2:   mov     r0,r4
0000a7f4:   bl      0x00009f86
1771              if (output_pointer == NULL)
0000a7f8:   cmp     r0,#0x0
0000a7fa:   beq     0x0000a8aa
1775              *output_pointer++ = ':';
0000a7fc:   movs    r2,#0x3a
0000a7fe:   strb    r2,[r0]
1776              if (output_buffer->format)
0000a800:   ldr     r2,[r4,#0x14]
0000a802:   cbz     r2,0x0000a808
1778                  *output_pointer++ = '\t';
0000a804:   movs    r2,#0x9
0000a806:   strb    r2,[r0,#0x1]
1780              output_buffer->offset += length;
0000a808:   ldr     r1,[r4,#0x8]
0000a80a:   add     r1,r6
0000a80c:   str     r1,[r4,#0x8]
1783              if (!print_value(current_item, output_buffer))
0000a80e:   mov     r1,r4
0000a810:   mov     r0,r5
0000a812:   bl      0x0000a528
0000a816:   mov     r3,r0
0000a818:   cmp     r0,#0x0
0000a81a:   beq     0x0000a89e
1787              update_offset(output_buffer);
0000a81c:   mov     r0,r4
0000a81e:   bl      0x00009ed4
0000a822:   ldr     r3,[r4,#0x14]
0000a824:   cmp     r3,#0x0
0000a826:   beq     0x0000a7b2
0000a828:   movs    r6,#0x1
0000a82a:   ldr     r3,[r5]
0000a82c:   cmp     r3,#0x0
0000a82e:   beq     0x0000a7b6
0000a830:   movs    r3,#0x1
0000a832:   add     r6,r3
0000a834:   adds    r1,r6,#1
0000a836:   mov     r0,r4
......... ...
1134              if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0')
0000adb0:   ldr     r3,[sp,#0x14]
0000adb2:   ldr     r2,[sp,#0x10]
0000adb4:   cmp     r3,r2
0000adb6:   bcs     0x0000adc0
0000adb8:   ldr     r2,[sp,#0xc]
0000adba:   ldrb    r3,[r2,r3]
0000adbc:   cmp     r3,#0x0
0000adbe:   beq     0x0000ad9c
1147          if (item != NULL)
0000adc0:   cmp     r5,#0x0
0000adc2:   beq     0x0000ad3c
1149              cJSON_Delete(item);
0000adc4:   mov     r0,r5
0000adc6:   bl      0x0000a998
0000adca:   b       0x0000ad3c
1162              else if (buffer.length > 0)
0000adcc:   cmp     r3,#0x0
0000adce:   beq     0x0000ad50
1164                  local_error.position = buffer.length - 1;
0000add0:   subs    r3,#0x1
0000add2:   str     r3,[sp,#0x8]
0000add4:   b       0x0000ad50
1175          return NULL;
0000add6:   movs    r5,#0x0
0000add8:   b       0x0000ad66
0000adda:   nop
0000addc:   lsrs    r0,r3,#11
0000adde:   movs    r0,#0x0
0000ade0:   lsls    r0,r3,#14
0000ade2:   movs    r0,#0x0
1087          if (NULL == value)
          cJSON_ParseWithOpts:
0000ade4:   cbz     r0,0x0000ae00
1084      {
0000ade6:   push    {r4,r5,r6,lr}
0000ade8:   mov     r4,r0
0000adea:   mov     r6,r2
0000adec:   mov     r5,r1
1093          buffer_length = strlen(value) + sizeof("");
0000adee:   bl      0x0000d7f6
1095          return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated);
0000adf2:   mov     r3,r6
0000adf4:   mov     r2,r5
0000adf6:   adds    r1,r0,#1
0000adf8:   mov     r0,r4
0000adfa:   bl      0x0000ad20
1096      }
0000adfe:   pop     {r4,r5,r6,pc}
1089              return NULL;
0000ae00:   movs    r0,#0x0
1096      }
0000ae02:   bx      lr
1180      {
          cJSON_Parse:
0000ae04:   push    {r3,lr}
1181          return cJSON_ParseWithOpts(value, 0, 0);
0000ae06:   movs    r2,#0x0
0000ae08:   mov     r1,r2
0000ae0a:   bl      0x0000ade4
1182      }
0000ae0e:   pop     {r3,pc}
1262      {
          cJSON_PrintUnformatted:
0000ae10:   push    {r3,lr}
1263          return (char*)print(item, false, &global_hooks);
0000ae12:   ldr     r2,[pc,#0x8] ; 0xae18
0000ae14:   movs    r1,#0x0
0000ae16:   bl      0x0000a600
1264      }
0000ae1a:   pop     {r3,pc}
0000ae1c:   lsls    r0,r3,#14
0000ae1e:   movs    r0,#0x0
1876          if (index < 0)
          cJSON_GetArrayItem:
0000ae20:   cmp     r1,#0x0
0000ae22:   blt     0x0000ae2c
1875      {
0000ae24:   push    {r3,lr}
1881          return get_array_item(array, (size_t)index);
0000ae26:   bl      0x00009e78
1882      }
0000ae2a:   pop     {r3,pc}
1878              return NULL;
0000ae2c:   movs    r0,#0x0
1882      }
0000ae2e:   bx      lr
1917      {
          cJSON_GetObjectItem:
0000ae30:   push    {r3,lr}
1918          return get_object_item(object, string, false);
0000ae32:   movs    r2,#0x0
0000ae34:   bl      0x0000a940
1919      }
0000ae38:   pop     {r3,pc}
1995      {
          cJSON_AddItemToArray:
0000ae3a:   push    {r3,lr}
1996          return add_item_to_array(array, item);
0000ae3c:   bl      0x00009e94
1997      }
0000ae40:   pop     {r3,pc}
0000ae42:   movs    r0,r0
2053      {
          cJSON_AddItemToObject:
0000ae44:   push    {lr}
0000ae46:   sub     sp,sp,#0xc
2054          return add_item_to_object(object, string, item, &global_hooks, false);
0000ae48:   movs    r3,#0x0
0000ae4a:   str     r3,[sp,#0x0]
0000ae4c:   ldr     r3,[pc,#0x8] ; 0xae54
0000ae4e:   bl      0x00009f18
2055      }
0000ae52:   add     sp,sp,#0xc
0000ae54:   pop.w   {pc}
0000ae58:   lsls    r0,r3,#14
0000ae5a:   movs    r0,#0x0
2418      {
          cJSON_CreateBool:
0000ae5c:   push    {r4,lr}
0000ae5e:   mov     r4,r0
2419          cJSON *item = cJSON_New_Item(&global_hooks);
0000ae60:   ldr     r0,[pc,#0x14] ; 0xae74
0000ae62:   bl      0x0000a166
2420          if(item)
0000ae66:   mov     r3,r0
0000ae68:   cbz     r0,0x0000ae70
2422              item->type = boolean ? cJSON_True : cJSON_False;
0000ae6a:   cbz     r4,0x0000ae74
0000ae6c:   movs    r2,#0x2
0000ae6e:   str     r2,[r3,#0xc]
2426      }
0000ae70:   mov     r0,r3
0000ae72:   pop     {r4,pc}
2422              item->type = boolean ? cJSON_True : cJSON_False;
0000ae74:   movs    r2,#0x1
0000ae76:   b       0x0000ae6e
......... ...

Share this post

Link to post

Share on other sites

jcxz 4

Posted April 20, 2021 · Report post

18 часов назад, kreker сказал:

Если не трудно - подскажите как это правильно делается.

Как все делают - в начале программы заполнить удобным паттерном (константой), а в подозрительном месте - проверить уровень использования.

4 часа назад, kreker сказал:

По брекпойнту сразу срабатывает.

И где он у вас "срабатывает"? Куда бряк поставили?? На "if" что-ль? :wacko2:

Вы сами понимаете что делаете? Складывается ощущение - совершенно не понимаете.

Бряк нужно ставить на __ISB().

19.04.2021 в 10:17, jcxz сказал:

и поставить бряк на __ISB().

А это что за мусор и зачем сюда запихали?:

Цитата

Скрыть содержимое


00001088:   lsrs    r3,r0,#16
0000108a:   movs    r0,r0
0000108c:   lsrs    r1,r6,#17
0000108e:   movs    r0,r0
00001090:   lsrs    r1,r1,#18
00001092:   movs    r0,r0
00001094:   lsrs    r1,r4,#18
00001096:   movs    r0,r0
00001098:   lsrs    r1,r7,#18
0000109a:   movs    r0,r0
0000109c:   lsrs    r1,r2,#19
0000109e:   movs    r0,r0
...

Share this post

Link to post

Share on other sites

kreker 0

Posted April 20, 2021 · Report post

2 hours ago, jcxz said:

А это что за мусор и зачем сюда запихали?

Это часть функции packer(), видимо появилась, когда переходил по элементам в окне Debug.

2 hours ago, jcxz said:

Бряк нужно ставить на __ISB().

Да понял я, понял. Только вот когда ставлю брэкйпойнт на __ISB() при выполнении кода он упорно перезжает строчкой выше - на if().

2 hours ago, jcxz said:

И где он у вас "срабатывает"?

Уже нигде. :crazy:

Вместо __ISB() поставил __BKPT(0) - вроде как это программный брэкпойнт и выполнение кода дложно остановиться при заходе в условие, прямо на этой строчке. Даже без выставления брэкпойнта вручную.

Но в условие не зашло, вместо этого теперь Hardfault выкидывает чутка в другом месте этой же либы...

Пытаюсь повторить ошибку...

Share this post

Link to post

Share on other sites

kreker 0

Posted April 20, 2021 (edited) · Report post

Упорно не желает повторяться.

HardFault:
SCB->CFSR   0x00008200
SCB->HFSR   0x40000000
SCB->MMFAR  0x20080038
SCB->BFAR   0x20080038

SP          0x2007fe70
R0          0x20080038
R1          0x20002168
R2          0x20000aec
R3          0x20080039
R12         0x2007fe63
LR          0x0000d5f9
PC          0x0000ccdc
PSR         0x61000000


[HardFault]
SP        = 2007fe70
R0        = 20080038
R1        = 20002168
R2        = 20000aec
R3        = 20080039
R12       = 2007fe63
LR [R14]  = 0000d5f9 - Subroutine Call return address
PC [R15]  = 0000ccdc - Program Counter
PSR       = 61000000
BFAR      = 20080038 - Bus Fault SR/Address causing bus fault
CFSR      = 00008200 - Config. Fault SR
HFSR      = 40000000 - Hard Fault SR
  :FORCED, Bus fault/Memory management fault/usage fault
DFSR      = 00000000 - Debug Fault SR
MMAR      = 20080038 - Memory Manage Address R
AFSR      = 00000000 - Auxilirary Fault SR
SCB->SHCSR= 00000000 - System Handler Control and State R (exception)

Лог дизассемблера.

Spoiler

......... ...
1432                  return print_string(item, output_buffer);
0000a584:   bl      0x0000a15c
0000a588:   b       0x0000a5de
1384                  output = ensure(output_buffer, 5);
0000a58a:   movs    r1,#0x5
0000a58c:   mov     r0,r4
0000a58e:   bl      0x00009f86
1385                  if (output == NULL)
0000a592:   cbz     r0,0x0000a5a0
1389                  strcpy((char*)output, "null");
0000a594:   ldr     r1,[pc,#0x5c] ; 0xa5f0
0000a596:   bl      0x0000d7bc
1390                  return true;
0000a59a:   movs    r0,#0x1
0000a59c:   b       0x0000a5de
1393                  output = ensure(output_buffer, 6);
0000a59e:   movs    r1,#0x6
0000a5a0:   mov     r0,r4
0000a5a2:   bl      0x00009f86
1394                  if (output == NULL)
0000a5a6:   cbz     r0,0x0000a5e4
1398                  strcpy((char*)output, "false");
0000a5a8:   ldr     r1,[pc,#0x4c] ; 0xa5f4
0000a5aa:   bl      0x0000d7bc
1399                  return true;
0000a5ae:   movs    r0,#0x1
0000a5b0:   b       0x0000a5de
1402                  output = ensure(output_buffer, 5);
0000a5b2:   movs    r1,#0x5
0000a5b4:   mov     r0,r4
0000a5b6:   bl      0x00009f86
1403                  if (output == NULL)
0000a5ba:   cbz     r0,0x0000a5e8
1407                  strcpy((char*)output, "true");
0000a5bc:   ldr     r1,[pc,#0x3c] ; 0xa5f8
0000a5be:   bl      0x0000d7bc
1408                  return true;
0000a5c2:   movs    r0,#0x1
0000a5c4:   b       0x0000a5de
1411                  return print_number(item, output_buffer);
0000a5c6:   bl      0x0000a414
0000a5ca:   b       0x0000a5de
1435                  return print_array(item, output_buffer);
0000a5cc:   bl      0x0000a6a0
0000a5d0:   b       0x0000a5de
1438                  return print_object(item, output_buffer);
0000a5d2:   bl      0x0000a746
0000a5d6:   b       0x0000a5de
1378              return false;
0000a5d8:   movs    r0,#0x0
1443      }
0000a5da:   bx      lr
1378              return false;
0000a5dc:   movs    r0,#0x0
1443      }
0000a5de:   pop     {r4,r5,r6,pc}
1387                      return false;
0000a5e0:   movs    r0,#0x0
0000a5e2:   b       0x0000a5de
1396                      return false;
0000a5e4:   movs    r0,#0x0
0000a5e6:   b       0x0000a5de
1405                      return false;
0000a5e8:   movs    r0,#0x0
0000a5ea:   b       0x0000a5de
1418                      return false;
0000a5ec:   movs    r0,#0x0
0000a5ee:   b       0x0000a5de
1425                      return false;
0000a5f0:   movs    r0,#0x0
0000a5f2:   b       0x0000a5de
0000a5f4:   cmp     r1,#0x44
0000a5f6:   movs    r1,r0
0000a5f8:   asrs    r0,r7,#0x1e
0000a5fa:   movs    r1,r0
0000a5fc:   asrs    r0,r6,#0x1e
0000a5fe:   movs    r1,r0
1193      {
          print:
0000a600:   push    {r4,r5,r6,r7,lr}
0000a602:   sub     sp,sp,#0x2c
0000a604:   mov     r7,r0
0000a606:   mov     r6,r1
0000a608:   mov     r5,r2
1198          memset(buffer, 0, sizeof(buffer));
0000a60a:   movs    r2,#0x24
0000a60c:   movs    r1,#0x0
0000a60e:   add     r0,sp,#0x4
0000a610:   bl      0x0000cb86
1201          buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size);
0000a614:   ldr     r3,[r5]
0000a616:   mov.w   r0,#0x100
0000a61a:   blx     r3
0000a61c:   mov     r4,r0
0000a61e:   str     r0,[sp,#0x4]
1202          buffer->length = default_buffer_size;
0000a620:   mov.w   r3,#0x100
0000a624:   str     r3,[sp,#0x8]
1203          buffer->format = format;
0000a626:   str     r6,[sp,#0x18]
1204          buffer->hooks = *hooks;
0000a628:   ldm.w   r5,{r0,r1,r2}
0000a62c:   add     r3,sp,#0x28
0000a62e:   stmdb   r3,{r0,r1,r2}
1205          if (buffer->buffer == NULL)
0000a632:   cbz     r4,0x0000a640
1211          if (!print_value(item, buffer))
0000a634:   add     r1,sp,#0x4
0000a636:   mov     r0,r7
0000a638:   bl      0x0000a528
0000a63c:   cbnz    r0,0x0000a658
1196          unsigned char *printed = NULL;
0000a63e:   movs    r4,#0x0
1243          if (buffer->buffer != NULL)
0000a640:   ldr     r0,[sp,#0x4]
0000a642:   cbz     r0,0x0000a648
1245              hooks->deallocate(buffer->buffer);
0000a644:   ldr     r3,[r5,#0x4]
0000a646:   blx     r3
1248          if (printed != NULL)
0000a648:   cbz     r4,0x0000a652
1250              hooks->deallocate(printed);
0000a64a:   ldr     r3,[r5,#0x4]
0000a64c:   mov     r0,r4
0000a64e:   blx     r3
1253          return NULL;
0000a650:   movs    r4,#0x0
1254      }
0000a652:   mov     r0,r4
0000a654:   add     sp,sp,#0x2c
0000a656:   pop     {r4,r5,r6,r7,pc}
1215          update_offset(buffer);
0000a658:   add     r0,sp,#0x4
0000a65a:   bl      0x00009ed4
1218          if (hooks->reallocate != NULL)
0000a65e:   ldr     r3,[r5,#0x8]
0000a660:   cbz     r3,0x0000a672
1220              printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1);
0000a662:   ldr     r1,[sp,#0xc]
0000a664:   adds    r1,#0x1
0000a666:   ldr     r0,[sp,#0x4]
0000a668:   blx     r3
1221              if (printed == NULL) {
0000a66a:   mov     r4,r0
0000a66c:   cmp     r0,#0x0
0000a66e:   bne     0x0000a652
0000a670:   b       0x0000a640
1228              printed = (unsigned char*) hooks->allocate(buffer->offset + 1);
0000a672:   ldr     r3,[r5]
0000a674:   ldr     r0,[sp,#0xc]
0000a676:   adds    r0,#0x1
0000a678:   blx     r3
1229              if (printed == NULL)
0000a67a:   mov     r4,r0
0000a67c:   cmp     r0,#0x0
0000a67e:   beq     0x0000a640
1233              memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1));
0000a680:   ldr     r2,[sp,#0xc]
0000a682:   adds    r2,#0x1
0000a684:   ldr     r3,[sp,#0x8]
0000a686:   cmp     r2,r3
0000a688:   it      cs
0000a68a:   mov     r2,r3
0000a68c:   ldr     r1,[sp,#0x4]
0000a68e:   bl      0x0000cb70
1234              printed[buffer->offset] = '\0'; /* just to be sure */
0000a692:   ldr     r3,[sp,#0xc]
0000a694:   movs    r2,#0x0
0000a696:   strb    r2,[r4,r3]
1237              hooks->deallocate(buffer->buffer);
0000a698:   ldr     r3,[r5,#0x4]
0000a69a:   ldr     r0,[sp,#0x4]
0000a69c:   blx     r3
0000a69e:   b       0x0000a652
1545      {
          print_array:
0000a6a0:   push    {r4,r5,r6,lr}
1548          cJSON *current_element = item->child;
0000a6a2:   ldr     r5,[r0,#0x8]
1550          if (output_buffer == NULL)
0000a6a4:   cmp     r1,#0x0
0000a6a6:   beq     0x0000a734
......... ...
1085      {
0000ade6:   push    {r4,r5,r6,lr}
0000ade8:   mov     r4,r0
0000adea:   mov     r6,r2
0000adec:   mov     r5,r1
1094          buffer_length = strlen(value) + sizeof("");
0000adee:   bl      0x0000d7f6
1096          return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated);
0000adf2:   mov     r3,r6
0000adf4:   mov     r2,r5
0000adf6:   adds    r1,r0,#1
0000adf8:   mov     r0,r4
0000adfa:   bl      0x0000ad20
1097      }
0000adfe:   pop     {r4,r5,r6,pc}
1090              return NULL;
0000ae00:   movs    r0,#0x0
1097      }
0000ae02:   bx      lr
1181      {
          cJSON_Parse:
0000ae04:   push    {r3,lr}
1182          return cJSON_ParseWithOpts(value, 0, 0);
0000ae06:   movs    r2,#0x0
0000ae08:   mov     r1,r2
0000ae0a:   bl      0x0000ade4
1183      }
0000ae0e:   pop     {r3,pc}
1263      {
          cJSON_PrintUnformatted:
0000ae10:   push    {r3,lr}
1264          return (char*)print(item, false, &global_hooks);
0000ae12:   ldr     r2,[pc,#0x8] ; 0xae18
0000ae14:   movs    r1,#0x0
0000ae16:   bl      0x0000a600
1265      }
0000ae1a:   pop     {r3,pc}
0000ae1c:   lsls    r0,r3,#14
0000ae1e:   movs    r0,#0x0
1877          if (index < 0)
          cJSON_GetArrayItem:
0000ae20:   cmp     r1,#0x0
0000ae22:   blt     0x0000ae2c
1876      {
0000ae24:   push    {r3,lr}
1882          return get_array_item(array, (size_t)index);
0000ae26:   bl      0x00009e78
1883      }
0000ae2a:   pop     {r3,pc}
1879              return NULL;
0000ae2c:   movs    r0,#0x0
1883      }
0000ae2e:   bx      lr
1918      {
          cJSON_GetObjectItem:
0000ae30:   push    {r3,lr}
1919          return get_object_item(object, string, false);
0000ae32:   movs    r2,#0x0
0000ae34:   bl      0x0000a940
1920      }
0000ae38:   pop     {r3,pc}
1996      {
          cJSON_AddItemToArray:
0000ae3a:   push    {r3,lr}
1997          return add_item_to_array(array, item);
0000ae3c:   bl      0x00009e94
1998      }
0000ae40:   pop     {r3,pc}
0000ae42:   movs    r0,r0
2054      {
          cJSON_AddItemToObject:
0000ae44:   push    {lr}
0000ae46:   sub     sp,sp,#0xc
2055          return add_item_to_object(object, string, item, &global_hooks, false);
0000ae48:   movs    r3,#0x0
0000ae4a:   str     r3,[sp,#0x0]
0000ae4c:   ldr     r3,[pc,#0x8] ; 0xae54
0000ae4e:   bl      0x00009f18
2056      }
0000ae52:   add     sp,sp,#0xc
0000ae54:   pop.w   {pc}
0000ae58:   lsls    r0,r3,#14
0000ae5a:   movs    r0,#0x0
2419      {
          cJSON_CreateBool:
0000ae5c:   push    {r4,lr}
0000ae5e:   mov     r4,r0
2420          cJSON *item = cJSON_New_Item(&global_hooks);
0000ae60:   ldr     r0,[pc,#0x14] ; 0xae74
0000ae62:   bl      0x0000a166
2421          if(item)
0000ae66:   mov     r3,r0
0000ae68:   cbz     r0,0x0000ae70
2423              item->type = boolean ? cJSON_True : cJSON_False;
0000ae6a:   cbz     r4,0x0000ae74
0000ae6c:   movs    r2,#0x2
0000ae6e:   str     r2,[r3,#0xc]
2427      }
0000ae70:   mov     r0,r3
0000ae72:   pop     {r4,pc}
0000ae74:   movs    r2,#0x1
0000ae76:   b       0x0000ae6e
0000ae78:   lsls    r0,r3,#14
0000ae7a:   movs    r0,#0x0
2121      {
          cJSON_AddBoolToObject:
0000ae7c:   push    {r4,r5,r6,lr}
0000ae7e:   sub     sp,sp,#0x8
0000ae80:   mov     r5,r0
0000ae82:   mov     r6,r1
2122          cJSON *bool_item = cJSON_CreateBool(boolean);
0000ae84:   mov     r0,r2
0000ae86:   bl      0x0000ae5c
0000ae8a:   mov     r4,r0
2123          if (add_item_to_object(object, name, bool_item, &global_hooks, false))
0000ae8c:   movs    r3,#0x0
0000ae8e:   str     r3,[sp,#0x0]
0000ae90:   ldr     r3,[pc,#0x1c] ; 0xaeac
0000ae92:   mov     r2,r0
0000ae94:   mov     r1,r6
0000ae96:   mov     r0,r5
0000ae98:   bl      0x00009f18
0000ae9c:   cbz     r0,0x0000aea4
2130      }
0000ae9e:   mov     r0,r4
0000aea0:   add     sp,sp,#0x8
0000aea2:   pop     {r4,r5,r6,pc}
2128          cJSON_Delete(bool_item);
0000aea4:   mov     r0,r4
0000aea6:   bl      0x0000a998
2129          return NULL;
0000aeaa:   movs    r4,#0x0
0000aeac:   b       0x0000ae9e
0000aeae:   nop
0000aeb0:   lsls    r0,r3,#14
0000aeb2:   movs    r0,#0x0
0000aeb4:   movs    r0,r0
0000aeb6:   movs    r0,r0
2430      {
          cJSON_CreateNumber:
0000aeb8:   push    {r4,r6,r7,lr}
0000aeba:   mov     r6,r0
0000aebc:   mov     r7,r1
2431          cJSON *item = cJSON_New_Item(&global_hooks);
0000aebe:   ldr     r0,[pc,#0x58] ; 0xaf14
0000aec0:   bl      0x0000a166
2432          if(item)
0000aec4:   mov     r4,r0
0000aec6:   cbz     r0,0x0000af00
2434              item->type = cJSON_Number;
0000aec8:   movs    r3,#0x8
0000aeca:   str     r3,[r0,#0xc]
2435              item->valuedouble = num;
0000aecc:   strd    r6,r7,[r0,#0x18]
2438              if (num >= INT_MAX)
0000aed0:   add     r3,pc,#0x3c
0000aed2:   ldrd    r2,r3,[r3]
0000aed6:   mov     r0,r6
0000aed8:   mov     r1,r7
0000aeda:   bl      0x0000c3ac
0000aede:   cbnz    r0,0x0000aefa
2442              else if (num <= (double)INT_MIN)
0000aee0:   movs    r2,#0x0
0000aee2:   ldr     r3,[pc,#0x38] ; 0xaf18
0000aee4:   mov     r0,r6
0000aee6:   mov     r1,r7
0000aee8:   bl      0x0000c398
0000aeec:   cbnz    r0,0x0000af04
2448                  item->valueint = (int)num;
0000aeee:   mov     r0,r6
0000aef0:   mov     r1,r7
0000aef2:   bl      0x0000c400
0000aef6:   str     r0,[r4,#0x14]
2452          return item;
0000aef8:   b       0x0000af00
2440                  item->valueint = INT_MAX;
0000aefa:   mvn     r3,#0x80000000
0000aefe:   str     r3,[r4,#0x14]
2453      }
0000af00:   mov     r0,r4
0000af02:   pop     {r4,r6,r7,pc}
2444                  item->valueint = INT_MIN;
0000af04:   mov.w   r3,#0x80000000
0000af08:   str     r3,[r4,#0x14]
0000af0a:   b       0x0000af00
0000af0c:   nop.w
0000af10:   movs    r0,r0
0000af12:   invalid opcode
0000af16:   rors    r7,r3
0000af18:   lsls    r0,r3,#14
0000af1a:   movs    r0,#0x0
0000af1c:   movs    r0,r0
0000af1e:   stm     r1!,{r5,r6,r7}
2133      {
          cJSON_AddNumberToObject:
0000af20:   push    {r4,r5,r6,lr}
0000af22:   sub     sp,sp,#0x8
0000af24:   mov     r5,r0
0000af26:   mov     r6,r1
2134          cJSON *number_item = cJSON_CreateNumber(number);
0000af28:   mov     r0,r2
0000af2a:   mov     r1,r3
0000af2c:   bl      0x0000aeb8
0000af30:   mov     r4,r0
2135          if (add_item_to_object(object, name, number_item, &global_hooks, false))
0000af32:   movs    r3,#0x0
0000af34:   str     r3,[sp,#0x0]
0000af36:   ldr     r3,[pc,#0x1c] ; 0xaf50
0000af38:   mov     r2,r0
0000af3a:   mov     r1,r6
0000af3c:   mov     r0,r5
0000af3e:   bl      0x00009f18
0000af42:   cbz     r0,0x0000af4a
2142      }
0000af44:   mov     r0,r4
0000af46:   add     sp,sp,#0x8
0000af48:   pop     {r4,r5,r6,pc}
2140          cJSON_Delete(number_item);
0000af4a:   mov     r0,r4
0000af4c:   bl      0x0000a998
2141          return NULL;
0000af50:   movs    r4,#0x0
0000af52:   b       0x0000af44
0000af54:   lsls    r0,r3,#14
0000af56:   movs    r0,#0x0
2456      {
          cJSON_CreateString:
0000af58:   push    {r3,r4,r5,lr}
0000af5a:   mov     r5,r0
2457          cJSON *item = cJSON_New_Item(&global_hooks);
0000af5c:   ldr     r0,[pc,#0x24] ; 0xaf80
0000af5e:   bl      0x0000a166
2458          if(item)
0000af62:   mov     r4,r0
0000af64:   cbz     r0,0x0000af76
2460              item->type = cJSON_String;
0000af66:   movs    r3,#0x10
0000af68:   str     r3,[r0,#0xc]
2461              item->valuestring = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks);
0000af6a:   ldr     r1,[pc,#0x18] ; 0xaf80
0000af6c:   mov     r0,r5
0000af6e:   bl      0x00009ef0
0000af72:   str     r0,[r4,#0x10]
2462              if(!item->valuestring)
0000af74:   cbz     r0,0x0000af7a
2470      }
0000af76:   mov     r0,r4
0000af78:   pop     {r3,r4,r5,pc}
2464                  cJSON_Delete(item);
0000af7a:   mov     r0,r4
0000af7c:   bl      0x0000a998
2465                  return NULL;
0000af80:   movs    r4,#0x0
0000af82:   b       0x0000af76
0000af84:   lsls    r0,r3,#14
0000af86:   movs    r0,#0x0
2145      {
          cJSON_AddStringToObject:
0000af88:   push    {r4,r5,r6,lr}
0000af8a:   sub     sp,sp,#0x8
0000af8c:   mov     r5,r0
0000af8e:   mov     r6,r1
2146          cJSON *string_item = cJSON_CreateString(string);
0000af90:   mov     r0,r2
0000af92:   bl      0x0000af58
0000af96:   mov     r4,r0
2147          if (add_item_to_object(object, name, string_item, &global_hooks, false))
0000af98:   movs    r3,#0x0
0000af9a:   str     r3,[sp,#0x0]
0000af9c:   ldr     r3,[pc,#0x1c] ; 0xafb8
0000af9e:   mov     r2,r0
0000afa0:   mov     r1,r6
0000afa2:   mov     r0,r5
0000afa4:   bl      0x00009f18
0000afa8:   cbz     r0,0x0000afb0
2154      }
0000afaa:   mov     r0,r4
0000afac:   add     sp,sp,#0x8
0000afae:   pop     {r4,r5,r6,pc}
2152          cJSON_Delete(string_item);
0000afb0:   mov     r0,r4
0000afb2:   bl      0x0000a998
2153          return NULL;
0000afb6:   movs    r4,#0x0
0000afb8:   b       0x0000afaa
0000afba:   nop
0000afbc:   lsls    r0,r3,#14
0000afbe:   movs    r0,#0x0
2523      {
          cJSON_CreateArray:
0000afc0:   push    {r3,lr}
2524          cJSON *item = cJSON_New_Item(&global_hooks);
0000afc2:   ldr     r0,[pc,#0x10] ; 0xafd0
0000afc4:   bl      0x0000a166
2525          if(item)
0000afc8:   mov     r3,r0
0000afca:   cbz     r0,0x0000afd0
2527              item->type=cJSON_Array;
0000afcc:   movs    r2,#0x20
0000afce:   str     r2,[r0,#0xc]
2531      }
0000afd0:   mov     r0,r3
0000afd2:   pop     {r3,pc}
0000afd4:   lsls    r0,r3,#14
0000afd6:   movs    r0,#0x0
2181      {
          cJSON_AddArrayToObject:
0000afd8:   push    {r4,r5,r6,lr}
0000afda:   sub     sp,sp,#0x8
0000afdc:   mov     r5,r0
0000afde:   mov     r6,r1
2182          cJSON *array = cJSON_CreateArray();
0000afe0:   bl      0x0000afc0
0000afe4:   mov     r4,r0
2183          if (add_item_to_object(object, name, array, &global_hooks, false))
0000afe6:   movs    r3,#0x0
0000afe8:   str     r3,[sp,#0x0]
0000afea:   ldr     r3,[pc,#0x1c] ; 0xb004
0000afec:   mov     r2,r0
0000afee:   mov     r1,r6
0000aff0:   mov     r0,r5
......... ...
0000ccdc:   str     r5,[r4]
0000ccde:   b       0x000000000000cc98
0000cce0:   lsrs    r4,r4,#11
0000cce2:   movs    r0,#0x0
0000cce4:   lsrs    r0,r5,#11
0000cce6:   movs    r0,#0x0
0000cce8:   stmdb   sp!,{r4,r5,r6,r7,r8,r9,r10,lr}
0000ccec:   sub     sp,sp,#0x20
0000ccee:   cmp     r3,#0x0
0000ccf0:   ldr     r7,[sp,#0x50]
0000ccf2:   ldr     r6,[sp,#0x40]
0000ccf4:   ldrd    r1,r10,[sp,#0x48]
0000ccf8:   mov     r5,r3
0000ccfa:   bic     r7,r7,#0x20
0000ccfe:   ittet   lt
0000cd00:   add.w   r3,r3,#0x80000000
0000cd04:   mov     r5,r3
0000cd06:   movs    r3,#0x0
0000cd08:   movs    r3,#0x2d
0000cd0a:   mov     r4,r2
0000cd0c:   it      lt
0000cd0e:   mov     r4,r2
0000cd10:   cmp     r7,#0x46
0000cd12:   strb    r3,[r1]
0000cd14:   beq     0x000000000000cd20
0000cd16:   cmp     r7,#0x45
0000cd18:   bne     0x000000000000cd1c
0000cd1a:   adds    r6,#0x1
0000cd1c:   movs    r3,#0x2
0000cd1e:   b       0x000000000000cd22
0000cd20:   movs    r3,#0x3
0000cd22:   add     r2,sp,#0x1c
0000cd24:   str     r2,[sp,#0x10]
0000cd26:   add     r2,sp,#0x18
0000cd28:   strd    r10,r2,[sp,#0x8]
0000cd2c:   strd    r3,r6,[sp]
0000cd30:   mov     r2,r4
0000cd32:   mov     r3,r5
0000cd34:   bl      0x000000000000e868
0000cd38:   cmp     r7,#0x47
0000cd3a:   mov     r8,r0
0000cd3c:   bne     0x000000000000cd44
0000cd3e:   ldr     r3,[sp,#0x44]
0000cd40:   lsls    r3,r3,#31
0000cd42:   bpl     0x000000000000cd92
0000cd44:   cmp     r7,#0x46
0000cd46:   add.w   r9,r8,r6
0000cd4a:   bne     0x000000000000cd70
0000cd4c:   ldrb.w  r3,[r8]
0000cd50:   cmp     r3,#0x30
0000cd52:   bne     0x000000000000cd6a
0000cd54:   movs    r2,#0x0
0000cd56:   movs    r3,#0x0
0000cd58:   mov     r0,r4
0000cd5a:   mov     r1,r5
0000cd5c:   bl      0x000000000000c370
0000cd60:   cbnz    r0,0x000000000000cd6a
0000cd62:   rsb.w   r6,r6,#0x1
......... ...

В общем, не вывезу я всё это дело.

jcxz, отправил вам ЛС. Нет - попробую найти человека в разделе "Работа", если почку продавать не придётся.

Edited April 21, 2021 by kreker

Share this post

Link to post

Share on other sites

x893 0

Posted April 20, 2021 · Report post

Оптимизация O0 или O1

Код свой выложите на github.

Где то валялась STK-3700 - не совсем GG11

Share this post

Link to post

Share on other sites

jcxz 4

Posted April 20, 2021 · Report post

1 час назад, kreker сказал:

Да понял я, понял. Только вот когда ставлю брэкйпойнт на __ISB() при выполнении кода он упорно перезжает строчкой выше - на if().

Значит - поставить в окне дизассемблера.

1 час назад, kreker сказал:

Вместо __ISB() поставил __BKPT(0) - вроде как это программный брэкпойнт и выполнение кода дложно остановиться при заходе в условие, прямо на этой строчке. Даже без выставления брэкпойнта вручную.

Я бы не рассчитывал на этот __BKPT - неизвестно как его отладчик обрабатывает.

1 час назад, kreker сказал:

Но в условие не зашло, вместо этого теперь Hardfault выкидывает чутка в другом месте этой же либы...

Где-то что-то у вас затирается/разрушается. Так оно и будет бегать при внесении любых модификаций в код.

7 минут назад, x893 сказал:

Оптимизация O0 или O1

Ну да - и перестанет проявляться. Возможно. А когда включит - опять будет проявляться.

Это пинание колёс, а надо искать баг.

Share this post

Link to post

Share on other sites

x893 0

Posted April 20, 2021 · Report post

1 hour ago, jcxz said:

Ну да - и перестанет проявляться. Возможно. А когда включит - опять будет проявляться.

Это пинание колёс, а надо искать баг.

Тогда надо больше кофе - гадать удобнее будет.

Share this post

Link to post

Share on other sites

kreker 0

Posted April 21, 2021 · Report post

Проблема решена , по крайней мере частично, путём переделывания конструктора JSON: избавился, где можно было, от библиотечных функций cJSON активно использующих malloc \ realloc.

Несколько раз перезапускал проект, на этот раз отрабатывал дольше 5 минут. Ранее не работало устойчиво и двух минут.

Спасибо всем, кто помог.

EFM32 и Simplicity Studio, дебаг проекта

Recommended Posts

kreker 0

Share this post

Link to post

Share on other sites

jcxz 4

Share this post

Link to post

Share on other sites

kreker 0

Share this post

Link to post

Share on other sites

jcxz 4

Share this post

Link to post

Share on other sites

kreker 0

Share this post

Link to post

Share on other sites

jcxz 4

Share this post

Link to post

Share on other sites

kreker 0

Share this post

Link to post

Share on other sites

kreker 0

Share this post

Link to post

Share on other sites

jcxz 4

Share this post

Link to post

Share on other sites

kreker 0

Share this post

Link to post

Share on other sites

kreker 0

Share this post

Link to post

Share on other sites

x893 0

Share this post

Link to post

Share on other sites

jcxz 4

Share this post

Link to post

Share on other sites

x893 0

Share this post

Link to post

Share on other sites

kreker 0

Share this post

Link to post

Share on other sites