BaseTools/BinToPcd: Fix Python 2.7.x compatibility issue
[mirror_edk2.git] / EmbeddedPkg / GdbStub / Arm / Processor.c
1 /** @file
2 Processor specific parts of the GDB stub
3
4 Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
5
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
10
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14 **/
15
16 #include <GdbStubInternal.h>
17 #include <Library/CacheMaintenanceLib.h>
18 #include <Library/PrintLib.h>
19
20 //
21 // Array of exception types that need to be hooked by the debugger
22 // (efi, gdb) //efi number
23 //
24 EFI_EXCEPTION_TYPE_ENTRY gExceptionType[] = {
25 { EXCEPT_ARM_SOFTWARE_INTERRUPT, GDB_SIGTRAP }
26 // { EXCEPT_ARM_UNDEFINED_INSTRUCTION, GDB_SIGTRAP },
27 // { EXCEPT_ARM_PREFETCH_ABORT, GDB_SIGTRAP },
28 // { EXCEPT_ARM_DATA_ABORT, GDB_SIGEMT },
29 // { EXCEPT_ARM_RESERVED, GDB_SIGILL }
30 };
31
32 // Shut up some annoying RVCT warnings
33 #ifdef __CC_ARM
34 #pragma diag_suppress 1296
35 #endif
36
37 UINTN gRegisterOffsets[] = {
38 OFFSET_OF(EFI_SYSTEM_CONTEXT_ARM, R0),
39 OFFSET_OF(EFI_SYSTEM_CONTEXT_ARM, R1),
40 OFFSET_OF(EFI_SYSTEM_CONTEXT_ARM, R2),
41 OFFSET_OF(EFI_SYSTEM_CONTEXT_ARM, R3),
42 OFFSET_OF(EFI_SYSTEM_CONTEXT_ARM, R4),
43 OFFSET_OF(EFI_SYSTEM_CONTEXT_ARM, R5),
44 OFFSET_OF(EFI_SYSTEM_CONTEXT_ARM, R6),
45 OFFSET_OF(EFI_SYSTEM_CONTEXT_ARM, R7),
46 OFFSET_OF(EFI_SYSTEM_CONTEXT_ARM, R8),
47 OFFSET_OF(EFI_SYSTEM_CONTEXT_ARM, R9),
48 OFFSET_OF(EFI_SYSTEM_CONTEXT_ARM, R10),
49 OFFSET_OF(EFI_SYSTEM_CONTEXT_ARM, R11),
50 OFFSET_OF(EFI_SYSTEM_CONTEXT_ARM, R12),
51 OFFSET_OF(EFI_SYSTEM_CONTEXT_ARM, SP),
52 OFFSET_OF(EFI_SYSTEM_CONTEXT_ARM, LR),
53 OFFSET_OF(EFI_SYSTEM_CONTEXT_ARM, PC),
54 0x00000F01, // f0
55 0x00000F02,
56 0x00000F03,
57 0x00000F11, // f1
58 0x00000F12,
59 0x00000F13,
60 0x00000F21, // f2
61 0x00000F22,
62 0x00000F23,
63 0x00000F31, // f3
64 0x00000F32,
65 0x00000F33,
66 0x00000F41, // f4
67 0x00000F42,
68 0x00000F43,
69 0x00000F51, // f5
70 0x00000F52,
71 0x00000F53,
72 0x00000F61, // f6
73 0x00000F62,
74 0x00000F63,
75 0x00000F71, // f7
76 0x00000F72,
77 0x00000F73,
78 0x00000FFF, // fps
79 OFFSET_OF(EFI_SYSTEM_CONTEXT_ARM, CPSR)
80 };
81
82 // restore warnings for RVCT
83 #ifdef __CC_ARM
84 #pragma diag_default 1296
85 #endif
86
87 /**
88 Return the number of entries in the gExceptionType[]
89
90 @retval UINTN, the number of entries in the gExceptionType[] array.
91 **/
92 UINTN
93 MaxEfiException (
94 VOID
95 )
96 {
97 return sizeof (gExceptionType) / sizeof (EFI_EXCEPTION_TYPE_ENTRY);
98 }
99
100
101 /**
102 Return the number of entries in the gRegisters[]
103
104 @retval UINTN, the number of entries (registers) in the gRegisters[] array.
105 **/
106 UINTN
107 MaxRegisterCount (
108 VOID
109 )
110 {
111 return sizeof (gRegisterOffsets) / sizeof (UINTN);
112 }
113
114
115 /**
116 Check to see if the ISA is supported.
117 ISA = Instruction Set Architecture
118
119 @retval TRUE if Isa is supported
120
121 **/
122 BOOLEAN
123 CheckIsa (
124 IN EFI_INSTRUCTION_SET_ARCHITECTURE Isa
125 )
126 {
127 if (Isa == IsaArm) {
128 return TRUE;
129 } else {
130 return FALSE;
131 }
132 }
133
134
135 /**
136 This takes in the register number and the System Context, and returns a pointer to the RegNumber-th register in gdb ordering
137 It is, by default, set to find the register pointer of the ARM member
138 @param SystemContext Register content at time of the exception
139 @param RegNumber The register to which we want to find a pointer
140 @retval the pointer to the RegNumber-th pointer
141 **/
142 UINTN *
143 FindPointerToRegister (
144 IN EFI_SYSTEM_CONTEXT SystemContext,
145 IN UINTN RegNumber
146 )
147 {
148 UINT8 *TempPtr;
149 ASSERT(gRegisterOffsets[RegNumber] < 0xF00);
150 TempPtr = ((UINT8 *)SystemContext.SystemContextArm) + gRegisterOffsets[RegNumber];
151 return (UINT32 *)TempPtr;
152 }
153
154
155 /**
156 Adds the RegNumber-th register's value to the output buffer, starting at the given OutBufPtr
157 @param SystemContext Register content at time of the exception
158 @param RegNumber the number of the register that we want to read
159 @param OutBufPtr pointer to the output buffer's end. the new data will be added from this point on.
160 @retval the pointer to the next character of the output buffer that is available to be written on.
161 **/
162 CHAR8 *
163 BasicReadRegister (
164 IN EFI_SYSTEM_CONTEXT SystemContext,
165 IN UINTN RegNumber,
166 IN CHAR8 *OutBufPtr
167 )
168 {
169 UINTN RegSize;
170 CHAR8 Char;
171
172 if (gRegisterOffsets[RegNumber] > 0xF00) {
173 AsciiSPrint (OutBufPtr, 9, "00000000");
174 OutBufPtr += 8;
175 return OutBufPtr;
176 }
177
178 RegSize = 0;
179 while (RegSize < 32) {
180 Char = mHexToStr[(UINT8)((*FindPointerToRegister (SystemContext, RegNumber) >> (RegSize+4)) & 0xf)];
181 if ((Char >= 'A') && (Char <= 'F')) {
182 Char = Char - 'A' + 'a';
183 }
184 *OutBufPtr++ = Char;
185
186 Char = mHexToStr[(UINT8)((*FindPointerToRegister (SystemContext, RegNumber) >> RegSize) & 0xf)];
187 if ((Char >= 'A') && (Char <= 'F')) {
188 Char = Char - 'A' + 'a';
189 }
190 *OutBufPtr++ = Char;
191
192 RegSize = RegSize + 8;
193 }
194 return OutBufPtr;
195 }
196
197
198 /**
199 Reads the n-th register's value into an output buffer and sends it as a packet
200 @param SystemContext Register content at time of the exception
201 @param InBuffer Pointer to the input buffer received from gdb server
202 **/
203 VOID
204 ReadNthRegister (
205 IN EFI_SYSTEM_CONTEXT SystemContext,
206 IN CHAR8 *InBuffer
207 )
208 {
209 UINTN RegNumber;
210 CHAR8 OutBuffer[9]; // 1 reg=8 hex chars, and the end '\0' (escape seq)
211 CHAR8 *OutBufPtr; // pointer to the output buffer
212
213 RegNumber = AsciiStrHexToUintn (&InBuffer[1]);
214
215 if (RegNumber >= MaxRegisterCount ()) {
216 SendError (GDB_EINVALIDREGNUM);
217 return;
218 }
219
220 OutBufPtr = OutBuffer;
221 OutBufPtr = BasicReadRegister (SystemContext, RegNumber, OutBufPtr);
222
223 *OutBufPtr = '\0'; // the end of the buffer
224 SendPacket (OutBuffer);
225 }
226
227
228 /**
229 Reads the general registers into an output buffer and sends it as a packet
230 @param SystemContext Register content at time of the exception
231 **/
232 VOID
233 EFIAPI
234 ReadGeneralRegisters (
235 IN EFI_SYSTEM_CONTEXT SystemContext
236 )
237 {
238 UINTN Index;
239 CHAR8 *OutBuffer;
240 CHAR8 *OutBufPtr;
241 UINTN RegisterCount = MaxRegisterCount ();
242
243 // It is not safe to allocate pool here....
244 OutBuffer = AllocatePool ((RegisterCount * 8) + 1); // 8 bytes per register in string format plus a null to terminate
245 OutBufPtr = OutBuffer;
246 for (Index = 0; Index < RegisterCount; Index++) {
247 OutBufPtr = BasicReadRegister (SystemContext, Index, OutBufPtr);
248 }
249
250 *OutBufPtr = '\0';
251 SendPacket (OutBuffer);
252 FreePool (OutBuffer);
253 }
254
255
256 /**
257 Adds the RegNumber-th register's value to the output buffer, starting at the given OutBufPtr
258 @param SystemContext Register content at time of the exception
259 @param RegNumber the number of the register that we want to write
260 @param InBufPtr pointer to the output buffer. the new data will be extracted from the input buffer from this point on.
261 @retval the pointer to the next character of the input buffer that can be used
262 **/
263 CHAR8
264 *BasicWriteRegister (
265 IN EFI_SYSTEM_CONTEXT SystemContext,
266 IN UINTN RegNumber,
267 IN CHAR8 *InBufPtr
268 )
269 {
270 UINTN RegSize;
271 UINTN TempValue; // the value transferred from a hex char
272 UINT32 NewValue; // the new value of the RegNumber-th Register
273
274 if (gRegisterOffsets[RegNumber] > 0xF00) {
275 return InBufPtr + 8;
276 }
277
278 NewValue = 0;
279 RegSize = 0;
280 while (RegSize < 32) {
281 TempValue = HexCharToInt (*InBufPtr++);
282
283 if ((INTN)TempValue < 0) {
284 SendError (GDB_EBADMEMDATA);
285 return NULL;
286 }
287
288 NewValue += (TempValue << (RegSize+4));
289 TempValue = HexCharToInt (*InBufPtr++);
290
291 if ((INTN)TempValue < 0) {
292 SendError (GDB_EBADMEMDATA);
293 return NULL;
294 }
295
296 NewValue += (TempValue << RegSize);
297 RegSize = RegSize + 8;
298 }
299 *(FindPointerToRegister (SystemContext, RegNumber)) = NewValue;
300 return InBufPtr;
301 }
302
303
304 /** ‘P n...=r...’
305 Writes the new value of n-th register received into the input buffer to the n-th register
306 @param SystemContext Register content at time of the exception
307 @param InBuffer Ponter to the input buffer received from gdb server
308 **/
309 VOID
310 WriteNthRegister (
311 IN EFI_SYSTEM_CONTEXT SystemContext,
312 IN CHAR8 *InBuffer
313 )
314 {
315 UINTN RegNumber;
316 CHAR8 RegNumBuffer[MAX_REG_NUM_BUF_SIZE]; // put the 'n..' part of the message into this array
317 CHAR8 *RegNumBufPtr;
318 CHAR8 *InBufPtr; // pointer to the input buffer
319
320 // find the register number to write
321 InBufPtr = &InBuffer[1];
322 RegNumBufPtr = RegNumBuffer;
323 while (*InBufPtr != '=') {
324 *RegNumBufPtr++ = *InBufPtr++;
325 }
326 *RegNumBufPtr = '\0';
327 RegNumber = AsciiStrHexToUintn (RegNumBuffer);
328
329 // check if this is a valid Register Number
330 if (RegNumber >= MaxRegisterCount ()) {
331 SendError (GDB_EINVALIDREGNUM);
332 return;
333 }
334 InBufPtr++; // skips the '=' character
335 BasicWriteRegister (SystemContext, RegNumber, InBufPtr);
336 SendSuccess();
337 }
338
339
340 /** ‘G XX...’
341 Writes the new values received into the input buffer to the general registers
342 @param SystemContext Register content at time of the exception
343 @param InBuffer Pointer to the input buffer received from gdb server
344 **/
345
346 VOID
347 EFIAPI
348 WriteGeneralRegisters (
349 IN EFI_SYSTEM_CONTEXT SystemContext,
350 IN CHAR8 *InBuffer
351 )
352 {
353 UINTN i;
354 CHAR8 *InBufPtr; /// pointer to the input buffer
355 UINTN MinLength;
356 UINTN RegisterCount = MaxRegisterCount ();
357
358 MinLength = (RegisterCount * 8) + 1; // 'G' plus the registers in ASCII format
359
360 if (AsciiStrLen (InBuffer) < MinLength) {
361 //Bad message. Message is not the right length
362 SendError (GDB_EBADBUFSIZE);
363 return;
364 }
365
366 InBufPtr = &InBuffer[1];
367
368 // Read the new values for the registers from the input buffer to an array, NewValueArray.
369 // The values in the array are in the gdb ordering
370 for (i = 0; i < RegisterCount; i++) {
371 InBufPtr = BasicWriteRegister (SystemContext, i, InBufPtr);
372 }
373
374 SendSuccess ();
375 }
376
377 // What about Thumb?
378 // Use SWI 0xdbdbdb as the debug instruction
379 #define GDB_ARM_BKPT 0xefdbdbdb
380
381 BOOLEAN mSingleStepActive = FALSE;
382 UINT32 mSingleStepPC;
383 UINT32 mSingleStepData;
384 UINTN mSingleStepDataSize;
385
386 typedef struct {
387 LIST_ENTRY Link;
388 UINT64 Signature;
389 UINT32 Address;
390 UINT32 Instruction;
391 } ARM_SOFTWARE_BREAKPOINT;
392
393 #define ARM_SOFTWARE_BREAKPOINT_SIGNATURE SIGNATURE_64('A', 'R', 'M', 'B', 'R', 'K', 'P', 'T')
394 #define ARM_SOFTWARE_BREAKPOINT_FROM_LINK(a) CR(a, ARM_SOFTWARE_BREAKPOINT, Link, ARM_SOFTWARE_BREAKPOINT_SIGNATURE)
395
396 LIST_ENTRY BreakpointList;
397
398 /**
399 Insert Single Step in the SystemContext
400
401 @param SystemContext Register content at time of the exception
402 **/
403 VOID
404 AddSingleStep (
405 IN EFI_SYSTEM_CONTEXT SystemContext
406 )
407 {
408 if (mSingleStepActive) {
409 // Currently don't support nesting
410 return;
411 }
412 mSingleStepActive = TRUE;
413
414 mSingleStepPC = SystemContext.SystemContextArm->PC;
415
416 mSingleStepDataSize = sizeof (UINT32);
417 mSingleStepData = (*(UINT32 *)mSingleStepPC);
418 *(UINT32 *)mSingleStepPC = GDB_ARM_BKPT;
419 if (*(UINT32 *)mSingleStepPC != GDB_ARM_BKPT) {
420 // For some reason our breakpoint did not take
421 mSingleStepActive = FALSE;
422 }
423
424 InvalidateInstructionCacheRange ((VOID *)mSingleStepPC, mSingleStepDataSize);
425 //DEBUG((EFI_D_ERROR, "AddSingleStep at 0x%08x (was: 0x%08x is:0x%08x)\n", SystemContext.SystemContextArm->PC, mSingleStepData, *(UINT32 *)mSingleStepPC));
426 }
427
428
429 /**
430 Remove Single Step in the SystemContext
431
432 @param SystemContext Register content at time of the exception
433 **/
434 VOID
435 RemoveSingleStep (
436 IN EFI_SYSTEM_CONTEXT SystemContext
437 )
438 {
439 if (!mSingleStepActive) {
440 return;
441 }
442
443 if (mSingleStepDataSize == sizeof (UINT16)) {
444 *(UINT16 *)mSingleStepPC = (UINT16)mSingleStepData;
445 } else {
446 //DEBUG((EFI_D_ERROR, "RemoveSingleStep at 0x%08x (was: 0x%08x is:0x%08x)\n", SystemContext.SystemContextArm->PC, *(UINT32 *)mSingleStepPC, mSingleStepData));
447 *(UINT32 *)mSingleStepPC = mSingleStepData;
448 }
449 InvalidateInstructionCacheRange ((VOID *)mSingleStepPC, mSingleStepDataSize);
450 mSingleStepActive = FALSE;
451 }
452
453
454
455 /**
456 Continue. addr is Address to resume. If addr is omitted, resume at current
457 Address.
458
459 @param SystemContext Register content at time of the exception
460 **/
461 VOID
462 EFIAPI
463 ContinueAtAddress (
464 IN EFI_SYSTEM_CONTEXT SystemContext,
465 IN CHAR8 *PacketData
466 )
467 {
468 if (PacketData[1] != '\0') {
469 SystemContext.SystemContextArm->PC = AsciiStrHexToUintn (&PacketData[1]);
470 }
471 }
472
473
474 /** ‘s [addr ]’
475 Single step. addr is the Address at which to resume. If addr is omitted, resume
476 at same Address.
477
478 @param SystemContext Register content at time of the exception
479 **/
480 VOID
481 EFIAPI
482 SingleStep (
483 IN EFI_SYSTEM_CONTEXT SystemContext,
484 IN CHAR8 *PacketData
485 )
486 {
487 SendNotSupported ();
488 }
489
490 UINTN
491 GetBreakpointDataAddress (
492 IN EFI_SYSTEM_CONTEXT SystemContext,
493 IN UINTN BreakpointNumber
494 )
495 {
496 return 0;
497 }
498
499 UINTN
500 GetBreakpointDetected (
501 IN EFI_SYSTEM_CONTEXT SystemContext
502 )
503 {
504 return 0;
505 }
506
507 BREAK_TYPE
508 GetBreakpointType (
509 IN EFI_SYSTEM_CONTEXT SystemContext,
510 IN UINTN BreakpointNumber
511 )
512 {
513 return NotSupported;
514 }
515
516 ARM_SOFTWARE_BREAKPOINT *
517 SearchBreakpointList (
518 IN UINT32 Address
519 )
520 {
521 LIST_ENTRY *Current;
522 ARM_SOFTWARE_BREAKPOINT *Breakpoint;
523
524 Current = GetFirstNode (&BreakpointList);
525 while (!IsNull (&BreakpointList, Current)) {
526 Breakpoint = ARM_SOFTWARE_BREAKPOINT_FROM_LINK(Current);
527
528 if (Address == Breakpoint->Address) {
529 return Breakpoint;
530 }
531
532 Current = GetNextNode (&BreakpointList, Current);
533 }
534
535 return NULL;
536 }
537
538 VOID
539 SetBreakpoint (
540 IN UINT32 Address
541 )
542 {
543 ARM_SOFTWARE_BREAKPOINT *Breakpoint;
544
545 Breakpoint = SearchBreakpointList (Address);
546
547 if (Breakpoint != NULL) {
548 return;
549 }
550
551 // create and fill breakpoint structure
552 Breakpoint = AllocatePool (sizeof(ARM_SOFTWARE_BREAKPOINT));
553
554 Breakpoint->Signature = ARM_SOFTWARE_BREAKPOINT_SIGNATURE;
555 Breakpoint->Address = Address;
556 Breakpoint->Instruction = *(UINT32 *)Address;
557
558 // Add it to the list
559 InsertTailList (&BreakpointList, &Breakpoint->Link);
560
561 // Insert the software breakpoint
562 *(UINT32 *)Address = GDB_ARM_BKPT;
563 InvalidateInstructionCacheRange ((VOID *)Address, 4);
564
565 //DEBUG((EFI_D_ERROR, "SetBreakpoint at 0x%08x (was: 0x%08x is:0x%08x)\n", Address, Breakpoint->Instruction, *(UINT32 *)Address));
566 }
567
568 VOID
569 ClearBreakpoint (
570 IN UINT32 Address
571 )
572 {
573 ARM_SOFTWARE_BREAKPOINT *Breakpoint;
574
575 Breakpoint = SearchBreakpointList (Address);
576
577 if (Breakpoint == NULL) {
578 return;
579 }
580
581 // Add it to the list
582 RemoveEntryList (&Breakpoint->Link);
583
584 // Restore the original instruction
585 *(UINT32 *)Address = Breakpoint->Instruction;
586 InvalidateInstructionCacheRange ((VOID *)Address, 4);
587
588 //DEBUG((EFI_D_ERROR, "ClearBreakpoint at 0x%08x (was: 0x%08x is:0x%08x)\n", Address, GDB_ARM_BKPT, *(UINT32 *)Address));
589
590 FreePool (Breakpoint);
591 }
592
593 VOID
594 EFIAPI
595 InsertBreakPoint (
596 IN EFI_SYSTEM_CONTEXT SystemContext,
597 IN CHAR8 *PacketData
598 )
599 {
600 UINTN Type;
601 UINTN Address;
602 UINTN Length;
603 UINTN ErrorCode;
604
605 ErrorCode = ParseBreakpointPacket (PacketData, &Type, &Address, &Length);
606 if (ErrorCode > 0) {
607 SendError ((UINT8)ErrorCode);
608 return;
609 }
610
611 switch (Type) {
612 case 0: //Software breakpoint
613 break;
614
615 default :
616 DEBUG((EFI_D_ERROR, "Insert breakpoint default: %x\n", Type));
617 SendError (GDB_EINVALIDBRKPOINTTYPE);
618 return;
619 }
620
621 SetBreakpoint (Address);
622
623 SendSuccess ();
624 }
625
626 VOID
627 EFIAPI
628 RemoveBreakPoint (
629 IN EFI_SYSTEM_CONTEXT SystemContext,
630 IN CHAR8 *PacketData
631 )
632 {
633 UINTN Type;
634 UINTN Address;
635 UINTN Length;
636 UINTN ErrorCode;
637
638 //Parse breakpoint packet data
639 ErrorCode = ParseBreakpointPacket (PacketData, &Type, &Address, &Length);
640 if (ErrorCode > 0) {
641 SendError ((UINT8)ErrorCode);
642 return;
643 }
644
645 switch (Type) {
646 case 0: //Software breakpoint
647 break;
648
649 default:
650 SendError (GDB_EINVALIDBRKPOINTTYPE);
651 return;
652 }
653
654 ClearBreakpoint (Address);
655
656 SendSuccess ();
657 }
658
659 VOID
660 InitializeProcessor (
661 VOID
662 )
663 {
664 // Initialize breakpoint list
665 InitializeListHead (&BreakpointList);
666 }
667
668 BOOLEAN
669 ValidateAddress (
670 IN VOID *Address
671 )
672 {
673 if ((UINT32)Address < 0x80000000) {
674 return FALSE;
675 } else {
676 return TRUE;
677 }
678 }
679
680 BOOLEAN
681 ValidateException (
682 IN EFI_EXCEPTION_TYPE ExceptionType,
683 IN OUT EFI_SYSTEM_CONTEXT SystemContext
684 )
685 {
686 UINT32 ExceptionAddress;
687 UINT32 Instruction;
688
689 // Is it a debugger SWI?
690 ExceptionAddress = SystemContext.SystemContextArm->PC -= 4;
691 Instruction = *(UINT32 *)ExceptionAddress;
692 if (Instruction != GDB_ARM_BKPT) {
693 return FALSE;
694 }
695
696 // Special for SWI-based exception handling. SWI sets up the context
697 // to return to the instruction following the SWI instruction - NOT what we want
698 // for a debugger!
699 SystemContext.SystemContextArm->PC = ExceptionAddress;
700
701 return TRUE;
702 }
703