| blob | a16a6ea5ae02aded254903cc265fa34b874c8033 |
1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
3 *
4 * Module Name: psparse - Parser top level AML parse routines
5 *
6 * Copyright (C) 2000 - 2018, Intel Corp.
7 *
8 *****************************************************************************/
10 /*
11 * Parse the AML and build an operation tree as most interpreters,
12 * like Perl, do. Parsing is done by hand rather than with a YACC
13 * generated parser to tightly constrain stack and dynamic memory
14 * usage. At the same time, parsing is kept flexible and the code
15 * fairly compact by parsing based on a list of AML opcode
16 * templates in aml_op_info[]
17 */
19 #include <acpi/acpi.h>
27 #define _COMPONENT ACPI_PARSER
30 /*******************************************************************************
31 *
32 * FUNCTION: acpi_ps_get_opcode_size
33 *
34 * PARAMETERS: opcode - An AML opcode
35 *
36 * RETURN: Size of the opcode, in bytes (1 or 2)
37 *
38 * DESCRIPTION: Get the size of the current opcode.
39 *
40 ******************************************************************************/
42 {
44 /* Extended (2-byte) opcode if > 255 */
48 }
50 /* Otherwise, just a single byte opcode */
53 }
55 /*******************************************************************************
56 *
57 * FUNCTION: acpi_ps_peek_opcode
58 *
59 * PARAMETERS: parser_state - A parser state object
60 *
61 * RETURN: Next AML opcode
62 *
63 * DESCRIPTION: Get next AML opcode (without incrementing AML pointer)
64 *
65 ******************************************************************************/
68 {
70 u16 opcode;
77 /* Extended opcode, get the second opcode byte */
79 aml++;
81 }
84 }
86 /*******************************************************************************
87 *
88 * FUNCTION: acpi_ps_complete_this_op
89 *
90 * PARAMETERS: walk_state - Current State
91 * op - Op to complete
92 *
93 * RETURN: Status
94 *
95 * DESCRIPTION: Perform any cleanup at the completion of an Op.
96 *
97 ******************************************************************************/
99 acpi_status
102 {
111 /* Check for null Op, can happen if AML code is corrupt */
115 }
119 /* Delete this op and the subtree below it if asked to */
122 ACPI_PARSE_DELETE_TREE)
125 }
127 /* Make sure that we only delete this subtree */
133 /* Nothing more to do */
136 }
138 /*
139 * Check if we need to replace the operator and its subtree
140 * with a return value op (placeholder op)
141 */
142 parent_info =
144 aml_opcode);
152 /*
153 * These opcodes contain term_arg operands. The current
154 * op must be replaced by a placeholder return op
155 */
156 replacement_op =
161 }
165 /*
166 * These opcodes contain term_arg operands. The current
167 * op must be replaced by a placeholder return op
168 */
170 AML_REGION_OP)
172 AML_DATA_REGION_OP)
174 AML_BUFFER_OP)
176 AML_PACKAGE_OP)
178 AML_BANK_FIELD_OP)
180 AML_VARIABLE_PACKAGE_OP)) {
181 replacement_op =
186 }
189 AML_NAME_OP)
191 ACPI_IMODE_LOAD_PASS2)) {
195 AML_VARIABLE_PACKAGE_OP)) {
196 replacement_op =
198 aml_opcode,
207 }
208 }
209 }
214 replacement_op =
219 }
220 }
222 /* We must unlink this op from the parent tree */
226 /* This op is the first in the list */
234 replacement_op;
239 }
240 }
242 /* Search the parent list */
244 else
247 /* Traverse all siblings in the parent's argument list */
259 replacement_op;
267 }
268 }
270 }
271 }
273 cleanup:
275 /* Now we can actually delete the subtree rooted at Op */
279 }
281 /*******************************************************************************
282 *
283 * FUNCTION: acpi_ps_next_parse_state
284 *
285 * PARAMETERS: walk_state - Current state
286 * op - Current parse op
287 * callback_status - Status from previous operation
288 *
289 * RETURN: Status
290 *
291 * DESCRIPTION: Update the parser state based upon the return exception from
292 * the parser callback.
293 *
294 ******************************************************************************/
296 acpi_status
299 acpi_status callback_status)
300 {
308 /*
309 * A control method was terminated via a RETURN statement.
310 * The walk of this method is complete.
311 */
334 #if 0
340 #endif
343 /*
344 * Predicate of an IF was true, and we are at the matching ELSE.
345 * Just close out this package
346 */
352 /*
353 * Either an IF/WHILE Predicate was false or we encountered a BREAK
354 * opcode. In both cases, we do not execute the rest of the
355 * package; We simply close out the parent (finishing the walk of
356 * this branch of the tree) and continue execution at the parent
357 * level.
358 */
361 /* In the case of a BREAK, just force a predicate (if any) to FALSE */
369 /* A method call (invocation) -- transfer control */
377 /* Will return value (if any) be used by the caller? */
388 }
390 }
393 }
395 /*******************************************************************************
396 *
397 * FUNCTION: acpi_ps_parse_aml
398 *
399 * PARAMETERS: walk_state - Current state
400 *
401 *
402 * RETURN: Status
403 *
404 * DESCRIPTION: Parse raw AML and return a tree of ops
405 *
406 ******************************************************************************/
409 {
410 acpi_status status;
424 }
426 /* Create and initialize a new thread state */
432 /* Executing a control method - additional cleanup */
435 method_desc,
436 walk_state);
437 }
441 }
445 /*
446 * If executing a method, the starting sync_level is this method's
447 * sync_level
448 */
452 }
456 /*
457 * This global allows the AML debugger to get a handle to the currently
458 * executing control method.
459 */
462 /*
463 * Execute the walk loop as long as there is a valid Walk State. This
464 * handles nested control method invocations without recursion.
465 */
471 /*
472 * The parse_loop executes AML until the method terminates
473 * or calls another method.
474 */
476 }
483 /*
484 * A method call was detected.
485 * Transfer control to the called control method
486 */
487 status =
489 NULL);
491 status =
493 }
495 /*
496 * If the transfer to the new method method call worked
497 *, a new walk state was created -- get it
498 */
505 /* Either the method parse or actual execution failed */
510 method_node,
514 ACPI_ERROR_METHOD
517 }
520 /* Check for possible multi-thread reentrancy problem */
524 ACPI_METHOD_SERIALIZED))) {
525 /*
526 * Method is not serialized and tried to create an object
527 * twice. The probable cause is that the method cannot
528 * handle reentrancy. Mark as "pending serialized" now, and
529 * then mark "serialized" when the last thread exits.
530 */
532 ACPI_METHOD_SERIALIZED_PENDING;
533 }
534 }
536 /* We are done with this walk, move on to the parent if any */
540 /* Reset the current scope to the beginning of scope stack */
544 /*
545 * If we just returned from the execution of a control method or if we
546 * encountered an error during the method parse phase, there's lots of
547 * cleanup to do
548 */
550 ACPI_PARSE_EXECUTE &&
554 method_desc,
555 walk_state);
556 }
558 /* Delete this walk state and all linked control states */
568 /* Check if we have restarted a preempted walk */
573 /*
574 * There is another walk state, restart it.
575 * If the method return value is not used by the parent,
576 * The object is deleted
577 */
579 /*
580 * In slack mode execution, if there is no return value
581 * we should implicitly return zero (0) as a default value.
582 */
585 implicit_return_obj) {
586 previous_walk_state->
587 implicit_return_obj =
588 acpi_ut_create_integer_object
591 implicit_return_obj) {
592 return_ACPI_STATUS
594 }
595 }
597 /* Restart the calling control method */
599 status =
600 acpi_ds_restart_control_method
602 previous_walk_state->
603 implicit_return_obj);
605 /*
606 * We have a valid return value, delete any implicit
607 * return value.
608 */
609 acpi_ds_clear_implicit_return
612 status =
613 acpi_ds_restart_control_method
616 }
619 ACPI_WALK_METHOD_RESTART;
620 }
622 /* On error, delete any return object or implicit return */
625 return_desc);
626 acpi_ds_clear_implicit_return
628 }
629 }
631 /*
632 * Just completed a 1st-level method, save the final internal return
633 * value (if any)
634 */
640 /* NULL if no return value */
644 }
648 /* Caller doesn't want it, must delete it */
651 return_desc);
652 }
655 /* Caller doesn't want it, must delete it */
658 implicit_return_obj);
659 }
660 }
663 }
665 /* Normal exit */
672 }