1 /******************************************************************************
2 *
3 * Module Name: psobject - Support for parse objects
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2013, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44
45 #include "acpi.h"
46 #include "accommon.h"
47 #include "acparser.h"
48 #include "amlcode.h"
49
50 #define _COMPONENT ACPI_PARSER
51 ACPI_MODULE_NAME ("psobject")
52
53
54 /* Local prototypes */
55
56 static ACPI_STATUS
57 AcpiPsGetAmlOpcode (
58 ACPI_WALK_STATE *WalkState);
59
60
61 /*******************************************************************************
62 *
63 * FUNCTION: AcpiPsGetAmlOpcode
64 *
65 * PARAMETERS: WalkState - Current state
66 *
67 * RETURN: Status
68 *
69 * DESCRIPTION: Extract the next AML opcode from the input stream.
70 *
71 ******************************************************************************/
72
73 static ACPI_STATUS
74 AcpiPsGetAmlOpcode (
75 ACPI_WALK_STATE *WalkState)
76 {
77
78 ACPI_FUNCTION_TRACE_PTR (PsGetAmlOpcode, WalkState);
79
80
81 WalkState->AmlOffset = (UINT32) ACPI_PTR_DIFF (WalkState->ParserState.Aml,
82 WalkState->ParserState.AmlStart);
83 WalkState->Opcode = AcpiPsPeekOpcode (&(WalkState->ParserState));
84
85 /*
86 * First cut to determine what we have found:
87 * 1) A valid AML opcode
88 * 2) A name string
89 * 3) An unknown/invalid opcode
90 */
91 WalkState->OpInfo = AcpiPsGetOpcodeInfo (WalkState->Opcode);
92
93 switch (WalkState->OpInfo->Class)
94 {
95 case AML_CLASS_ASCII:
96 case AML_CLASS_PREFIX:
97 /*
98 * Starts with a valid prefix or ASCII char, this is a name
99 * string. Convert the bare name string to a namepath.
100 */
101 WalkState->Opcode = AML_INT_NAMEPATH_OP;
102 WalkState->ArgTypes = ARGP_NAMESTRING;
103 break;
104
105 case AML_CLASS_UNKNOWN:
106
107 /* The opcode is unrecognized. Complain and skip unknown opcodes */
108
109 if (WalkState->PassNumber == 2)
110 {
111 ACPI_ERROR ((AE_INFO,
112 "Unknown opcode 0x%.2X at table offset 0x%.4X, ignoring",
113 WalkState->Opcode,
114 (UINT32) (WalkState->AmlOffset + sizeof (ACPI_TABLE_HEADER))));
115
116 ACPI_DUMP_BUFFER ((WalkState->ParserState.Aml - 16), 48);
117
118 #ifdef ACPI_ASL_COMPILER
119 /*
120 * This is executed for the disassembler only. Output goes
121 * to the disassembled ASL output file.
122 */
123 AcpiOsPrintf (
124 "/*\nError: Unknown opcode 0x%.2X at table offset 0x%.4X, context:\n",
125 WalkState->Opcode,
126 (UINT32) (WalkState->AmlOffset + sizeof (ACPI_TABLE_HEADER)));
127
128 /* Dump the context surrounding the invalid opcode */
129
130 AcpiUtDumpBuffer (((UINT8 *) WalkState->ParserState.Aml - 16),
131 48, DB_BYTE_DISPLAY,
132 (WalkState->AmlOffset + sizeof (ACPI_TABLE_HEADER) - 16));
133 AcpiOsPrintf (" */\n");
134 #endif
135 }
136
137 /* Increment past one-byte or two-byte opcode */
138
139 WalkState->ParserState.Aml++;
140 if (WalkState->Opcode > 0xFF) /* Can only happen if first byte is 0x5B */
141 {
142 WalkState->ParserState.Aml++;
143 }
144
145 return_ACPI_STATUS (AE_CTRL_PARSE_CONTINUE);
146
147 default:
148
149 /* Found opcode info, this is a normal opcode */
150
151 WalkState->ParserState.Aml += AcpiPsGetOpcodeSize (WalkState->Opcode);
152 WalkState->ArgTypes = WalkState->OpInfo->ParseArgs;
153 break;
154 }
155
156 return_ACPI_STATUS (AE_OK);
157 }
158
159
160 /*******************************************************************************
161 *
162 * FUNCTION: AcpiPsBuildNamedOp
163 *
164 * PARAMETERS: WalkState - Current state
165 * AmlOpStart - Begin of named Op in AML
166 * UnnamedOp - Early Op (not a named Op)
167 * Op - Returned Op
168 *
169 * RETURN: Status
170 *
171 * DESCRIPTION: Parse a named Op
172 *
173 ******************************************************************************/
174
175 ACPI_STATUS
176 AcpiPsBuildNamedOp (
177 ACPI_WALK_STATE *WalkState,
178 UINT8 *AmlOpStart,
179 ACPI_PARSE_OBJECT *UnnamedOp,
180 ACPI_PARSE_OBJECT **Op)
181 {
182 ACPI_STATUS Status = AE_OK;
183 ACPI_PARSE_OBJECT *Arg = NULL;
184
185
186 ACPI_FUNCTION_TRACE_PTR (PsBuildNamedOp, WalkState);
187
188
189 UnnamedOp->Common.Value.Arg = NULL;
190 UnnamedOp->Common.ArgListLength = 0;
191 UnnamedOp->Common.AmlOpcode = WalkState->Opcode;
192
193 /*
194 * Get and append arguments until we find the node that contains
195 * the name (the type ARGP_NAME).
196 */
197 while (GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) &&
198 (GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) != ARGP_NAME))
199 {
200 Status = AcpiPsGetNextArg (WalkState, &(WalkState->ParserState),
201 GET_CURRENT_ARG_TYPE (WalkState->ArgTypes), &Arg);
202 if (ACPI_FAILURE (Status))
203 {
204 return_ACPI_STATUS (Status);
205 }
206
207 AcpiPsAppendArg (UnnamedOp, Arg);
208 INCREMENT_ARG_LIST (WalkState->ArgTypes);
209 }
210
211 /*
212 * Make sure that we found a NAME and didn't run out of arguments
213 */
214 if (!GET_CURRENT_ARG_TYPE (WalkState->ArgTypes))
215 {
216 return_ACPI_STATUS (AE_AML_NO_OPERAND);
217 }
218
219 /* We know that this arg is a name, move to next arg */
220
221 INCREMENT_ARG_LIST (WalkState->ArgTypes);
222
223 /*
224 * Find the object. This will either insert the object into
225 * the namespace or simply look it up
226 */
227 WalkState->Op = NULL;
228
229 Status = WalkState->DescendingCallback (WalkState, Op);
230 if (ACPI_FAILURE (Status))
231 {
232 ACPI_EXCEPTION ((AE_INFO, Status, "During name lookup/catalog"));
233 return_ACPI_STATUS (Status);
234 }
235
236 if (!*Op)
237 {
238 return_ACPI_STATUS (AE_CTRL_PARSE_CONTINUE);
239 }
240
241 Status = AcpiPsNextParseState (WalkState, *Op, Status);
242 if (ACPI_FAILURE (Status))
243 {
244 if (Status == AE_CTRL_PENDING)
245 {
246 return_ACPI_STATUS (AE_CTRL_PARSE_PENDING);
247 }
248 return_ACPI_STATUS (Status);
249 }
250
251 AcpiPsAppendArg (*Op, UnnamedOp->Common.Value.Arg);
252
253 if ((*Op)->Common.AmlOpcode == AML_REGION_OP ||
254 (*Op)->Common.AmlOpcode == AML_DATA_REGION_OP)
255 {
256 /*
257 * Defer final parsing of an OperationRegion body, because we don't
258 * have enough info in the first pass to parse it correctly (i.e.,
259 * there may be method calls within the TermArg elements of the body.)
260 *
261 * However, we must continue parsing because the opregion is not a
262 * standalone package -- we don't know where the end is at this point.
263 *
264 * (Length is unknown until parse of the body complete)
265 */
266 (*Op)->Named.Data = AmlOpStart;
267 (*Op)->Named.Length = 0;
268 }
269
270 return_ACPI_STATUS (AE_OK);
271 }
272
273
274 /*******************************************************************************
275 *
276 * FUNCTION: AcpiPsCreateOp
277 *
278 * PARAMETERS: WalkState - Current state
279 * AmlOpStart - Op start in AML
280 * NewOp - Returned Op
281 *
282 * RETURN: Status
283 *
284 * DESCRIPTION: Get Op from AML
285 *
286 ******************************************************************************/
287
288 ACPI_STATUS
289 AcpiPsCreateOp (
290 ACPI_WALK_STATE *WalkState,
291 UINT8 *AmlOpStart,
292 ACPI_PARSE_OBJECT **NewOp)
293 {
294 ACPI_STATUS Status = AE_OK;
295 ACPI_PARSE_OBJECT *Op;
296 ACPI_PARSE_OBJECT *NamedOp = NULL;
297 ACPI_PARSE_OBJECT *ParentScope;
298 UINT8 ArgumentCount;
299 const ACPI_OPCODE_INFO *OpInfo;
300
301
302 ACPI_FUNCTION_TRACE_PTR (PsCreateOp, WalkState);
303
304
305 Status = AcpiPsGetAmlOpcode (WalkState);
306 if (Status == AE_CTRL_PARSE_CONTINUE)
307 {
308 return_ACPI_STATUS (AE_CTRL_PARSE_CONTINUE);
309 }
310
311 /* Create Op structure and append to parent's argument list */
312
313 WalkState->OpInfo = AcpiPsGetOpcodeInfo (WalkState->Opcode);
314 Op = AcpiPsAllocOp (WalkState->Opcode);
315 if (!Op)
316 {
317 return_ACPI_STATUS (AE_NO_MEMORY);
318 }
319
320 if (WalkState->OpInfo->Flags & AML_NAMED)
321 {
322 Status = AcpiPsBuildNamedOp (WalkState, AmlOpStart, Op, &NamedOp);
323 AcpiPsFreeOp (Op);
324 if (ACPI_FAILURE (Status))
325 {
326 return_ACPI_STATUS (Status);
327 }
328
329 *NewOp = NamedOp;
330 return_ACPI_STATUS (AE_OK);
331 }
332
333 /* Not a named opcode, just allocate Op and append to parent */
334
335 if (WalkState->OpInfo->Flags & AML_CREATE)
336 {
337 /*
338 * Backup to beginning of CreateXXXfield declaration
339 * BodyLength is unknown until we parse the body
340 */
341 Op->Named.Data = AmlOpStart;
342 Op->Named.Length = 0;
343 }
344
345 if (WalkState->Opcode == AML_BANK_FIELD_OP)
346 {
347 /*
348 * Backup to beginning of BankField declaration
349 * BodyLength is unknown until we parse the body
350 */
351 Op->Named.Data = AmlOpStart;
352 Op->Named.Length = 0;
353 }
354
355 ParentScope = AcpiPsGetParentScope (&(WalkState->ParserState));
356 AcpiPsAppendArg (ParentScope, Op);
357
358 if (ParentScope)
359 {
360 OpInfo = AcpiPsGetOpcodeInfo (ParentScope->Common.AmlOpcode);
361 if (OpInfo->Flags & AML_HAS_TARGET)
362 {
363 ArgumentCount = AcpiPsGetArgumentCount (OpInfo->Type);
364 if (ParentScope->Common.ArgListLength > ArgumentCount)
365 {
366 Op->Common.Flags |= ACPI_PARSEOP_TARGET;
367 }
368 }
369 else if (ParentScope->Common.AmlOpcode == AML_INCREMENT_OP)
370 {
371 Op->Common.Flags |= ACPI_PARSEOP_TARGET;
372 }
373 }
374
375 if (WalkState->DescendingCallback != NULL)
376 {
377 /*
378 * Find the object. This will either insert the object into
379 * the namespace or simply look it up
380 */
381 WalkState->Op = *NewOp = Op;
382
383 Status = WalkState->DescendingCallback (WalkState, &Op);
384 Status = AcpiPsNextParseState (WalkState, Op, Status);
385 if (Status == AE_CTRL_PENDING)
386 {
387 Status = AE_CTRL_PARSE_PENDING;
388 }
389 }
390
391 return_ACPI_STATUS (Status);
392 }
393
394
395 /*******************************************************************************
396 *
397 * FUNCTION: AcpiPsCompleteOp
398 *
399 * PARAMETERS: WalkState - Current state
400 * Op - Returned Op
401 * Status - Parse status before complete Op
402 *
403 * RETURN: Status
404 *
405 * DESCRIPTION: Complete Op
406 *
407 ******************************************************************************/
408
409 ACPI_STATUS
410 AcpiPsCompleteOp (
411 ACPI_WALK_STATE *WalkState,
412 ACPI_PARSE_OBJECT **Op,
413 ACPI_STATUS Status)
414 {
415 ACPI_STATUS Status2;
416
417
418 ACPI_FUNCTION_TRACE_PTR (PsCompleteOp, WalkState);
419
420
421 /*
422 * Finished one argument of the containing scope
423 */
424 WalkState->ParserState.Scope->ParseScope.ArgCount--;
425
426 /* Close this Op (will result in parse subtree deletion) */
427
428 Status2 = AcpiPsCompleteThisOp (WalkState, *Op);
429 if (ACPI_FAILURE (Status2))
430 {
431 return_ACPI_STATUS (Status2);
432 }
433
434 *Op = NULL;
435
436 switch (Status)
437 {
438 case AE_OK:
439
440 break;
441
442 case AE_CTRL_TRANSFER:
443
444 /* We are about to transfer to a called method */
445
446 WalkState->PrevOp = NULL;
447 WalkState->PrevArgTypes = WalkState->ArgTypes;
448 return_ACPI_STATUS (Status);
449
450 case AE_CTRL_END:
451
452 AcpiPsPopScope (&(WalkState->ParserState), Op,
453 &WalkState->ArgTypes, &WalkState->ArgCount);
454
455 if (*Op)
456 {
457 WalkState->Op = *Op;
458 WalkState->OpInfo = AcpiPsGetOpcodeInfo ((*Op)->Common.AmlOpcode);
459 WalkState->Opcode = (*Op)->Common.AmlOpcode;
460
461 Status = WalkState->AscendingCallback (WalkState);
462 Status = AcpiPsNextParseState (WalkState, *Op, Status);
463
464 Status2 = AcpiPsCompleteThisOp (WalkState, *Op);
465 if (ACPI_FAILURE (Status2))
466 {
467 return_ACPI_STATUS (Status2);
468 }
469 }
470
471 Status = AE_OK;
472 break;
473
474 case AE_CTRL_BREAK:
475 case AE_CTRL_CONTINUE:
476
477 /* Pop off scopes until we find the While */
478
479 while (!(*Op) || ((*Op)->Common.AmlOpcode != AML_WHILE_OP))
480 {
481 AcpiPsPopScope (&(WalkState->ParserState), Op,
482 &WalkState->ArgTypes, &WalkState->ArgCount);
483 }
484
485 /* Close this iteration of the While loop */
486
487 WalkState->Op = *Op;
488 WalkState->OpInfo = AcpiPsGetOpcodeInfo ((*Op)->Common.AmlOpcode);
489 WalkState->Opcode = (*Op)->Common.AmlOpcode;
490
491 Status = WalkState->AscendingCallback (WalkState);
492 Status = AcpiPsNextParseState (WalkState, *Op, Status);
493
494 Status2 = AcpiPsCompleteThisOp (WalkState, *Op);
495 if (ACPI_FAILURE (Status2))
496 {
497 return_ACPI_STATUS (Status2);
498 }
499
500 Status = AE_OK;
501 break;
502
503 case AE_CTRL_TERMINATE:
504
505 /* Clean up */
506 do
507 {
508 if (*Op)
509 {
510 Status2 = AcpiPsCompleteThisOp (WalkState, *Op);
511 if (ACPI_FAILURE (Status2))
512 {
513 return_ACPI_STATUS (Status2);
514 }
515
516 AcpiUtDeleteGenericState (
517 AcpiUtPopGenericState (&WalkState->ControlState));
518 }
519
520 AcpiPsPopScope (&(WalkState->ParserState), Op,
521 &WalkState->ArgTypes, &WalkState->ArgCount);
522
523 } while (*Op);
524
525 return_ACPI_STATUS (AE_OK);
526
527 default: /* All other non-AE_OK status */
528
529 do
530 {
531 if (*Op)
532 {
533 Status2 = AcpiPsCompleteThisOp (WalkState, *Op);
534 if (ACPI_FAILURE (Status2))
535 {
536 return_ACPI_STATUS (Status2);
537 }
538 }
539
540 AcpiPsPopScope (&(WalkState->ParserState), Op,
541 &WalkState->ArgTypes, &WalkState->ArgCount);
542
543 } while (*Op);
544
545
546 #if 0
547 /*
548 * TBD: Cleanup parse ops on error
549 */
550 if (*Op == NULL)
551 {
552 AcpiPsPopScope (ParserState, Op,
553 &WalkState->ArgTypes, &WalkState->ArgCount);
554 }
555 #endif
556 WalkState->PrevOp = NULL;
557 WalkState->PrevArgTypes = WalkState->ArgTypes;
558 return_ACPI_STATUS (Status);
559 }
560
561 /* This scope complete? */
562
563 if (AcpiPsHasCompletedScope (&(WalkState->ParserState)))
564 {
565 AcpiPsPopScope (&(WalkState->ParserState), Op,
566 &WalkState->ArgTypes, &WalkState->ArgCount);
567 ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", *Op));
568 }
569 else
570 {
571 *Op = NULL;
572 }
573
574 return_ACPI_STATUS (AE_OK);
575 }
576
577
578 /*******************************************************************************
579 *
580 * FUNCTION: AcpiPsCompleteFinalOp
581 *
582 * PARAMETERS: WalkState - Current state
583 * Op - Current Op
584 * Status - Current parse status before complete last
585 * Op
586 *
587 * RETURN: Status
588 *
589 * DESCRIPTION: Complete last Op.
590 *
591 ******************************************************************************/
592
593 ACPI_STATUS
594 AcpiPsCompleteFinalOp (
595 ACPI_WALK_STATE *WalkState,
596 ACPI_PARSE_OBJECT *Op,
597 ACPI_STATUS Status)
598 {
599 ACPI_STATUS Status2;
600
601
602 ACPI_FUNCTION_TRACE_PTR (PsCompleteFinalOp, WalkState);
603
604
605 /*
606 * Complete the last Op (if not completed), and clear the scope stack.
607 * It is easily possible to end an AML "package" with an unbounded number
608 * of open scopes (such as when several ASL blocks are closed with
609 * sequential closing braces). We want to terminate each one cleanly.
610 */
611 ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "AML package complete at Op %p\n", Op));
612 do
613 {
614 if (Op)
615 {
616 if (WalkState->AscendingCallback != NULL)
617 {
618 WalkState->Op = Op;
619 WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
620 WalkState->Opcode = Op->Common.AmlOpcode;
621
622 Status = WalkState->AscendingCallback (WalkState);
623 Status = AcpiPsNextParseState (WalkState, Op, Status);
624 if (Status == AE_CTRL_PENDING)
625 {
626 Status = AcpiPsCompleteOp (WalkState, &Op, AE_OK);
627 if (ACPI_FAILURE (Status))
628 {
629 return_ACPI_STATUS (Status);
630 }
631 }
632
633 if (Status == AE_CTRL_TERMINATE)
634 {
635 Status = AE_OK;
636
637 /* Clean up */
638 do
639 {
640 if (Op)
641 {
642 Status2 = AcpiPsCompleteThisOp (WalkState, Op);
643 if (ACPI_FAILURE (Status2))
644 {
645 return_ACPI_STATUS (Status2);
646 }
647 }
648
649 AcpiPsPopScope (&(WalkState->ParserState), &Op,
650 &WalkState->ArgTypes, &WalkState->ArgCount);
651
652 } while (Op);
653
654 return_ACPI_STATUS (Status);
655 }
656
657 else if (ACPI_FAILURE (Status))
658 {
659 /* First error is most important */
660
661 (void) AcpiPsCompleteThisOp (WalkState, Op);
662 return_ACPI_STATUS (Status);
663 }
664 }
665
666 Status2 = AcpiPsCompleteThisOp (WalkState, Op);
667 if (ACPI_FAILURE (Status2))
668 {
669 return_ACPI_STATUS (Status2);
670 }
671 }
672
673 AcpiPsPopScope (&(WalkState->ParserState), &Op, &WalkState->ArgTypes,
674 &WalkState->ArgCount);
675
676 } while (Op);
677
678 return_ACPI_STATUS (Status);
679 }