Jump to content

    

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

Recommended Posts

kreker

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

 

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);
}

 

 

 

on_error.png

on_error2.png

on_halt.png

Edited by kreker

Share this post


Link to post
Share on other sites

jcxz
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
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
3 минуты назад, kreker сказал:

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

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

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

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

 

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

Share this post


Link to post
Share on other sites

kreker
58 minutes ago, jcxz said:

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

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

Share this post


Link to post
Share on other sites

jcxz

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

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

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

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

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

Share this post


Link to post
Share on other sites

kreker
5 hours ago, jcxz said:

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

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

5 hours ago, jcxz said:

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

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

 

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

Debug view.png

Edited by kreker

Share this post


Link to post
Share on other sites

kreker

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

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

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
......... ...

 

 

BKP_3.png

BKP_2.png

BKP_1.png

Share this post


Link to post
Share on other sites

jcxz
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
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

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

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, отправил вам ЛС. Нет - попробую найти человека в разделе "Работа", если почку продавать не придётся.

 

 

 

on_error2.png

on_halt.png

on_error.png

Edited by kreker

Share this post


Link to post
Share on other sites

x893

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

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

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

Share this post


Link to post
Share on other sites

jcxz
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
1 hour ago, jcxz said:

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

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

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

Share this post


Link to post
Share on other sites

kreker

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

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

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

Share this post


Link to post
Share on other sites

Guest
This topic is now closed to further replies.