This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Macros | |
| #define | NAMEOF_LOCAL_NTE "__L0" |
| #define | NAMEOF_ARG_NTE "__A0" |
Macro Definition Documentation
◆ NAMEOF_ARG_NTE
| #define NAMEOF_ARG_NTE "__A0" |
Definition at line 49 of file acdispat.h.
◆ NAMEOF_LOCAL_NTE
| #define NAMEOF_LOCAL_NTE "__L0" |
Definition at line 48 of file acdispat.h.
Function Documentation
◆ AcpiDsAutoSerializeMethod()
| ACPI_STATUS AcpiDsAutoSerializeMethod | ( | ACPI_NAMESPACE_NODE * | Node, |
| ACPI_OPERAND_OBJECT * | ObjDesc | ||
| ) |
Definition at line 94 of file dsmethod.c.
97{
100 ACPI_WALK_STATE *WalkState;
101
102
104
105
107 "Method auto-serialization parse [%4.4s] %p\n",
109
110 /* Create/Init a root op for the method parse tree */
111
113 if (!Op)
114 {
116 }
117
120
121 /* Create and initialize a new walk state */
122
124 if (!WalkState)
125 {
126 AcpiPsFreeOp (Op);
128 }
129
133 {
134 AcpiDsDeleteWalkState (WalkState);
135 AcpiPsFreeOp (Op);
137 }
138
140
141 /* Parse the method, scan for creation of named objects */
142
144
145 AcpiPsDeleteParseTree (Op);
147}
static ACPI_STATUS AcpiDsDetectNamedOpcodes(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT **OutOp)
Definition: dsmethod.c:166
ACPI_WALK_STATE * AcpiDsCreateWalkState(ACPI_OWNER_ID OwnerId, ACPI_PARSE_OBJECT *Origin, ACPI_OPERAND_OBJECT *MethodDesc, ACPI_THREAD_STATE *Thread)
Definition: dswstate.c:600
ACPI_STATUS AcpiDsInitAmlWalk(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, ACPI_NAMESPACE_NODE *MethodNode, UINT8 *AmlStart, UINT32 AmlLength, ACPI_EVALUATE_INFO *Info, UINT8 PassNumber)
Definition: dswstate.c:662
void AcpiDsDeleteWalkState(ACPI_WALK_STATE *WalkState)
Definition: dswstate.c:780
Definition: acstruct.h:74
ACPI_PARSE_DOWNWARDS DescendingCallback
Definition: acstruct.h:128
Definition: aclocal.h:1077
Definition: dlist.c:348
Referenced by AcpiDsInitOneObject().
◆ AcpiDsBeginMethodExecution()
| ACPI_STATUS AcpiDsBeginMethodExecution | ( | ACPI_NAMESPACE_NODE * | MethodNode, |
| ACPI_OPERAND_OBJECT * | ObjDesc, | ||
| ACPI_WALK_STATE * | WalkState | ||
| ) |
Definition at line 352 of file dsmethod.c.
356{
358
359
360 ACPI_FUNCTION_TRACE_PTR (DsBeginMethodExecution, MethodNode);
361
362
363 if (!MethodNode)
364 {
366 }
367
368 AcpiExStartTraceMethod (MethodNode, ObjDesc, WalkState);
369
370 /* Prevent wraparound of thread count */
371
373 {
375 "Method reached maximum reentrancy limit (255)"));
377 }
378
379 /*
380 * If this method is serialized, we need to acquire the method mutex.
381 */
383 {
384 /*
385 * Create a mutex for the method if it is defined to be Serialized
386 * and a mutex has not already been created. We defer the mutex creation
387 * until a method is actually executed, to minimize the object count
388 */
390 {
393 {
395 }
396 }
397
398 /*
399 * The CurrentSyncLevel (per-thread) must be less than or equal to
400 * the sync level of the method. This mechanism provides some
401 * deadlock prevention.
402 *
403 * If the method was auto-serialized, we just ignore the sync level
404 * mechanism, because auto-serialization of methods can interfere
405 * with ASL code that actually uses sync levels.
406 *
407 * Top-level method invocation has no walk state at this point
408 */
409 if (WalkState &&
413 {
415 "Cannot acquire Mutex for method [%4.4s]"
416 ", current SyncLevel is too large (%u)",
417 AcpiUtGetNodeName (MethodNode),
419
421 }
422
423 /*
424 * Obtain the method mutex if necessary. Do not acquire mutex for a
425 * recursive call.
426 */
427 if (!WalkState ||
431 {
432 /*
433 * Acquire the method mutex. This releases the interpreter if we
434 * block (and reacquires it before it returns)
435 */
439 {
441 }
442
443 /* Update the mutex and walk info and save the original SyncLevel */
444
445 if (WalkState)
446 {
449
452
453 /*
454 * Update the current SyncLevel only if this is not an auto-
455 * serialized method. In the auto case, we have to ignore
456 * the sync level for the method mutex (created for the
457 * auto-serialization) because we have no idea of what the
458 * sync level should be. Therefore, just ignore it.
459 */
462 {
465 }
466 }
467 else
468 {
471
473 AcpiOsGetThreadId ();
474 }
475 }
476
477 /* Always increase acquisition depth */
478
480 }
481
482 /*
483 * Allocate an Owner ID for this method, only if this is the first thread
484 * to begin concurrent execution. We only need one OwnerId, even if the
485 * method is invoked recursively.
486 */
488 {
491 {
493 }
494 }
495
496 /*
497 * Increment the method parse tree thread count since it has been
498 * reentered one more time (even if it is the same thread)
499 */
501 AcpiMethodCount++;
503
504
505Cleanup:
506 /* On error, must release the method mutex (if present) */
507
509 {
511 }
513}
ACPI_STATUS AcpiUtAllocateOwnerId(ACPI_OWNER_ID *OwnerId)
Definition: utownerid.c:68
static ACPI_STATUS AcpiDsCreateMethodMutex(ACPI_OPERAND_OBJECT *MethodDesc)
Definition: dsmethod.c:301
ACPI_STATUS AcpiExSystemWaitMutex(ACPI_MUTEX Mutex, UINT16 Timeout)
Definition: exsystem.c:120
void AcpiExStartTraceMethod(ACPI_NAMESPACE_NODE *MethodNode, ACPI_OPERAND_OBJECT *ObjDesc, ACPI_WALK_STATE *WalkState)
Definition: extrace.c:224
ACPI_STATE_COMMON UINT8 CurrentSyncLevel
Definition: aclocal.h:764
Referenced by AcpiDsCallControlMethod(), and AcpiPsExecuteMethod().
◆ AcpiDsBuildInternalBufferObj()
| ACPI_STATUS AcpiDsBuildInternalBufferObj | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_PARSE_OBJECT * | Op, | ||
| UINT32 | BufferLength, | ||
| ACPI_OPERAND_OBJECT ** | ObjDescPtr | ||
| ) |
Definition at line 188 of file dsobject.c.
193{
194 ACPI_PARSE_OBJECT *Arg;
195 ACPI_OPERAND_OBJECT *ObjDesc;
196 ACPI_PARSE_OBJECT *ByteList;
197 UINT32 ByteListLength = 0;
198
199
200 ACPI_FUNCTION_TRACE (DsBuildInternalBufferObj);
201
202
203 /*
204 * If we are evaluating a Named buffer object "Name (xxxx, Buffer)".
205 * The buffer object already exists (from the NS node), otherwise it must
206 * be created.
207 */
208 ObjDesc = *ObjDescPtr;
209 if (!ObjDesc)
210 {
211 /* Create a new buffer object */
212
214 *ObjDescPtr = ObjDesc;
215 if (!ObjDesc)
216 {
218 }
219 }
220
221 /*
222 * Second arg is the buffer data (optional) ByteList can be either
223 * individual bytes or a string initializer. In either case, a
224 * ByteList appears in the AML.
225 */
227
228 ByteList = Arg->Named.Next;
229 if (ByteList)
230 {
232 {
234 "Expecting bytelist, found AML opcode 0x%X in op %p",
235 ByteList->Common.AmlOpcode, ByteList));
236
237 AcpiUtRemoveReference (ObjDesc);
239 }
240
242 }
243
244 /*
245 * The buffer length (number of bytes) will be the larger of:
246 * 1) The specified buffer length and
247 * 2) The length of the initializer byte list
248 */
251 {
252 ObjDesc->Buffer.Length = ByteListLength;
253 }
254
255 /* Allocate the buffer */
256
258 {
261 "Buffer defined with zero length in AML, creating\n"));
262 }
263 else
264 {
265 ObjDesc->Buffer.Pointer =
268 {
269 AcpiUtDeleteObjectDesc (ObjDesc);
271 }
272
273 /* Initialize buffer from the ByteList (if present) */
274
275 if (ByteList)
276 {
278 ByteListLength);
279 }
280 }
281
285}
void AcpiUtRemoveReference(ACPI_OPERAND_OBJECT *Object)
Definition: utdelete.c:790
void AcpiUtDeleteObjectDesc(ACPI_OPERAND_OBJECT *Object)
Definition: utobject.c:473
Definition: aclocal.h:186
Definition: acobject.h:518
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG BufferLength
Definition: wdfdevice.h:3771
Referenced by AcpiDsEvalDataObjectOperands().
◆ AcpiDsBuildInternalObject()
| ACPI_STATUS AcpiDsBuildInternalObject | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_PARSE_OBJECT * | Op, | ||
| ACPI_OPERAND_OBJECT ** | ObjDescPtr | ||
| ) |
Definition at line 72 of file dsobject.c.
76{
77 ACPI_OPERAND_OBJECT *ObjDesc;
79
80
81 ACPI_FUNCTION_TRACE (DsBuildInternalObject);
82
83
84 *ObjDescPtr = NULL;
86 {
87 /*
88 * This is a named object reference. If this name was
89 * previously looked up in the namespace, it was stored in
90 * this op. Otherwise, go ahead and look it up now
91 */
93 {
94 /* Check if we are resolving a named reference within a package */
95
98 {
99 /*
100 * We won't resolve package elements here, we will do this
101 * after all ACPI tables are loaded into the namespace. This
102 * behavior supports both forward references to named objects
103 * and external references to objects in other tables.
104 */
105 goto CreateNewObject;
106 }
107 else
108 {
110 Op->Common.Value.String,
113 ACPI_CAST_INDIRECT_PTR (
116 {
120 }
121 }
122 }
123 }
124
125CreateNewObject:
126
127 /* Create and init a new internal ACPI object */
128
129 ObjDesc = AcpiUtCreateInternalObject (
131 if (!ObjDesc)
132 {
134 }
135
137 WalkState, Op, Op->Common.AmlOpcode, &ObjDesc);
139 {
140 AcpiUtRemoveReference (ObjDesc);
142 }
143
144 /*
145 * Handling for unresolved package reference elements.
146 * These are elements that are namepaths.
147 */
150 {
152
155 {
156 /*
157 * Name was unresolved above.
158 * Get the prefix node for later lookup
159 */
163 }
164 }
165
166 *ObjDescPtr = ObjDesc;
168}
ACPI_STATUS AcpiNsLookup(ACPI_GENERIC_STATE *ScopeInfo, char *Name, ACPI_OBJECT_TYPE Type, ACPI_INTERPRETER_MODE InterpreterMode, UINT32 Flags, ACPI_WALK_STATE *WalkState, ACPI_NAMESPACE_NODE **RetNode)
Definition: nsaccess.c:328
const ACPI_OPCODE_INFO * AcpiPsGetOpcodeInfo(UINT16 Opcode)
Definition: psopinfo.c:72
ACPI_STATUS AcpiDsInitObjectFromOp(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, UINT16 Opcode, ACPI_OPERAND_OBJECT **RetObjDesc)
Definition: dsobject.c:373
Referenced by AcpiDsBuildInternalPackageObj(), and AcpiDsCreateNode().
◆ AcpiDsBuildInternalPackageObj()
| ACPI_STATUS AcpiDsBuildInternalPackageObj | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_PARSE_OBJECT * | op, | ||
| UINT32 | PackageLength, | ||
| ACPI_OPERAND_OBJECT ** | ObjDesc | ||
| ) |
Definition at line 94 of file dspkginit.c.
99{
100 ACPI_PARSE_OBJECT *Arg;
105 UINT16 ReferenceCount;
108
109
110 ACPI_FUNCTION_TRACE (DsBuildInternalPackageObj);
111
112
113 /* Check if we are executing module level code */
114
116 {
117 ModuleLevelCode = TRUE;
118 }
119
120 /* Find the parent of a possibly nested package */
121
122 Parent = Op->Common.Parent;
125 {
127 }
128
129 /*
130 * If we are evaluating a Named package object of the form:
131 * Name (xxxx, Package)
132 * the package object already exists, otherwise it must be created.
133 */
134 ObjDesc = *ObjDescPtr;
135 if (!ObjDesc)
136 {
138 *ObjDescPtr = ObjDesc;
139 if (!ObjDesc)
140 {
142 }
143
145 }
146
148 {
150 }
151
152 /*
153 * Allocate the element array (array of pointers to the individual
154 * objects) if necessary. the count is based on the NumElements
155 * parameter. Add an extra pointer slot so that the list is always
156 * null terminated.
157 */
159 {
161 ((ACPI_SIZE) ElementCount + 1) * sizeof (void *));
162
164 {
165 AcpiUtDeleteObjectDesc (ObjDesc);
167 }
168
170 }
171
172 /* First arg is element count. Second arg begins the initializer list */
173
174 Arg = Op->Common.Value.Arg;
175 Arg = Arg->Common.Next;
176
177 /*
178 * If we are executing module-level code, we will defer the
179 * full resolution of the package elements in order to support
180 * forward references from the elements. This provides
181 * compatibility with other ACPI implementations.
182 */
183 if (ModuleLevelCode)
184 {
187
189 "%s: Deferring resolution of Package elements\n",
190 ACPI_GET_FUNCTION_NAME));
191 }
192
193 /*
194 * Initialize the elements of the package, up to the NumElements count.
195 * Package is automatically padded with uninitialized (NULL) elements
196 * if NumElements is greater than the package list length. Likewise,
197 * Package is truncated if NumElements is less than the list length.
198 */
200 {
202 {
204 {
205 /*
206 * This is the case where an expression has returned a value.
207 * The use of expressions (TermArgs) within individual
208 * package elements is not supported by the AML interpreter,
209 * even though the ASL grammar supports it. Example:
210 *
211 * Name (INT1, 0x1234)
212 *
213 * Name (PKG3, Package () {
214 * Add (INT1, 0xAAAA0000)
215 * })
216 *
217 * 1) No known AML interpreter supports this type of construct
218 * 2) This fixes a fault if the construct is encountered
219 */
221 "Expressions within package elements are not supported"));
222
223 /* Cleanup the return object, it is not needed */
224
227 }
228
230 {
231 /*
232 * A method reference "looks" to the parser to be a method
233 * invocation, so we special case it here
234 */
238 }
239 else
240 {
241 /* This package element is already built, just get it */
242
245 }
246 }
247 else
248 {
252 {
254 }
255
256 if (!ModuleLevelCode)
257 {
258 /*
259 * Initialize this package element. This function handles the
260 * resolution of named references within the package.
261 * Forward references from module-level code are deferred
262 * until all ACPI tables are loaded.
263 */
266 }
267 }
268
269 if (*ObjDescPtr)
270 {
271 /* Existing package, get existing reference count */
272
273 ReferenceCount = (*ObjDescPtr)->Common.ReferenceCount;
274 if (ReferenceCount > 1)
275 {
276 /* Make new element ref count match original ref count */
277 /* TBD: Probably need an AcpiUtAddReferences function */
278
280 {
282 }
283 }
284 }
285
286 Arg = Arg->Common.Next;
287 }
288
289 /* Check for match between NumElements and actual length of PackageList */
290
291 if (Arg)
292 {
293 /*
294 * NumElements was exhausted, but there are remaining elements in
295 * the PackageList. Truncate the package to NumElements.
296 *
297 * Note: technically, this is an error, from ACPI spec: "It is an
298 * error for NumElements to be less than the number of elements in
299 * the PackageList". However, we just print a message and no
300 * exception is returned. This provides compatibility with other
301 * ACPI implementations. Some firmware implementations will alter
302 * the NumElements on the fly, possibly creating this type of
303 * ill-formed package object.
304 */
305 while (Arg)
306 {
307 /*
308 * We must delete any package elements that were created earlier
309 * and are not going to be used because of the package truncation.
310 */
312 {
313 AcpiUtRemoveReference (
316 }
317
318 /* Find out how many elements there really are */
319
320 i++;
321 Arg = Arg->Common.Next;
322 }
323
324 ACPI_INFO ((
325 "Actual Package length (%u) is larger than "
326 "NumElements field (%u), truncated",
327 i, ElementCount));
328 }
330 {
331 /*
332 * Arg list (elements) was exhausted, but we did not reach
333 * NumElements count.
334 *
335 * Note: this is not an error, the package is padded out
336 * with NULLs as per the ACPI specification.
337 */
339 "%s: Package List length (%u) smaller than NumElements "
340 "count (%u), padded with null elements\n",
342 }
343
344 /* Module-level packages will be resolved later */
345
346 if (!ModuleLevelCode)
347 {
349 }
350
353}
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn UINT32 *TableIdx UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE Parent
Definition: acpixf.h:732
ACPI_STATUS AcpiDsBuildInternalObject(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, ACPI_OPERAND_OBJECT **ObjDescPtr)
Definition: dsobject.c:72
ACPI_STATUS AcpiDsInitPackageElement(UINT8 ObjectType, ACPI_OPERAND_OBJECT *SourceObject, ACPI_GENERIC_STATE *State, void *Context)
Definition: dspkginit.c:369
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
ACPI_OBJECT_COMMON_HEADER ACPI_NAMESPACE_NODE * Node
Definition: acobject.h:160
ACPI_STATE_COMMON union acpi_operand_object * ObjDesc[ACPI_RESULTS_FRAME_OBJ_NUM]
Definition: aclocal.h:779
Referenced by AcpiDsEvalDataObjectOperands().
◆ AcpiDsCallControlMethod()
| ACPI_STATUS AcpiDsCallControlMethod | ( | ACPI_THREAD_STATE * | Thread, |
| ACPI_WALK_STATE * | WalkState, | ||
| ACPI_PARSE_OBJECT * | Op | ||
| ) |
Definition at line 531 of file dsmethod.c.
535{
537 ACPI_NAMESPACE_NODE *MethodNode;
539 ACPI_OPERAND_OBJECT *ObjDesc;
542
543
544 ACPI_FUNCTION_TRACE_PTR (DsCallControlMethod, ThisWalkState);
545
547 "Calling method %p, currentstate=%p\n",
548 ThisWalkState->PrevOp, ThisWalkState));
549
550 /*
551 * Get the namespace entry for the control method we are about to call
552 */
553 MethodNode = ThisWalkState->MethodCallNode;
554 if (!MethodNode)
555 {
557 }
558
559 ObjDesc = AcpiNsGetAttachedObject (MethodNode);
560 if (!ObjDesc)
561 {
563 }
564
565 /* Init for new method, possibly wait on method mutex */
566
568 MethodNode, ObjDesc, ThisWalkState);
570 {
572 }
573
574 /* Begin method parse/execution. Create a new walk state */
575
576 NextWalkState = AcpiDsCreateWalkState (
578 if (!NextWalkState)
579 {
582 }
583
584 /*
585 * The resolved arguments were put on the previous walk state's operand
586 * stack. Operands on the previous walk state stack always
587 * start at index 0. Also, null terminate the list of arguments
588 */
589 ThisWalkState->Operands [ThisWalkState->NumOperands] = NULL;
590
591 /*
592 * Allocate and initialize the evaluation information block
593 * TBD: this is somewhat inefficient, should change interface to
594 * DsInitAmlWalk. For now, keeps this struct off the CPU stack
595 */
598 {
601 }
602
603 Info->Parameters = &ThisWalkState->Operands[0];
604
608
611 {
613 }
614
615 NextWalkState->MethodNestingDepth = ThisWalkState->MethodNestingDepth + 1;
616
617 /*
618 * Delete the operands on the previous walkstate operand stack
619 * (they were copied to new objects)
620 */
622 {
625 }
626
627 /* Clear the operand stack */
628
629 ThisWalkState->NumOperands = 0;
630
632 "**** Begin nested execution of [%4.4s] **** WalkState=%p\n",
634
636 ThisWalkState->MethodIsNested = TRUE;
637
638 /* Optional object evaluation log */
639
641 "%-26s: %*s%s\n", " Nested method call",
643 &ThisWalkState->MethodPathname[1]));
644
645 /* Invoke an internal method if necessary */
646
648 {
651 {
653 }
654 }
655
657
658
659Cleanup:
660
661 /* On error, we must terminate the method properly */
662
663 AcpiDsTerminateControlMethod (ObjDesc, NextWalkState);
664 AcpiDsDeleteWalkState (NextWalkState);
665
667}
char * AcpiNsGetNormalizedPathname(ACPI_NAMESPACE_NODE *Node, BOOLEAN NoTrailing)
Definition: nsnames.c:367
ACPI_OPERAND_OBJECT * AcpiNsGetAttachedObject(ACPI_NAMESPACE_NODE *Node)
Definition: nsobject.c:308
void AcpiDsTerminateControlMethod(ACPI_OPERAND_OBJECT *MethodDesc, ACPI_WALK_STATE *WalkState)
Definition: dsmethod.c:779
ACPI_STATUS AcpiDsBeginMethodExecution(ACPI_NAMESPACE_NODE *MethodNode, ACPI_OPERAND_OBJECT *ObjDesc, ACPI_WALK_STATE *WalkState)
Definition: dsmethod.c:352
Definition: acstruct.h:204
union acpi_object_method::@610 Dispatch
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:690
Referenced by AcpiPsParseAml().
◆ AcpiDsClearImplicitReturn()
| void AcpiDsClearImplicitReturn | ( | ACPI_WALK_STATE * | WalkState | ) |
Definition at line 73 of file dsutils.c.
75{
76 ACPI_FUNCTION_NAME (DsClearImplicitReturn);
77
78
79 /*
80 * Slack must be enabled for this feature
81 */
82 if (!AcpiGbl_EnableInterpreterSlack)
83 {
84 return;
85 }
86
88 {
89 /*
90 * Delete any "stale" implicit return. However, in
91 * complex statements, the implicit return value can be
92 * bubbled up several levels.
93 */
95 "Removing reference on stale implicit return obj %p\n",
96 WalkState->ImplicitReturnObj));
97
100 }
101}
union acpi_operand_object * ImplicitReturnObj
Definition: acstruct.h:112
Referenced by AcpiDsDoImplicitReturn(), AcpiDsExecEndControlOp(), AcpiDsMethodError(), and AcpiPsParseAml().
◆ AcpiDsClearOperands()
| void AcpiDsClearOperands | ( | ACPI_WALK_STATE * | WalkState | ) |
Definition at line 453 of file dsutils.c.
455{
457
458
459 ACPI_FUNCTION_TRACE_PTR (DsClearOperands, WalkState);
460
461
462 /* Remove a reference on each operand on the stack */
463
465 {
466 /*
467 * Remove a reference to all operands, including both
468 * "Arguments" and "Targets".
469 */
472 }
473
474 WalkState->NumOperands = 0;
475 return_VOID;
476}
union acpi_operand_object * Operands[ACPI_OBJ_NUM_OPERANDS+1]
Definition: acstruct.h:105
Referenced by AcpiDsExecEndOp().
◆ AcpiDsCreateBankField()
| ACPI_STATUS AcpiDsCreateBankField | ( | ACPI_PARSE_OBJECT * | Op, |
| ACPI_NAMESPACE_NODE * | RegionNode, | ||
| ACPI_WALK_STATE * | WalkState | ||
| ) |
Definition at line 748 of file dsfield.c.
752{
754 ACPI_PARSE_OBJECT *Arg;
756
757
758 ACPI_FUNCTION_TRACE_PTR (DsCreateBankField, Op);
759
760
761 /* First arg is the name of the parent OpRegion (must already exist) */
762
763 Arg = Op->Common.Value.Arg;
764 if (!RegionNode)
765 {
768 ACPI_NS_SEARCH_PARENT, WalkState, &RegionNode);
769#ifdef ACPI_ASL_COMPILER
771 Arg->Common.Value.Name, WalkState, &RegionNode);
772#endif
774 {
778 }
779 }
780
781 /* Second arg is the Bank Register (Field) (must already exist) */
782
783 Arg = Arg->Common.Next;
788 {
792 }
793
794 /*
795 * Third arg is the BankValue
796 * This arg is a TermArg, not a constant
797 * It will be evaluated later, by AcpiDsEvalBankFieldOperands
798 */
799 Arg = Arg->Common.Next;
800
801 /* Fourth arg is the field flags */
802
803 Arg = Arg->Common.Next;
805
806 /* Each remaining arg is a Named Field */
807
809 Info.RegionNode = RegionNode;
810
811 /*
812 * Use Info.DataRegisterNode to store BankField Op
813 * It's safe because DataRegisterNode will never be used when create
814 * bank field \we store AmlStart and AmlLength in the BankField Op for
815 * late evaluation. Used in AcpiExPrepFieldValue(Info)
816 *
817 * TBD: Or, should we add a field in ACPI_CREATE_FIELD_INFO, like
818 * "void *ParentOp"?
819 */
821
824}
static ACPI_STATUS AcpiDsGetFieldNames(ACPI_CREATE_FIELD_INFO *Info, ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Arg)
Definition: dsfield.c:324
Definition: aclocal.h:303
Referenced by AcpiDsLoad2EndOp().
◆ AcpiDsCreateBufferField()
| ACPI_STATUS AcpiDsCreateBufferField | ( | ACPI_PARSE_OBJECT * | Op, |
| ACPI_WALK_STATE * | WalkState | ||
| ) |
Definition at line 165 of file dsfield.c.
168{
169 ACPI_PARSE_OBJECT *Arg;
172 ACPI_OPERAND_OBJECT *ObjDesc;
175
176
177 ACPI_FUNCTION_TRACE (DsCreateBufferField);
178
179
180 /*
181 * Get the NameString argument (name of the new BufferField)
182 */
184 {
185 /* For CreateField, name is the 4th argument */
186
187 Arg = AcpiPsGetArg (Op, 3);
188 }
189 else
190 {
191 /* For all other CreateXXXField operators, name is the 3rd argument */
192
193 Arg = AcpiPsGetArg (Op, 2);
194 }
195
196 if (!Arg)
197 {
199 }
200
202 {
204 }
205 else
206 {
207 /* Execute flag should always be set when this function is entered */
208
210 {
212 "Parse execute mode is not set"));
214 }
215
216 /* Creating new namespace node, should not already exist */
217
220
221 /*
222 * Mark node temporary if we are executing a normal control
223 * method. (Don't mark if this is a module-level code method)
224 */
227 {
229 }
230
231 /* Enter the NameString into the namespace */
232
238 {
240 }
242 {
246 }
247 }
248
249 /*
250 * We could put the returned object (Node) on the object stack for later,
251 * but for now, we will put it in the "op" object that the parser uses,
252 * so we can get it again at the end of this scope.
253 */
255
256 /*
257 * If there is no object attached to the node, this node was just created
258 * and we need to create the field object. Otherwise, this was a lookup
259 * of an existing node and we don't want to create the field object again.
260 */
262 if (ObjDesc)
263 {
265 }
266
267 /*
268 * The Field definition is not fully parsed at this time.
269 * (We must save the address of the AML for the buffer and index operands)
270 */
271
272 /* Create the buffer field object */
273
275 if (!ObjDesc)
276 {
279 }
280
281 /*
282 * Remember location in AML stream of the field unit opcode and operands
283 * -- since the buffer and index operands must be evaluated.
284 */
285 SecondDesc = ObjDesc->Common.NextObject;
289
290 /* Attach constructed field descriptors to parent node */
291
294 {
296 }
297
298
299Cleanup:
300
301 /* Remove local reference to the object */
302
303 AcpiUtRemoveReference (ObjDesc);
305}
ACPI_STATUS AcpiNsAttachObject(ACPI_NAMESPACE_NODE *Node, ACPI_OPERAND_OBJECT *Object, ACPI_OBJECT_TYPE Type)
Definition: nsobject.c:76
ACPI_PARSE_OBJECT * AcpiPsGetArg(ACPI_PARSE_OBJECT *op, UINT32 argn)
Definition: pstree.c:76
Referenced by AcpiDsLoad1EndOp(), and AcpiDsLoad2EndOp().
◆ AcpiDsCreateField()
| ACPI_STATUS AcpiDsCreateField | ( | ACPI_PARSE_OBJECT * | Op, |
| ACPI_NAMESPACE_NODE * | RegionNode, | ||
| ACPI_WALK_STATE * | WalkState | ||
| ) |
Definition at line 534 of file dsfield.c.
538{
540 ACPI_PARSE_OBJECT *Arg;
542
543
544 ACPI_FUNCTION_TRACE_PTR (DsCreateField, Op);
545
546
547 /* First arg is the name of the parent OpRegion (must already exist) */
548
549 Arg = Op->Common.Value.Arg;
550
551 if (!RegionNode)
552 {
555 ACPI_NS_SEARCH_PARENT, WalkState, &RegionNode);
556#ifdef ACPI_ASL_COMPILER
558 Arg->Common.Value.Name, WalkState, &RegionNode);
559#endif
561 {
565 }
566 }
567
569
570 /* Second arg is the field flags */
571
572 Arg = Arg->Common.Next;
574 Info.Attribute = 0;
575
576 /* Each remaining arg is a Named Field */
577
579 Info.RegionNode = RegionNode;
580
583 {
585 }
586
588 {
592 {
594 }
595 }
596
598}
Referenced by AcpiDsLoad2EndOp().
◆ AcpiDsCreateIndexField()
| ACPI_STATUS AcpiDsCreateIndexField | ( | ACPI_PARSE_OBJECT * | Op, |
| ACPI_NAMESPACE_NODE * | RegionNode, | ||
| ACPI_WALK_STATE * | WalkState | ||
| ) |
Definition at line 842 of file dsfield.c.
846{
848 ACPI_PARSE_OBJECT *Arg;
850
851
852 ACPI_FUNCTION_TRACE_PTR (DsCreateIndexField, Op);
853
854
855 /* First arg is the name of the Index register (must already exist) */
856
857 Arg = Op->Common.Value.Arg;
862 {
866 }
867
868 /* Second arg is the data register (must already exist) */
869
870 Arg = Arg->Common.Next;
875 {
879 }
880
881 /* Next arg is the field flags */
882
883 Arg = Arg->Common.Next;
885
886 /* Each remaining arg is a Named Field */
887
889 Info.RegionNode = RegionNode;
890
893}
Referenced by AcpiDsLoad2EndOp().
◆ AcpiDsCreateNode()
| ACPI_STATUS AcpiDsCreateNode | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_NAMESPACE_NODE * | Node, | ||
| ACPI_PARSE_OBJECT * | Op | ||
| ) |
Definition at line 302 of file dsobject.c.
306{
308 ACPI_OPERAND_OBJECT *ObjDesc;
309
310
311 ACPI_FUNCTION_TRACE_PTR (DsCreateNode, Op);
312
313
314 /*
315 * Because of the execution pass through the non-control-method
316 * parts of the table, we can arrive here twice. Only init
317 * the named object node the first time through
318 */
320 {
322 }
323
325 {
326 /* No arguments, there is nothing to do */
327
329 }
330
331 /* Build an internal object for the argument(s) */
332
334 WalkState, Op->Common.Value.Arg, &ObjDesc);
336 {
338 }
339
340 /* Re-type the object according to its argument */
341
343
344 /* Attach obj to node */
345
347
348 /* Remove local reference to the object */
349
350 AcpiUtRemoveReference (ObjDesc);
352}
Referenced by AcpiDsExecEndOp(), and AcpiDsLoad2EndOp().
◆ AcpiDsCreateOperand()
| ACPI_STATUS AcpiDsCreateOperand | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_PARSE_OBJECT * | Arg, | ||
| UINT32 | ArgsRemaining | ||
| ) |
Definition at line 497 of file dsutils.c.
501{
503 char *NameString;
504 UINT32 NameLength;
505 ACPI_OPERAND_OBJECT *ObjDesc;
506 ACPI_PARSE_OBJECT *ParentOp;
508 ACPI_INTERPRETER_MODE InterpreterMode;
510
511
512 ACPI_FUNCTION_TRACE_PTR (DsCreateOperand, Arg);
513
514
515 /* A valid name must be looked up in the namespace */
516
518 (Arg->Common.Value.String) &&
520 {
522
523 /* Get the entire name string from the AML stream */
524
526 Arg->Common.Value.Buffer, &NameString, &NameLength);
527
529 {
531 }
532
533 /* All prefixes have been handled, and the name is in NameString */
534
535 /*
536 * Special handling for BufferField declarations. This is a deferred
537 * opcode that unfortunately defines the field name as the last
538 * parameter instead of the first. We get here when we are performing
539 * the deferred execution, so the actual name of the field is already
540 * in the namespace. We don't want to attempt to look it up again
541 * because we may be executing in a different scope than where the
542 * actual opcode exists.
543 */
546 (ArgIndex == (UINT32)
548 {
549 ObjDesc = ACPI_CAST_PTR (
552 }
553 else /* All other opcodes */
554 {
555 /*
556 * Differentiate between a namespace "create" operation
557 * versus a "lookup" operation (IMODE_LOAD_PASS2 vs.
558 * IMODE_EXECUTE) in order to support the creation of
559 * namespace objects during the execution of control methods.
560 */
561 ParentOp = Arg->Common.Parent;
563
568 {
569 /* Enter name into namespace if not found */
570
571 InterpreterMode = ACPI_IMODE_LOAD_PASS2;
572 }
573 else
574 {
575 /* Return a failure if name not found */
576
577 InterpreterMode = ACPI_IMODE_EXECUTE;
578 }
579
581 ACPI_TYPE_ANY, InterpreterMode,
584 /*
585 * The only case where we pass through (ignore) a NOT_FOUND
586 * error is for the CondRefOf opcode.
587 */
589 {
591 {
592 /*
593 * For the Conditional Reference op, it's OK if
594 * the name is not found; We just need a way to
595 * indicate this to the interpreter, set the
596 * object to the root
597 */
598 ObjDesc = ACPI_CAST_PTR (
599 ACPI_OPERAND_OBJECT, AcpiGbl_RootNode);
601 }
603 {
604 /*
605 * This opcode should never appear here. It is used only
606 * by AML disassemblers and is surrounded by an If(0)
607 * by the ASL compiler.
608 *
609 * Therefore, if we see it here, it is a serious error.
610 */
612 }
613 else
614 {
615 /*
616 * We just plain didn't find it -- which is a
617 * very serious error at this point
618 */
620 }
621 }
622
624 {
626 NameString, Status);
627 }
628 }
629
630 /* Free the namestring created above */
631
632 ACPI_FREE (NameString);
633
634 /* Check status from the lookup */
635
637 {
639 }
640
641 /* Put the resulting object onto the current object stack */
642
645 {
647 }
648
649 AcpiDbDisplayArgumentObject (ObjDesc, WalkState);
650 }
651 else
652 {
653 /* Check for null name case */
654
657 {
658 /*
659 * If the name is null, this means that this is an
660 * optional result parameter that was not specified
661 * in the original ASL. Create a Zero Constant for a
662 * placeholder. (Store to a constant is a Noop.)
663 */
665
667 "Null namepath: Arg=%p\n", Arg));
668 }
669 else
670 {
672 }
673
674 /* Get the object type of the argument */
675
678 {
680 }
681
684 {
685 /*
686 * Use value that was already previously returned
687 * by the evaluation of this argument
688 */
691 {
692 /*
693 * Only error is underflow, and this indicates
694 * a missing or null operand!
695 */
697 "Missing or null operand"));
699 }
700 }
701 else
702 {
703 /* Create an ACPI_INTERNAL_OBJECT for the argument */
704
706 if (!ObjDesc)
707 {
709 }
710
711 /* Initialize the new object */
712
714 WalkState, Arg, Opcode, &ObjDesc);
716 {
717 AcpiUtDeleteObjectDesc (ObjDesc);
719 }
720 }
721
722 /* Put the operand object on the object stack */
723
726 {
728 }
729
730 AcpiDbDisplayArgumentObject (ObjDesc, WalkState);
731 }
732
734}
ACPI_STATUS AcpiDsResultPop(ACPI_OPERAND_OBJECT **Object, ACPI_WALK_STATE *WalkState)
Definition: dswstate.c:78
ACPI_STATUS AcpiDsObjStackPush(void *Object, ACPI_WALK_STATE *WalkState)
Definition: dswstate.c:342
ACPI_STATUS AcpiExGetNameString(ACPI_OBJECT_TYPE DataType, UINT8 *InAmlAddress, char **OutNameString, UINT32 *OutNameLength)
Definition: exnames.c:278
Definition: aclocal.h:867
Referenced by AcpiDsCreateOperands(), AcpiDsEvalBankFieldOperands(), AcpiDsEvalDataObjectOperands(), AcpiDsEvaluateNamePath(), and AcpiDsGetPredicateValue().
◆ AcpiDsCreateOperands()
| ACPI_STATUS AcpiDsCreateOperands | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_PARSE_OBJECT * | FirstArg | ||
| ) |
Definition at line 753 of file dsutils.c.
756{
758 ACPI_PARSE_OBJECT *Arg;
760 UINT32 ArgCount = 0;
763
764
765 ACPI_FUNCTION_TRACE_PTR (DsCreateOperands, FirstArg);
766
767
768 /* Get all arguments in the list */
769
770 Arg = FirstArg;
771 while (Arg)
772 {
774 {
776 }
777
778 Arguments[Index] = Arg;
780
781 /* Move on to next argument, if any */
782
783 Arg = Arg->Common.Next;
784 ArgCount++;
785 Index++;
786 }
787
789 "NumOperands %d, ArgCount %d, Index %d\n",
791
792 /* Create the interpreter arguments, in reverse order */
793
794 Index--;
796 {
797 Arg = Arguments[Index];
799
802 {
804 }
805
807 "Created Arg #%u (%p) %u args total\n",
808 Index, Arg, ArgCount));
809 Index--;
810 }
811
813
814
815Cleanup:
816 /*
817 * We must undo everything done above; meaning that we must
818 * pop everything off of the operand stack and delete those
819 * objects
820 */
821 AcpiDsObjStackPopAndDelete (ArgCount, WalkState);
822
825}
ACPI_STATUS AcpiDsCreateOperand(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Arg, UINT32 ArgIndex)
Definition: dsutils.c:497
void AcpiDsObjStackPopAndDelete(UINT32 PopCount, ACPI_WALK_STATE *WalkState)
Definition: dswstate.c:441
Referenced by AcpiDsEvalBufferFieldOperands(), AcpiDsEvalRegionOperands(), AcpiDsEvalTableRegionOperands(), AcpiDsExecEndControlOp(), AcpiDsExecEndOp(), AcpiDsLoad1EndOp(), and AcpiDsLoad2EndOp().
◆ AcpiDsCreateWalkState()
| ACPI_WALK_STATE * AcpiDsCreateWalkState | ( | ACPI_OWNER_ID | OwnerId, |
| ACPI_PARSE_OBJECT * | Origin, | ||
| ACPI_OPERAND_OBJECT * | MthDesc, | ||
| ACPI_THREAD_STATE * | Thread | ||
| ) |
Definition at line 600 of file dswstate.c.
605{
606 ACPI_WALK_STATE *WalkState;
607
608
609 ACPI_FUNCTION_TRACE (DsCreateWalkState);
610
611
613 if (!WalkState)
614 {
616 }
617
619 WalkState->MethodDesc = MethodDesc;
621 WalkState->Origin = Origin;
623
625
626 /* Init the method args/local */
627
628#ifndef ACPI_CONSTANT_EVAL_ONLY
629 AcpiDsMethodDataInit (WalkState);
630#endif
631
632 /* Put the new state at the head of the walk list */
633
635 {
637 }
638
639 return_PTR (WalkState);
640}
void AcpiDsPushWalkState(ACPI_WALK_STATE *WalkState, ACPI_THREAD_STATE *Thread)
Definition: dswstate.c:526
Referenced by AcpiDsAutoSerializeMethod(), AcpiDsCallControlMethod(), AcpiDsExecuteArguments(), AcpiNsOneCompleteParse(), AcpiPsExecuteMethod(), and AcpiPsExecuteTable().
◆ AcpiDsDeleteResultIfNotUsed()
| void AcpiDsDeleteResultIfNotUsed | ( | ACPI_PARSE_OBJECT * | Op, |
| ACPI_OPERAND_OBJECT * | ResultObj, | ||
| ACPI_WALK_STATE * | WalkState | ||
| ) |
Definition at line 359 of file dsutils.c.
363{
364 ACPI_OPERAND_OBJECT *ObjDesc;
366
367
368 ACPI_FUNCTION_TRACE_PTR (DsDeleteResultIfNotUsed, ResultObj);
369
370
371 if (!Op)
372 {
374 return_VOID;
375 }
376
377 if (!ResultObj)
378 {
379 return_VOID;
380 }
381
383 {
384 /* Must pop the result stack (ObjDesc should be equal to ResultObj) */
385
388 {
389 AcpiUtRemoveReference (ResultObj);
390 }
391 }
392
393 return_VOID;
394}
BOOLEAN AcpiDsIsResultUsed(ACPI_PARSE_OBJECT *Op, ACPI_WALK_STATE *WalkState)
Definition: dsutils.c:187
Referenced by AcpiDsExecEndOp().
◆ AcpiDsDeleteWalkState()
| void AcpiDsDeleteWalkState | ( | ACPI_WALK_STATE * | WalkState | ) |
Definition at line 780 of file dswstate.c.
782{
784
785
786 ACPI_FUNCTION_TRACE_PTR (DsDeleteWalkState, WalkState);
787
788
789 if (!WalkState)
790 {
791 return_VOID;
792 }
793
795 {
797 WalkState));
798 return_VOID;
799 }
800
801 /* There should not be any open scopes */
802
804 {
806 WalkState));
808 }
809
810 /* Always must free any linked control states */
811
813 {
816
818 }
819
820 /* Always must free any linked parse states */
821
823 {
826
828 }
829
830 /* Always must free any stacked result states */
831
833 {
836
838 }
839
840 ACPI_FREE (WalkState);
841 return_VOID;
842}
void AcpiUtDeleteGenericState(ACPI_GENERIC_STATE *State)
Definition: utstate.c:340
Definition: stack_allocator.h:18
Definition: aclocal.h:821
Referenced by AcpiDsAutoSerializeMethod(), AcpiDsCallControlMethod(), AcpiDsExecuteArguments(), AcpiNsOneCompleteParse(), AcpiPsExecuteMethod(), AcpiPsExecuteTable(), and AcpiPsParseAml().
◆ AcpiDsDoImplicitReturn()
| BOOLEAN AcpiDsDoImplicitReturn | ( | ACPI_OPERAND_OBJECT * | ReturnDesc, |
| ACPI_WALK_STATE * | WalkState, | ||
| BOOLEAN | AddReference | ||
| ) |
Definition at line 123 of file dsutils.c.
127{
128 ACPI_FUNCTION_NAME (DsDoImplicitReturn);
129
130
131 /*
132 * Slack must be enabled for this feature, and we must
133 * have a valid return object
134 */
135 if ((!AcpiGbl_EnableInterpreterSlack) ||
136 (!ReturnDesc))
137 {
139 }
140
142 "Result %p will be implicitly returned; Prev=%p\n",
143 ReturnDesc,
144 WalkState->ImplicitReturnObj));
145
146 /*
147 * Delete any "stale" implicit return value first. However, in
148 * complex statements, the implicit return value can be
149 * bubbled up several levels, so we don't clear the value if it
150 * is the same as the ReturnDesc.
151 */
153 {
155 {
157 }
158 AcpiDsClearImplicitReturn (WalkState);
159 }
160
161 /* Save the implicit return value, add a reference if requested */
162
163 WalkState->ImplicitReturnObj = ReturnDesc;
164 if (AddReference)
165 {
166 AcpiUtAddReference (ReturnDesc);
167 }
168
170}
void AcpiDsClearImplicitReturn(ACPI_WALK_STATE *WalkState)
Definition: dsutils.c:73
Referenced by AcpiDsGetPredicateValue(), AcpiDsIsResultUsed(), and AcpiDsRestartControlMethod().
◆ AcpiDsDumpMethodStack()
| void AcpiDsDumpMethodStack | ( | ACPI_STATUS | Status, |
| ACPI_WALK_STATE * | WalkState, | ||
| ACPI_PARSE_OBJECT * | Op | ||
| ) |
◆ AcpiDsEvalBankFieldOperands()
| ACPI_STATUS AcpiDsEvalBankFieldOperands | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_PARSE_OBJECT * | Op | ||
| ) |
Definition at line 755 of file dsopcode.c.
758{
760 ACPI_OPERAND_OBJECT *ObjDesc;
761 ACPI_OPERAND_OBJECT *OperandDesc;
763 ACPI_PARSE_OBJECT *NextOp;
764 ACPI_PARSE_OBJECT *Arg;
765
766
767 ACPI_FUNCTION_TRACE_PTR (DsEvalBankFieldOperands, Op);
768
769
770 /*
771 * This is where we evaluate the BankValue field of the
772 * BankField declaration
773 */
774
775 /* NextOp points to the op that holds the Region */
776
777 NextOp = Op->Common.Value.Arg;
778
779 /* NextOp points to the op that holds the Bank Register */
780
781 NextOp = NextOp->Common.Next;
782
783 /* NextOp points to the op that holds the Bank Value */
784
785 NextOp = NextOp->Common.Next;
786
787 /*
788 * Set proper index into operand stack for AcpiDsObjStackPush
789 * invoked inside AcpiDsCreateOperand.
790 *
791 * We use WalkState->Operands[0] to store the evaluated BankValue
792 */
793 WalkState->OperandIndex = 0;
794
797 {
799 }
800
803 {
805 }
806
809 /*
810 * Get the BankValue operand and save it
811 * (at Top of stack)
812 */
813 OperandDesc = WalkState->Operands[0];
814
815 /* Arg points to the start Bank Field */
816
817 Arg = AcpiPsGetArg (Op, 4);
818 while (Arg)
819 {
820 /* Ignore OFFSET and ACCESSAS terms here */
821
823 {
825
827 if (!ObjDesc)
828 {
830 }
831
833 }
834
835 /* Move to next field in the list */
836
837 Arg = Arg->Common.Next;
838 }
839
840 AcpiUtRemoveReference (OperandDesc);
842}
ACPI_STATUS AcpiExResolveToValue(ACPI_OPERAND_OBJECT **StackPtr, ACPI_WALK_STATE *WalkState)
Definition: exresolv.c:79
Referenced by AcpiDsExecEndOp().
◆ AcpiDsEvalBufferFieldOperands()
| ACPI_STATUS AcpiDsEvalBufferFieldOperands | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_PARSE_OBJECT * | Op | ||
| ) |
Definition at line 321 of file dsopcode.c.
324{
326 ACPI_OPERAND_OBJECT *ObjDesc;
328 ACPI_PARSE_OBJECT *NextOp;
329
330
331 ACPI_FUNCTION_TRACE_PTR (DsEvalBufferFieldOperands, Op);
332
333
334 /*
335 * This is where we evaluate the address and length fields of the
336 * CreateXxxField declaration
337 */
339
340 /* NextOp points to the op that holds the Buffer */
341
342 NextOp = Op->Common.Value.Arg;
343
344 /* Evaluate/create the address and length operands */
345
348 {
350 }
351
353 if (!ObjDesc)
354 {
356 }
357
358 /* Resolve the operands */
359
363 {
366
368 }
369
370 /* Initialize the Buffer Field */
371
373 {
374 /* NOTE: Slightly different operands for this opcode */
375
379 }
380 else
381 {
382 /* All other, CreateXxxField opcodes */
383
387 }
388
390}
static ACPI_STATUS AcpiDsInitBufferField(UINT16 AmlOpcode, ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT *BufferDesc, ACPI_OPERAND_OBJECT *OffsetDesc, ACPI_OPERAND_OBJECT *LengthDesc, ACPI_OPERAND_OBJECT *ResultDesc)
Definition: dsopcode.c:116
ACPI_STATUS AcpiDsCreateOperands(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *FirstArg)
Definition: dsutils.c:753
ACPI_STATUS AcpiExResolveOperands(UINT16 Opcode, ACPI_OPERAND_OBJECT **StackPtr, ACPI_WALK_STATE *WalkState)
Definition: exresop.c:145
Referenced by AcpiDsExecEndOp().
◆ AcpiDsEvalDataObjectOperands()
| ACPI_STATUS AcpiDsEvalDataObjectOperands | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_PARSE_OBJECT * | Op, | ||
| ACPI_OPERAND_OBJECT * | ObjDesc | ||
| ) |
Definition at line 637 of file dsopcode.c.
641{
643 ACPI_OPERAND_OBJECT *ArgDesc;
645
646
647 ACPI_FUNCTION_TRACE (DsEvalDataObjectOperands);
648
649
650 /* The first operand (for all of these data objects) is the length */
651
652 /*
653 * Set proper index into operand stack for AcpiDsObjStackPush
654 * invoked inside AcpiDsCreateOperand.
655 */
657
658 /* Ignore if child is not valid */
659
661 {
663 "Missing child while evaluating opcode %4.4X, Op %p",
664 Op->Common.AmlOpcode, Op));
666 }
667
670 {
672 }
673
676 WalkState);
678 {
680 }
681
682 /* Extract length operand */
683
686
687 /* Cleanup for length operand */
688
691 {
693 }
694
695 AcpiUtRemoveReference (ArgDesc);
696
697 /*
698 * Create the actual data object
699 */
701 {
703
705 WalkState, Op, Length, &ObjDesc);
706 break;
707
710
712 WalkState, Op, Length, &ObjDesc);
713 break;
714
715 default:
716
718 }
719
721 {
722 /*
723 * Return the object in the WalkState, unless the parent is a package -
724 * in this case, the return object will be stored in the parse tree
725 * for the package.
726 */
731 {
732 WalkState->ResultObj = ObjDesc;
733 }
734 }
735
737}
ACPI_STATUS AcpiDsBuildInternalBufferObj(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, UINT32 BufferLength, ACPI_OPERAND_OBJECT **ObjDescPtr)
Definition: dsobject.c:188
ACPI_STATUS AcpiDsBuildInternalPackageObj(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, UINT32 ElementCount, ACPI_OPERAND_OBJECT **ObjDescPtr)
Definition: dspkginit.c:94
ACPI_STATUS AcpiDsObjStackPop(UINT32 PopCount, ACPI_WALK_STATE *WalkState)
Definition: dswstate.c:391
Referenced by AcpiDsExecEndOp().
◆ AcpiDsEvalRegionOperands()
| ACPI_STATUS AcpiDsEvalRegionOperands | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_PARSE_OBJECT * | Op | ||
| ) |
Definition at line 408 of file dsopcode.c.
411{
413 ACPI_OPERAND_OBJECT *ObjDesc;
414 ACPI_OPERAND_OBJECT *OperandDesc;
416 ACPI_PARSE_OBJECT *NextOp;
418
419
420 ACPI_FUNCTION_TRACE_PTR (DsEvalRegionOperands, Op);
421
422
423 /*
424 * This is where we evaluate the address and length fields of the
425 * OpRegion declaration
426 */
428
429 /* NextOp points to the op that holds the SpaceID */
430
431 NextOp = Op->Common.Value.Arg;
433
434 /* NextOp points to address op */
435
436 NextOp = NextOp->Common.Next;
437
438 /* Evaluate/create the address and length operands */
439
442 {
444 }
445
446 /* Resolve the length and address operands to numbers */
447
451 {
453 }
454
456 if (!ObjDesc)
457 {
459 }
460
461 /*
462 * Get the length operand and save it
463 * (at Top of stack)
464 */
466
468 AcpiUtRemoveReference (OperandDesc);
469
470 /* A zero-length operation region is unusable. Just warn */
471
473 {
475 "Operation Region [%4.4s] has zero length (SpaceId %X)",
477 }
478
479 /*
480 * Get the address and save it
481 * (at top of stack - 1)
482 */
484
487 AcpiUtRemoveReference (OperandDesc);
488
492
495
496 /* Now the address and length are valid for this opregion */
497
500}
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn UINT32 *TableIdx UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE ACPI_HANDLE ACPI_HANDLE *OutHandle ACPI_HANDLE *OutHandle void *Context void *Context ACPI_EVENT_HANDLER Handler UINT32 UINT32 ACPI_GPE_HANDLER void *Context UINT32 ACPI_NOTIFY_HANDLER void *Context ACPI_ADR_SPACE_TYPE SpaceId
Definition: acpixf.h:832
ACPI_STATUS AcpiUtAddAddressRange(ACPI_ADR_SPACE_TYPE SpaceId, ACPI_PHYSICAL_ADDRESS Address, UINT32 Length, ACPI_NAMESPACE_NODE *RegionNode)
Definition: utaddress.c:78
Referenced by AcpiDsExecEndOp().
◆ AcpiDsEvalTableRegionOperands()
| ACPI_STATUS AcpiDsEvalTableRegionOperands | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_PARSE_OBJECT * | Op | ||
| ) |
Definition at line 519 of file dsopcode.c.
522{
524 ACPI_OPERAND_OBJECT *ObjDesc;
525 ACPI_OPERAND_OBJECT **Operand;
527 ACPI_PARSE_OBJECT *NextOp;
529 UINT32 TableIndex;
530
531
532 ACPI_FUNCTION_TRACE_PTR (DsEvalTableRegionOperands, Op);
533
534
535 /*
536 * This is where we evaluate the Signature string, OemId string,
537 * and OemTableId string of the Data Table Region declaration
538 */
540
541 /* NextOp points to Signature string op */
542
543 NextOp = Op->Common.Value.Arg;
544
545 /*
546 * Evaluate/create the Signature string, OemId string,
547 * and OemTableId string operands
548 */
551 {
553 }
554
555 Operand = &WalkState->Operands[0];
556
557 /*
558 * Resolve the Signature string, OemId string,
559 * and OemTableId string operands
560 */
564 {
566 }
567
568 /* Find the ACPI table */
569
571 Operand[0]->String.Pointer,
572 Operand[1]->String.Pointer,
573 Operand[2]->String.Pointer, &TableIndex);
575 {
577 {
579 "ACPI Table [%4.4s] OEM:(%s, %s) not found in RSDT/XSDT",
580 Operand[0]->String.Pointer,
581 Operand[1]->String.Pointer,
582 Operand[2]->String.Pointer));
583 }
585 }
586
589 {
591 }
592
594 if (!ObjDesc)
595 {
598 }
599
603
607
608 /* Now the address and length are valid for this opregion */
609
611
612Cleanup:
613 AcpiUtRemoveReference (Operand[0]);
614 AcpiUtRemoveReference (Operand[1]);
615 AcpiUtRemoveReference (Operand[2]);
616
618}
ACPI_STATUS AcpiTbFindTable(char *Signature, char *OemId, char *OemTableId, UINT32 *TableIndex)
Definition: tbfind.c:70
Definition: actbl.h:107
ACPI_STATUS AcpiGetTableByIndex(UINT32 TableIndex, ACPI_TABLE_HEADER **OutTable)
Definition: tbxface.c:491
Referenced by AcpiDsExecEndOp().
◆ AcpiDsEvaluateNamePath()
| ACPI_STATUS AcpiDsEvaluateNamePath | ( | ACPI_WALK_STATE * | WalkState | ) |
Definition at line 845 of file dsutils.c.
847{
851 ACPI_OPERAND_OBJECT *NewObjDesc;
853
854
855 ACPI_FUNCTION_TRACE_PTR (DsEvaluateNamePath, WalkState);
856
857
859 {
860 /* This happens after certain exception processing */
861
863 }
864
868 {
869 /* TBD: Should we specify this feature as a bit of OpInfo->Flags of these opcodes? */
870
872 }
873
876 {
878 }
879
881 {
882 NewObjDesc = *Operand;
883 goto PushResult;
884 }
885
887
890 {
892 }
893
895 {
896 /* It was incremented by AcpiExResolveToValue */
897
898 AcpiUtRemoveReference (*Operand);
899
901 *Operand, &NewObjDesc, WalkState);
903 {
905 }
906 }
907 else
908 {
909 /*
910 * The object either was anew created or is
911 * a Namespace node - don't decrement it.
912 */
913 NewObjDesc = *Operand;
914 }
915
916 /* Cleanup for name-path operand */
917
920 {
921 WalkState->ResultObj = NewObjDesc;
923 }
924
925PushResult:
926
927 WalkState->ResultObj = NewObjDesc;
928
931 {
932 /* Force to take it from stack */
933
935 }
936
937Exit:
938
940}
ACPI_STATUS AcpiUtCopyIobjectToIobject(ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT **DestDesc, ACPI_WALK_STATE *WalkState)
Definition: utcopy.c:1037
ACPI_STATUS AcpiDsResultPush(ACPI_OPERAND_OBJECT *Object, ACPI_WALK_STATE *WalkState)
Definition: dswstate.c:160
Referenced by AcpiDsExecEndOp().
◆ AcpiDsExecBeginControlOp()
| ACPI_STATUS AcpiDsExecBeginControlOp | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_PARSE_OBJECT * | Op | ||
| ) |
Definition at line 71 of file dscontrol.c.
74{
76 ACPI_GENERIC_STATE *ControlState;
77
78
79 ACPI_FUNCTION_NAME (DsExecBeginControlOp);
80
81
83 Op, Op->Common.AmlOpcode, WalkState));
84
86 {
88 /*
89 * If this is an additional iteration of a while loop, continue.
90 * There is no need to allocate a new control state.
91 */
93 {
96 {
97 /* Reset the state to start-of-loop */
98
101 break;
102 }
103 }
104
105 ACPI_FALLTHROUGH;
106
108 /*
109 * IF/WHILE: Create a new control state to manage these
110 * constructs. We need to manage these as a stack, in order
111 * to handle nesting.
112 */
113 ControlState = AcpiUtCreateControlState ();
114 if (!ControlState)
115 {
117 break;
118 }
119 /*
120 * Save a pointer to the predicate for multiple executions
121 * of a loop
122 */
128 Op->Common.AmlOpcode;
131
132 /* Push the control state on this walk's control stack */
133
135 break;
136
138
139 /* Predicate is in the state object */
140 /* If predicate is true, the IF was executed, ignore ELSE part */
141
143 {
145 }
146
147 break;
148
150
151 break;
152
153 default:
154
155 break;
156 }
157
159}
#define ACPI_CONTROL_CONDITIONAL_EXECUTING
Definition: aclocal.h:670
ACPI_GENERIC_STATE * AcpiUtCreateControlState(void)
Definition: utstate.c:300
void AcpiUtPushGenericState(ACPI_GENERIC_STATE **ListHead, ACPI_GENERIC_STATE *State)
Definition: utstate.c:65
Referenced by AcpiDsExecBeginOp().
◆ AcpiDsExecBeginOp()
| ACPI_STATUS AcpiDsExecBeginOp | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_PARSE_OBJECT ** | OutOp | ||
| ) |
Definition at line 234 of file dswexec.c.
237{
238 ACPI_PARSE_OBJECT *Op;
240 UINT32 OpcodeClass;
241
242
243 ACPI_FUNCTION_TRACE_PTR (DsExecBeginOp, WalkState);
244
245
246 Op = WalkState->Op;
247 if (!Op)
248 {
251 {
253 }
254
255 Op = *OutOp;
256 WalkState->Op = Op;
259
261 {
263 "(%s) Popping scope for Op %p\n",
265
268 {
270 }
271 }
272 }
273
275 {
276 if (OutOp)
277 {
278 *OutOp = Op;
279 }
280
282 }
283
284 /*
285 * If the previous opcode was a conditional, this opcode
286 * must be the beginning of the associated predicate.
287 * Save this knowledge in the current scope descriptor
288 */
292 {
294 "Exec predicate Op=%p State=%p\n",
295 Op, WalkState));
296
299
300 /* Save start of predicate */
301
303 }
304
305
307
308 /* We want to send namepaths to the load code */
309
311 {
312 OpcodeClass = AML_CLASS_NAMED_OBJECT;
313 }
314
315 /*
316 * Handle the opcode based upon the opcode type
317 */
318 switch (OpcodeClass)
319 {
321
323 break;
324
326
328 {
329 /*
330 * Found a named object declaration during method execution;
331 * we must enter this object into the namespace. The created
332 * object is temporary and will be deleted upon completion of
333 * the execution of this method.
334 *
335 * Note 10/2010: Except for the Scope() op. This opcode does
336 * not actually create a new object, it refers to an existing
337 * object. However, for Scope(), we want to indeed open a
338 * new scope.
339 */
341 {
343 }
344 else
345 {
349 {
351 }
352 }
353 }
354 break;
355
358
359 break;
360
361 default:
362
363 break;
364 }
365
366 /* Nothing to do here during method execution */
367
369
370
371ErrorExit:
374}
ACPI_STATUS AcpiDsExecBeginControlOp(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op)
Definition: dscontrol.c:71
ACPI_STATUS AcpiDsMethodError(ACPI_STATUS Status, ACPI_WALK_STATE *WalkState)
Definition: dsmethod.c:223
ACPI_STATUS AcpiDsLoad2BeginOp(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT **OutOp)
Definition: dswload2.c:74
ACPI_STATUS AcpiDsScopeStackPush(ACPI_NAMESPACE_NODE *Node, ACPI_OBJECT_TYPE Type, ACPI_WALK_STATE *WalkState)
Definition: dswscope.c:107
ACPI_STATUS AcpiDsScopeStackPop(ACPI_WALK_STATE *WalkState)
Definition: dswscope.c:192
Referenced by AcpiDsInitCallbacks(), and AcpiDsLoad2BeginOp().
◆ AcpiDsExecEndControlOp()
| ACPI_STATUS AcpiDsExecEndControlOp | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_PARSE_OBJECT * | Op | ||
| ) |
Definition at line 177 of file dscontrol.c.
180{
182 ACPI_GENERIC_STATE *ControlState;
183
184
185 ACPI_FUNCTION_NAME (DsExecEndControlOp);
186
187
189 {
191
193
194 /*
195 * Save the result of the predicate in case there is an
196 * ELSE to come
197 */
198 WalkState->LastPredicate =
200
201 /*
202 * Pop the control state that was created at the start
203 * of the IF and free it
204 */
206 AcpiUtDeleteGenericState (ControlState);
207 break;
208
210
211 break;
212
214
216
217 ControlState = WalkState->ControlState;
219 {
220 /* Predicate was true, the body of the loop was just executed */
221
222 /*
223 * This infinite loop detection mechanism allows the interpreter
224 * to escape possibly infinite loops. This can occur in poorly
225 * written AML when the hardware does not respond within a while
226 * loop and the loop does not implement a timeout.
227 */
230 {
232 break;
233 }
234
235 /*
236 * Go back and evaluate the predicate and maybe execute the loop
237 * another time
238 */
240 WalkState->AmlLastWhile =
242 break;
243 }
244
245 /* Predicate was false, terminate this while loop */
246
248 "[WHILE_OP] termination! Op=%p\n",Op));
249
250 /* Pop this control state and free it */
251
253 AcpiUtDeleteGenericState (ControlState);
254 break;
255
257
260
261 /*
262 * One optional operand -- the return value
263 * It can be either an immediate operand or a result that
264 * has been bubbled up the tree
265 */
267 {
268 /* Since we have a real Return(), delete any implicit return */
269
270 AcpiDsClearImplicitReturn (WalkState);
271
272 /* Return statement has an immediate operand */
273
276 {
278 }
279
280 /*
281 * If value being returned is a Reference (such as
282 * an arg or local), resolve it now because it may
283 * cease to exist at the end of the method.
284 */
286 &WalkState->Operands [0], WalkState);
288 {
290 }
291
292 /*
293 * Get the return value and save as the last result
294 * value. This is the only place where WalkState->ReturnDesc
295 * is set to anything other than zero!
296 */
298 }
300 {
301 /* Since we have a real Return(), delete any implicit return */
302
303 AcpiDsClearImplicitReturn (WalkState);
304
305 /*
306 * The return value has come from a previous calculation.
307 *
308 * If value being returned is a Reference (such as
309 * an arg or local), resolve it now because it may
310 * cease to exist at the end of the method.
311 *
312 * Allow references created by the Index operator to return
313 * unchanged.
314 */
316 ACPI_DESC_TYPE_OPERAND) &&
318 ACPI_TYPE_LOCAL_REFERENCE) &&
320 ACPI_REFCLASS_INDEX))
321 {
325 {
327 }
328 }
329
331 }
332 else
333 {
334 /* No return operand */
335
337 {
339 }
340
342 WalkState->NumOperands = 0;
344 }
345
346
348 "Completed RETURN_OP State=%p, RetVal=%p\n",
349 WalkState, WalkState->ReturnDesc));
350
351 /* End the control method execution right now */
352
354 break;
355
357
358 /* Just do nothing! */
359
360 break;
361
363
364 AcpiDbSignalBreakPoint (WalkState);
365
366 /* Call to the OSL in case OS wants a piece of the action */
367
369 "Executed AML Breakpoint opcode");
370 break;
371
374
375 /* Pop and delete control states until we find a while */
376
379 {
381 AcpiUtDeleteGenericState (ControlState);
382 }
383
384 /* No while found? */
385
387 {
389 }
390
391 /* Was: WalkState->AmlLastWhile = WalkState->ControlState->Control.AmlPredicateStart; */
392
393 WalkState->AmlLastWhile =
395
396 /* Return status depending on opcode */
397
399 {
401 }
402 else
403 {
405 }
406 break;
407
408 default:
409
411 Op->Common.AmlOpcode, Op));
412
414 break;
415 }
416
418}
ACPI_GENERIC_STATE * AcpiUtPopGenericState(ACPI_GENERIC_STATE **ListHead)
Definition: utstate.c:93
Referenced by AcpiDsExecEndOp().
◆ AcpiDsExecEndOp()
| ACPI_STATUS AcpiDsExecEndOp | ( | ACPI_WALK_STATE * | State | ) |
Definition at line 392 of file dswexec.c.
394{
395 ACPI_PARSE_OBJECT *Op;
399 ACPI_PARSE_OBJECT *NextOp;
400 ACPI_PARSE_OBJECT *FirstArg;
401#ifdef ACPI_EXEC_APP
402 char *Namepath;
403 ACPI_OPERAND_OBJECT *ObjDesc;
404#endif
405
406 ACPI_FUNCTION_TRACE_PTR (DsExecEndOp, WalkState);
407
408
409 Op = WalkState->Op;
410 OpType = WalkState->OpInfo->Type;
411 OpClass = WalkState->OpInfo->Class;
412
414 {
417 }
418
419 FirstArg = Op->Common.Value.Arg;
420
421 /* Init the walk state */
422
423 WalkState->NumOperands = 0;
424 WalkState->OperandIndex = 0;
425 WalkState->ReturnDesc = NULL;
426 WalkState->ResultObj = NULL;
427
428 /* Call debugger for single step support (DEBUG build only) */
429
432 {
434 }
435
436 /* Decode the Opcode Class */
437
439 {
441
443 {
446 {
448 }
449 }
450 break;
451
453
454 /* Build resolved operand stack */
455
458 {
460 }
461
462 /*
463 * All opcodes require operand resolution, with the only exceptions
464 * being the ObjectType and SizeOf operators.
465 */
467 {
468 /* Resolve all operands */
469
471 &(WalkState->Operands [WalkState->NumOperands -1]),
472 WalkState);
473 }
474
476 {
477 /*
478 * Dispatch the request to the appropriate interpreter handler
479 * routine. There is one routine per opcode "type" based upon the
480 * number of opcode arguments and return type.
481 */
483 }
484 else
485 {
486 /*
487 * Treat constructs of the form "Store(LocalX,LocalX)" as noops when the
488 * Local is uninitialized.
489 */
491 (WalkState->Opcode == AML_STORE_OP) &&
492 (WalkState->Operands[0]->Common.Type == ACPI_TYPE_LOCAL_REFERENCE) &&
493 (WalkState->Operands[1]->Common.Type == ACPI_TYPE_LOCAL_REFERENCE) &&
494 (WalkState->Operands[0]->Reference.Class ==
495 WalkState->Operands[1]->Reference.Class) &&
496 (WalkState->Operands[0]->Reference.Value ==
497 WalkState->Operands[1]->Reference.Value))
498 {
500 }
501 else
502 {
504 "While resolving operands for [%s]",
505 AcpiPsGetOpcodeName (WalkState->Opcode)));
506 }
507 }
508
509 /* Always delete the argument objects and clear the operand stack */
510
511 AcpiDsClearOperands (WalkState);
512
513 /*
514 * If a result object was returned from above, push it on the
515 * current result stack
516 */
518 WalkState->ResultObj)
519 {
521 }
522 break;
523
524 default:
525
527 {
529
530 /* 1 Operand, 0 ExternalResult, 0 InternalResult */
531
533
534 break;
535
537 /*
538 * If the method is referenced from within a package
539 * declaration, it is not a invocation of the method, just
540 * a reference to it.
541 */
545 {
547 "Method Reference in a Package, Op=%p\n", Op));
548
550 Op->Asl.Value.Arg->Asl.Node;
553 }
554
556 "Method invocation, Op=%p\n", Op));
557
558 /*
559 * (AML_METHODCALL) Op->Asl.Value.Arg->Asl.Node contains
560 * the method Node pointer
561 */
562 /* NextOp points to the op that holds the method name */
563
564 NextOp = FirstArg;
565
566 /* NextOp points to first argument op */
567
568 NextOp = NextOp->Common.Next;
569
570 /*
571 * Get the method's arguments and put them on the operand stack
572 */
575 {
576 break;
577 }
578
579 /*
580 * Since the operands will be passed to another control method,
581 * we must resolve all local references here (Local variables,
582 * arguments to *this* method, etc.)
583 */
586 {
587 /* On error, clear all resolved operands */
588
589 AcpiDsClearOperands (WalkState);
590 break;
591 }
592
593 /*
594 * Tell the walk loop to preempt this running method and
595 * execute the new method
596 */
598
599 /*
600 * Return now; we don't want to disturb anything,
601 * especially the operand count!
602 */
604
606
608 "Executing CreateField Buffer/Index Op=%p\n", Op));
609
612 {
613 break;
614 }
615
618 {
619 break;
620 }
621
622#ifdef ACPI_EXEC_APP
623 /*
624 * AcpiExec support for namespace initialization file (initialize
625 * BufferFields in this code.)
626 */
628 Status = AeLookupInitFileEntry (Namepath, &ObjDesc);
630 {
633 {
635 }
636 }
637 ACPI_FREE (Namepath);
639#endif
640 break;
641
642
644
646 "Executing CreateObject (Buffer/Package) Op=%p Child=%p ParentOpcode=%4.4X\n",
648
650 {
652 /*
653 * Put the Node on the object stack (Contains the ACPI Name
654 * of this object)
655 */
656 WalkState->Operands[0] = (void *)
657 Op->Common.Parent->Common.Node;
658 WalkState->NumOperands = 1;
659
663 {
664 break;
665 }
666
667 ACPI_FALLTHROUGH;
668
670
673 break;
674
675 default:
676
678 break;
679 }
680
681 /*
682 * If a result object was returned from above, push it on the
683 * current result stack
684 */
685 if (WalkState->ResultObj)
686 {
688 }
689 break;
690
695
698 {
699 break;
700 }
701
703 {
705 "Executing OpRegion Address/Length Op=%p\n", Op));
706
709 {
710 break;
711 }
712 }
714 {
716 "Executing DataTableRegion Strings Op=%p\n", Op));
717
720 {
721 break;
722 }
723 }
725 {
727 "Executing BankField Op=%p\n", Op));
728
731 {
732 break;
733 }
734 }
735 break;
736
738
740 "Undefined opcode type Op=%p", Op));
742
744
746 "Internal opcode=%X type Op=%p\n",
747 WalkState->Opcode, Op));
748 break;
749
750 default:
751
753 "Unimplemented opcode, class=0x%X "
754 "type=0x%X Opcode=0x%X Op=%p",
756
758 break;
759 }
760 }
761
762 /*
763 * ACPI 2.0 support for 64-bit integers: Truncate numeric
764 * result value if we are executing from a 32-bit ACPI table
765 */
767
768 /*
769 * Check if we just completed the evaluation of a
770 * conditional predicate
771 */
773 (WalkState->ControlState) &&
774 (WalkState->ControlState->Common.State ==
775 ACPI_CONTROL_PREDICATE_EXECUTING) &&
776 (WalkState->ControlState->Control.PredicateOp == Op))
777 {
779 WalkState->ResultObj = NULL;
780 }
781
782
783Cleanup:
784
785 if (WalkState->ResultObj)
786 {
787 /* Break to debugger to display result */
788
789 AcpiDbDisplayResultObject (WalkState->ResultObj,WalkState);
790
791 /*
792 * Delete the result op if and only if:
793 * Parent will not use the result -- such as any
794 * non-nested type2 op in a method (parent will be method)
795 */
796 AcpiDsDeleteResultIfNotUsed (Op, WalkState->ResultObj, WalkState);
797 }
798
799#ifdef _UNDER_DEVELOPMENT
800
801 if (WalkState->ParserState.Aml == WalkState->ParserState.AmlEnd)
802 {
803 AcpiDbMethodEnd (WalkState);
804 }
805#endif
806
807 /* Invoke exception handler on error */
808
810 {
812 }
813
814 /* Always clear the object stack */
815
816 WalkState->NumOperands = 0;
818}
char * AcpiNsGetExternalPathname(ACPI_NAMESPACE_NODE *Node)
Definition: nsnames.c:70
ACPI_STATUS AcpiDsExecEndControlOp(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op)
Definition: dscontrol.c:177
ACPI_STATUS AcpiDsCreateNode(ACPI_WALK_STATE *WalkState, ACPI_NAMESPACE_NODE *Node, ACPI_PARSE_OBJECT *Op)
Definition: dsobject.c:302
ACPI_STATUS AcpiDsEvalTableRegionOperands(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op)
Definition: dsopcode.c:519
ACPI_STATUS AcpiDsEvalBufferFieldOperands(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op)
Definition: dsopcode.c:321
ACPI_STATUS AcpiDsEvalBankFieldOperands(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op)
Definition: dsopcode.c:755
ACPI_STATUS AcpiDsEvalRegionOperands(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op)
Definition: dsopcode.c:408
ACPI_STATUS AcpiDsEvalDataObjectOperands(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, ACPI_OPERAND_OBJECT *ObjDesc)
Definition: dsopcode.c:637
void AcpiDsDeleteResultIfNotUsed(ACPI_PARSE_OBJECT *Op, ACPI_OPERAND_OBJECT *ResultObj, ACPI_WALK_STATE *WalkState)
Definition: dsutils.c:359
ACPI_STATUS AcpiDsResolveOperands(ACPI_WALK_STATE *WalkState)
Definition: dsutils.c:412
ACPI_STATUS AcpiDsEvaluateNamePath(ACPI_WALK_STATE *WalkState)
Definition: dsutils.c:845
ACPI_STATUS AcpiDsGetPredicateValue(ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT *ResultObj)
Definition: dswexec.c:94
ACPI_STATUS AcpiExWriteDataToField(ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **ResultDesc)
Definition: exfield.c:317
BOOLEAN AcpiExTruncateFor32bitTable(ACPI_OPERAND_OBJECT *ObjDesc)
Definition: exutils.c:177
Definition: nsiface.idl:2307
Referenced by AcpiDsInitCallbacks().
◆ AcpiDsGetBankFieldArguments()
| ACPI_STATUS AcpiDsGetBankFieldArguments | ( | ACPI_OPERAND_OBJECT * | ObjDesc | ) |
Definition at line 245 of file dsargs.c.
247{
248 ACPI_OPERAND_OBJECT *ExtraDesc;
251
252
253 ACPI_FUNCTION_TRACE_PTR (DsGetBankFieldArguments, ObjDesc);
254
255
257 {
259 }
260
261 /* Get the AML pointer (method object) and BankField node */
262
263 ExtraDesc = AcpiNsGetSecondaryObject (ObjDesc);
265
266 ACPI_DEBUG_EXEC (AcpiUtDisplayInitPathname (
268
271
272 /* Execute the AML code for the TermArg arguments */
273
277}
ACPI_OPERAND_OBJECT * AcpiNsGetSecondaryObject(ACPI_OPERAND_OBJECT *ObjDesc)
Definition: nsobject.c:346
static ACPI_STATUS AcpiDsExecuteArguments(ACPI_NAMESPACE_NODE *Node, ACPI_NAMESPACE_NODE *ScopeNode, UINT32 AmlLength, UINT8 *AmlStart)
Definition: dsargs.c:81
Referenced by AcpiNsInitOneObject().
◆ AcpiDsGetBufferArguments()
| ACPI_STATUS AcpiDsGetBufferArguments | ( | ACPI_OPERAND_OBJECT * | ObjDesc | ) |
Definition at line 294 of file dsargs.c.
296{
299
300
301 ACPI_FUNCTION_TRACE_PTR (DsGetBufferArguments, ObjDesc);
302
303
305 {
307 }
308
309 /* Get the Buffer node */
310
313 {
315 "No pointer back to namespace node in buffer object %p",
316 ObjDesc));
318 }
319
321
322 /* Execute the AML code for the TermArg arguments */
323
327}
Referenced by AcpiExOpcode_1A_0T_1R(), AcpiExPrepFieldValue(), AcpiExResolveNodeToValue(), and AcpiExResolveObjectToValue().
◆ AcpiDsGetBufferFieldArguments()
| ACPI_STATUS AcpiDsGetBufferFieldArguments | ( | ACPI_OPERAND_OBJECT * | ObjDesc | ) |
Definition at line 196 of file dsargs.c.
198{
199 ACPI_OPERAND_OBJECT *ExtraDesc;
202
203
204 ACPI_FUNCTION_TRACE_PTR (DsGetBufferFieldArguments, ObjDesc);
205
206
208 {
210 }
211
212 /* Get the AML pointer (method object) and BufferField node */
213
214 ExtraDesc = AcpiNsGetSecondaryObject (ObjDesc);
216
217 ACPI_DEBUG_EXEC (AcpiUtDisplayInitPathname (
219
222
223 /* Execute the AML code for the TermArg arguments */
224
228}
Referenced by AcpiExFieldDatumIo(), AcpiExReadDataFromField(), and AcpiExWriteDataToField().
◆ AcpiDsGetCurrentWalkState()
| ACPI_WALK_STATE * AcpiDsGetCurrentWalkState | ( | ACPI_THREAD_STATE * | Thread | ) |
Definition at line 494 of file dswstate.c.
496{
497 ACPI_FUNCTION_NAME (DsGetCurrentWalkState);
498
499
501 {
503 }
504
506 Thread->WalkStateList));
507
509}
Referenced by AcpiPsParseAml().
◆ AcpiDsGetPackageArguments()
| ACPI_STATUS AcpiDsGetPackageArguments | ( | ACPI_OPERAND_OBJECT * | ObjDesc | ) |
Definition at line 344 of file dsargs.c.
346{
349
350
351 ACPI_FUNCTION_TRACE_PTR (DsGetPackageArguments, ObjDesc);
352
353
355 {
357 }
358
359 /* Get the Package node */
360
363 {
365 "No pointer back to namespace node in package %p", ObjDesc));
367 }
368
371
372 /* Execute the AML code for the TermArg arguments */
373
376
378}
Referenced by AcpiExOpcode_1A_0T_1R(), AcpiExResolveNodeToValue(), AcpiExResolveObjectToValue(), and AcpiNsInitOnePackage().
◆ AcpiDsGetPredicateValue()
| ACPI_STATUS AcpiDsGetPredicateValue | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_OPERAND_OBJECT * | ResultObj | ||
| ) |
Definition at line 94 of file dswexec.c.
97{
99 ACPI_OPERAND_OBJECT *ObjDesc;
101
102
103 ACPI_FUNCTION_TRACE_PTR (DsGetPredicateValue, WalkState);
104
105
107
108 if (ResultObj)
109 {
112 {
114 "Could not get result from predicate evaluation"));
115
117 }
118 }
119 else
120 {
123 {
125 }
126
129 {
131 }
132
133 ObjDesc = WalkState->Operands [0];
134 }
135
136 if (!ObjDesc)
137 {
139 "No predicate ObjDesc=%p State=%p",
140 ObjDesc, WalkState));
141
143 }
144
145 /*
146 * Result of predicate evaluation must be an Integer
147 * object. Implicitly convert the argument if necessary.
148 */
150 ACPI_IMPLICIT_CONVERSION);
152 {
154 }
155
157 {
159 "Bad predicate (not an integer) ObjDesc=%p State=%p Type=0x%X",
160 ObjDesc, WalkState, ObjDesc->Common.Type));
161
164 }
165
166 /* Truncate the predicate to 32-bits if necessary */
167
169
170 /*
171 * Save the result of the predicate evaluation on
172 * the control stack
173 */
175 {
177 }
178 else
179 {
180 /*
181 * Predicate is FALSE, we will just toss the
182 * rest of the package
183 */
186 }
187
188 /* Predicate can be used for an implicit return value */
189
191
192
193Cleanup:
194
196 "Completed a predicate eval=%X Op=%p\n",
198
199 /* Break to debugger to display result */
200
201 AcpiDbDisplayResultObject (LocalObjDesc, WalkState);
202
203 /*
204 * Delete the predicate result object (we know that
205 * we don't need it anymore)
206 */
207 if (LocalObjDesc != ObjDesc)
208 {
209 AcpiUtRemoveReference (LocalObjDesc);
210 }
211 AcpiUtRemoveReference (ObjDesc);
212
215}
BOOLEAN AcpiDsDoImplicitReturn(ACPI_OPERAND_OBJECT *ReturnDesc, ACPI_WALK_STATE *WalkState, BOOLEAN AddReference)
Definition: dsutils.c:123
ACPI_STATUS AcpiExConvertToInteger(ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **ResultDesc, UINT32 ImplicitConversion)
Definition: exconvrt.c:79
Referenced by AcpiDsExecEndOp(), and AcpiPsParseLoop().
◆ AcpiDsGetRegionArguments()
| ACPI_STATUS AcpiDsGetRegionArguments | ( | ACPI_OPERAND_OBJECT * | RgnDesc | ) |
Definition at line 395 of file dsargs.c.
397{
400 ACPI_OPERAND_OBJECT *ExtraDesc;
401
402
403 ACPI_FUNCTION_TRACE_PTR (DsGetRegionArguments, ObjDesc);
404
405
407 {
409 }
410
411 ExtraDesc = AcpiNsGetSecondaryObject (ObjDesc);
412 if (!ExtraDesc)
413 {
415 }
416
417 /* Get the Region node */
418
419 Node = ObjDesc->Region.Node;
420
421 ACPI_DEBUG_EXEC (AcpiUtDisplayInitPathname (
423
425 "[%4.4s] OpRegion Arg Init at AML %p\n",
427
428 /* Execute the argument AML */
429
433 {
435 }
436
438 ObjDesc->Region.Address, ObjDesc->Region.Length, Node);
440}
Referenced by AcpiExLoadOp(), and AcpiExSetupRegion().
◆ AcpiDsInitAmlWalk()
| ACPI_STATUS AcpiDsInitAmlWalk | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_PARSE_OBJECT * | Op, | ||
| ACPI_NAMESPACE_NODE * | MethodNode, | ||
| UINT8 * | AmlStart, | ||
| UINT32 | AmlLength, | ||
| ACPI_EVALUATE_INFO * | Info, | ||
| UINT8 | PassNumber | ||
| ) |
Definition at line 662 of file dswstate.c.
670{
673 ACPI_PARSE_OBJECT *ExtraOp;
674
675
676 ACPI_FUNCTION_TRACE (DsInitAmlWalk);
677
678
683
684 /* The NextOp of the NextWalk will be the beginning of the method */
685
687 WalkState->PassNumber = PassNumber;
688
690 {
693 }
694
697 {
699 }
700
701 if (MethodNode)
702 {
705 WalkState->MethodNode = MethodNode;
707
708 /* Push start scope on scope stack and make it current */
709
711 MethodNode, ACPI_TYPE_METHOD, WalkState);
713 {
715 }
716
717 /* Init the method arguments */
718
720 ACPI_METHOD_NUM_ARGS, WalkState);
722 {
724 }
725 }
726 else
727 {
728 /*
729 * Setup the current scope.
730 * Find a Named Op that has a namespace node associated with it.
731 * search upwards from this Op. Current scope is the first
732 * Op with a namespace node.
733 */
734 ExtraOp = ParserState->StartOp;
736 {
737 ExtraOp = ExtraOp->Common.Parent;
738 }
739
740 if (!ExtraOp)
741 {
743 }
744 else
745 {
747 }
748
750 {
751 /* Push start scope on scope stack and make it current */
752
754 ParserState->StartNode->Type, WalkState);
756 {
758 }
759 }
760 }
761
764}
ACPI_STATUS AcpiPsInitScope(ACPI_PARSE_STATE *ParserState, ACPI_PARSE_OBJECT *Root)
Definition: psscope.c:112
ACPI_STATUS AcpiDsMethodDataInitArgs(ACPI_OPERAND_OBJECT **Params, UINT32 MaxParamCount, ACPI_WALK_STATE *WalkState)
Definition: dsmthdat.c:213
ACPI_STATUS AcpiDsInitCallbacks(ACPI_WALK_STATE *WalkState, UINT32 PassNumber)
Definition: dswload.c:73
Definition: aclocal.h:1100
union acpi_operand_object ** CallerReturnDesc
Definition: acstruct.h:109
Referenced by AcpiDsAutoSerializeMethod(), AcpiDsCallControlMethod(), AcpiDsExecuteArguments(), AcpiNsOneCompleteParse(), AcpiPsExecuteMethod(), and AcpiPsExecuteTable().
◆ AcpiDsInitCallbacks()
| ACPI_STATUS AcpiDsInitCallbacks | ( | ACPI_WALK_STATE * | WalkState, |
| UINT32 | PassNumber | ||
| ) |
Definition at line 73 of file dswload.c.
76{
77
78 switch (PassNumber)
79 {
80 case 0:
81
82 /* Parse only - caller will setup callbacks */
83
89 break;
90
91 case 1:
92
93 /* Load pass 1 */
94
99 break;
100
101 case 2:
102
103 /* Load pass 2 */
104
109 break;
110
111 case 3:
112
113 /* Execution pass */
114
119 break;
120
121 default:
122
124 }
125
127}
ACPI_STATUS AcpiDsExecBeginOp(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT **OutOp)
Definition: dswexec.c:234
ACPI_STATUS AcpiDsLoad1BeginOp(ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT **OutOp)
Definition: dswload.c:144
Referenced by AcpiDsInitAmlWalk().
◆ AcpiDsInitFieldObjects()
| ACPI_STATUS AcpiDsInitFieldObjects | ( | ACPI_PARSE_OBJECT * | Op, |
| ACPI_WALK_STATE * | WalkState | ||
| ) |
Definition at line 617 of file dsfield.c.
620{
626
627
628 ACPI_FUNCTION_TRACE_PTR (DsInitFieldObjects, Op);
629
630
631 /* Execute flag should always be set when this function is entered */
632
634 {
636 {
637 /* BankField Op is deferred, just return OK */
638
640 }
641
643 "Parse deferred mode is not set"));
645 }
646
647 /*
648 * Get the FieldList argument for this opcode. This is the start of the
649 * list of field elements.
650 */
652 {
654
655 Arg = AcpiPsGetArg (Op, 2);
657 break;
658
660
661 Arg = AcpiPsGetArg (Op, 4);
663 break;
664
666
667 Arg = AcpiPsGetArg (Op, 3);
669 break;
670
671 default:
672
674 }
675
676 /* Creating new namespace node(s), should not already exist */
677
680
681 /*
682 * Mark node(s) temporary if we are executing a normal control
683 * method. (Don't mark if this is a module-level code method)
684 */
687 {
689 }
690
691#ifdef ACPI_EXEC_APP
693#endif
694 /*
695 * Walk the list of entries in the FieldList
696 * Note: FieldList can be of zero length. In this case, Arg will be NULL.
697 */
698 while (Arg)
699 {
700 /*
701 * Ignore OFFSET/ACCESSAS/CONNECTION terms here; we are only interested
702 * in the field names in order to enter them into the namespace.
703 */
705 {
710 {
714 {
716 }
717
718 /* Name already exists, just ignore this error */
719 }
720
722 }
723
724 /* Get the next field element in the list */
725
726 Arg = Arg->Common.Next;
727 }
728
730}
Referenced by AcpiDsLoad1EndOp(), and AcpiDsLoad2EndOp().
◆ AcpiDsInitializeObjects()
| ACPI_STATUS AcpiDsInitializeObjects | ( | UINT32 | TableIndex, |
| ACPI_NAMESPACE_NODE * | StartNode | ||
| ) |
Definition at line 204 of file dsinit.c.
207{
212
213
214 ACPI_FUNCTION_TRACE (DsInitializeObjects);
215
216
219 {
221 }
222
224 "**** Starting initialization of namespace objects ****\n"));
225
226 /* Set all init info to zero */
227
229
231 Info.TableIndex = TableIndex;
232
233 /* Walk entire namespace from the supplied root */
234
235 /*
236 * We don't use AcpiWalkNamespace since we do not want to acquire
237 * the namespace reader lock.
238 */
242 {
244 }
245
248 {
250 }
251
252 /* DSDT is always the first AML table */
253
255 {
257 "\nACPI table initialization:\n"));
258 }
259
260 /* Summary of objects initialized */
261
263 "Table [%4.4s: %-8.8s] (id %.2X) - %4u Objects with %3u Devices, "
264 "%3u Regions, %4u Methods (%u/%u/%u Serial/Non/Cvt)\n",
268 Info.SerializedMethodCount));
269
272
274}
ACPI_STATUS AcpiNsWalkNamespace(ACPI_OBJECT_TYPE Type, ACPI_HANDLE StartObject, UINT32 MaxDepth, UINT32 Flags, ACPI_WALK_CALLBACK DescendingCallback, ACPI_WALK_CALLBACK AscendingCallback, void *Context, void **ReturnValue)
Definition: nswalk.c:190
ACPI_STATUS AcpiTbGetOwnerId(UINT32 TableIndex, ACPI_OWNER_ID *OwnerId)
Definition: tbdata.c:993
static ACPI_STATUS AcpiDsInitOneObject(ACPI_HANDLE ObjHandle, UINT32 Level, void *Context, void **ReturnValue)
Definition: dsinit.c:86
Definition: acstruct.h:137
Referenced by AcpiNsLoadTable().
◆ AcpiDsInitializeRegion()
| ACPI_STATUS AcpiDsInitializeRegion | ( | ACPI_HANDLE | ObjHandle | ) |
Definition at line 82 of file dsopcode.c.
84{
85 ACPI_OPERAND_OBJECT *ObjDesc;
87
88
89 ObjDesc = AcpiNsGetAttachedObject (ObjHandle);
90
91 /* Namespace is NOT locked */
92
95}
ACPI_STATUS AcpiEvInitializeRegion(ACPI_OPERAND_OBJECT *RegionObj)
Definition: evrgnini.c:629
Referenced by AcpiDsInitOneObject().
◆ AcpiDsInitObjectFromOp()
| ACPI_STATUS AcpiDsInitObjectFromOp | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_PARSE_OBJECT * | Op, | ||
| UINT16 | Opcode, | ||
| ACPI_OPERAND_OBJECT ** | ObjDesc | ||
| ) |
Definition at line 373 of file dsobject.c.
378{
380 ACPI_OPERAND_OBJECT *ObjDesc;
382
383
384 ACPI_FUNCTION_TRACE (DsInitObjectFromOp);
385
386
387 ObjDesc = *RetObjDesc;
390 {
391 /* Unknown opcode */
392
394 }
395
396 /* Perform per-object initialization */
397
399 {
401 /*
402 * Defer evaluation of Buffer TermArg operand
403 */
408 break;
409
411 /*
412 * Defer evaluation of Package TermArg operand and all
413 * package elements. (01/2017): We defer the element
414 * resolution to allow forward references from the package
415 * in order to provide compatibility with other ACPI
416 * implementations.
417 */
420
422 {
424 }
425
428 break;
429
431
433 {
435 /*
436 * Resolve AML Constants here - AND ONLY HERE!
437 * All constants are integers.
438 * We mark the integer with a flag that indicates that it started
439 * life as a constant -- so that stores to constants will perform
440 * as expected (noop). ZeroOp is used as a placeholder for optional
441 * target operands.
442 */
444
446 {
448
450 break;
451
453
455 break;
456
458
460
461 /* Truncate value if we are executing from a 32-bit ACPI table */
462
464 break;
465
467
469 break;
470
471 default:
472
476 break;
477 }
478 break;
479
481
483
485 {
486 /* Warn if we found a 64-bit constant in a 32-bit table */
487
489 "Truncated 64-bit constant found in 32-bit table: %8.8X%8.8X => %8.8X",
492 }
493 break;
494
495 default:
496
498 OpInfo->Type));
500 break;
501 }
502 break;
503
505
508
509 /*
510 * The string is contained in the ACPI table, don't ever try
511 * to delete it
512 */
514 break;
515
517 break;
518
520
522 {
524
525 /* Local ID (0-7) is (AML opcode - base AML_FIRST_LOCAL_OP) */
526
529
534 break;
535
537
538 /* Arg ID (0-6) is (AML opcode - base AML_FIRST_ARG_OP) */
539
542
547 break;
548
549 default: /* Object name or Debug object */
550
552 {
554
555 /* Node was saved in Op */
556
560 {
562 }
563 break;
564
566
568 break;
569
570 default:
571
575 }
576 break;
577 }
578 break;
579
580 default:
581
583 ObjDesc->Common.Type));
584
586 break;
587 }
588
590}
ACPI_STATUS AcpiDsMethodDataGetNode(UINT8 Type, UINT32 Index, ACPI_WALK_STATE *WalkState, ACPI_NAMESPACE_NODE **Node)
Definition: dsmthdat.c:275
Referenced by AcpiDsBuildInternalObject(), and AcpiDsCreateOperand().
◆ AcpiDsInitPackageElement()
| ACPI_STATUS AcpiDsInitPackageElement | ( | UINT8 | ObjectType, |
| ACPI_OPERAND_OBJECT * | SourceObject, | ||
| ACPI_GENERIC_STATE * | State, | ||
| void * | Context | ||
| ) |
Definition at line 369 of file dspkginit.c.
374{
375 ACPI_OPERAND_OBJECT **ElementPtr;
376
377
378 ACPI_FUNCTION_TRACE (DsInitPackageElement);
379
380
381 if (!SourceObject)
382 {
384 }
385
386 /*
387 * The following code is a bit of a hack to workaround a (current)
388 * limitation of the ACPI_PKG_CALLBACK interface. We need a pointer
389 * to the location within the element array because a new object
390 * may be created and stored there.
391 */
393 {
394 /* A direct call was made to this function */
395
397 }
398 else
399 {
400 /* Call came from AcpiUtWalkPackageTree */
401
402 ElementPtr = State->Pkg.ThisTargetObj;
403 }
404
405 /* We are only interested in reference objects/elements */
406
408 {
409 /* Attempt to resolve the (named) reference to a namespace node */
410
411 AcpiDsResolvePackageElement (ElementPtr);
412 }
414 {
416 }
417
419}
static void AcpiDsResolvePackageElement(ACPI_OPERAND_OBJECT **Element)
Definition: dspkginit.c:436
Definition: compobj.c:4795
Referenced by AcpiDsBuildInternalPackageObj(), and AcpiNsInitOnePackage().
◆ AcpiDsIsMethodValue()
| BOOLEAN AcpiDsIsMethodValue | ( | ACPI_OPERAND_OBJECT * | ObjDesc | ) |
◆ AcpiDsIsResultUsed()
| BOOLEAN AcpiDsIsResultUsed | ( | ACPI_PARSE_OBJECT * | Op, |
| ACPI_WALK_STATE * | WalkState | ||
| ) |
Definition at line 187 of file dsutils.c.
190{
192
193 ACPI_FUNCTION_TRACE_PTR (DsIsResultUsed, Op);
194
195
196 /* Must have both an Op and a Result Object */
197
198 if (!Op)
199 {
202 }
203
204 /*
205 * We know that this operator is not a
206 * Return() operator (would not come here.) The following code is the
207 * optional support for a so-called "implicit return". Some AML code
208 * assumes that the last value of the method is "implicitly" returned
209 * to the caller. Just save the last result as the return value.
210 * NOTE: this is optional because the ASL language does not actually
211 * support this behavior.
212 */
214
215 /*
216 * Now determine if the parent will use the result
217 *
218 * If there is no parent, or the parent is a ScopeOp, we are executing
219 * at the method level. An executing method typically has no parent,
220 * since each method is parsed separately. A method invoked externally
221 * via ExecuteControlMethod has a ScopeOp as the parent.
222 */
225 {
226 /* No parent, the return value cannot possibly be used */
227
229 "At Method level, result of [%s] not used\n",
232 }
233
234 /* Get info on the parent. The RootOp is AML_SCOPE */
235
238 {
240 "Unknown parent opcode Op=%p", Op));
242 }
243
244 /*
245 * Decide what to do with the result based on the parent. If
246 * the parent opcode will not use the result, delete the object.
247 * Otherwise leave it as is, it will be deleted when it is used
248 * as an operand later.
249 */
251 {
253
255 {
257
258 /* Never delete the return value associated with a return opcode */
259
260 goto ResultUsed;
261
264 /*
265 * If we are executing the predicate AND this is the predicate op,
266 * we will use the return value
267 */
269 ACPI_CONTROL_PREDICATE_EXECUTING) &&
271 {
272 goto ResultUsed;
273 }
274 break;
275
276 default:
277
278 /* Ignore other control opcodes */
279
280 break;
281 }
282
283 /* The general control opcode returns no result */
284
285 goto ResultNotUsed;
286
288 /*
289 * These opcodes allow TermArg(s) as operands and therefore
290 * the operands can be method calls. The result is used.
291 */
292 goto ResultUsed;
293
295
303 {
304 /*
305 * These opcodes allow TermArg(s) as operands and therefore
306 * the operands can be method calls. The result is used.
307 */
308 goto ResultUsed;
309 }
310
311 goto ResultNotUsed;
312
313 default:
314 /*
315 * In all other cases. the parent will actually use the return
316 * object, so keep it.
317 */
318 goto ResultUsed;
319 }
320
321
322ResultUsed:
324 "Result of [%s] used by Parent [%s] Op=%p\n",
327
329
330
331ResultNotUsed:
333 "Result of [%s] not used by Parent [%s] Op=%p\n",
336
338}
Referenced by AcpiDsDeleteResultIfNotUsed(), and AcpiPsNextParseState().
◆ AcpiDsLoad1BeginOp()
| ACPI_STATUS AcpiDsLoad1BeginOp | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_PARSE_OBJECT ** | OutOp | ||
| ) |
Definition at line 144 of file dswload.c.
147{
148 ACPI_PARSE_OBJECT *Op;
154
155
157
158
159 Op = WalkState->Op;
161
162 /* We are only interested in opcodes that have an associated name */
163
164 if (Op)
165 {
167 {
168 *OutOp = Op;
170 }
171
172 /* Check if this object has already been installed in the namespace */
173
175 {
176 *OutOp = Op;
178 }
179 }
180
182
183 /* Map the raw opcode into an internal object type */
184
186
188 "State=%p Op=%p [%s]\n", WalkState, Op,
190
192 {
194 /*
195 * The target name of the Scope() operator must exist at this point so
196 * that we can actually open the scope to enter new names underneath it.
197 * Allow search-to-root for single namesegs.
198 */
201#ifdef ACPI_ASL_COMPILER
203 {
204 /*
205 * Table disassembly:
206 * Target of Scope() not found. Generate an External for it, and
207 * insert the name into the namespace.
208 */
212 WalkState, &Node);
213 }
214#endif
216 {
219 }
220
221 /*
222 * Check to make sure that the target is
223 * one of the opcodes that actually opens a scope
224 */
226 {
233
234 /* These are acceptable types */
235 break;
236
240 /*
241 * These types we will allow, but we will change the type.
242 * This enables some existing code of the form:
243 *
244 * Name (DEB, 0)
245 * Scope (DEB) { ... }
246 *
247 * Note: silently change the type here. On the second pass,
248 * we will report a warning
249 */
251 "Type override - [%4.4s] had invalid type (%s) "
252 "for Scope operator, changed to type ANY\n",
254
257 break;
258
260 /*
261 * Allow scope change to root during execution of module-level
262 * code. Root is typed METHOD during this time.
263 */
266 {
267 break;
268 }
269
270 ACPI_FALLTHROUGH;
271
272 default:
273
274 /* All other types are an error */
275
277 "Invalid type (%s) for target of "
278 "Scope operator [%4.4s] (Cannot override)",
280
282 }
283 break;
284
285 default:
286 /*
287 * For all other named opcodes, we will enter the name into
288 * the namespace.
289 *
290 * Setup the search flags.
291 * Since we are entering a name into the namespace, we do not want to
292 * enable the search-to-root upsearch.
293 *
294 * There are only two conditions where it is acceptable that the name
295 * already exists:
296 * 1) the Scope() operator can reopen a scoping object that was
297 * previously defined (Scope, Method, Device, etc.)
298 * 2) Whenever we are parsing a deferred opcode (OpRegion, Buffer,
299 * BufferField, or Package), the name of the object is already
300 * in the namespace.
301 */
303 {
304 /* This name is already in the namespace, get the node */
305
308 break;
309 }
310
311 /*
312 * If we are executing a method, do not create any namespace objects
313 * during the load phase, only during execution.
314 */
316 {
319 break;
320 }
321
325 {
327 {
331 }
332 else
333 {
337 }
338 }
339 else
340 {
342 "[%s] Both Find or Create allowed\n",
344 }
345
346 /*
347 * Enter the named type into the internal namespace. We enter the name
348 * as we go downward in the parse tree. Any necessary subobjects that
349 * involve arguments to the opcode must be created as we go back up the
350 * parse tree later.
351 */
355 {
357 {
358 /* The name already exists in this scope */
359
361 {
362 /*
363 * Allow one create on an object or segment that was
364 * previously declared External
365 */
366 Node->Flags &= ~ANOBJ_IS_EXTERNAL;
368
369 /* Just retyped a node, probably will need to open a scope */
370
372 {
376 {
378 }
379 }
380
382 }
383 }
384
386 {
389 }
390 }
391 break;
392 }
393
394 /* Common exit */
395
396 if (!Op)
397 {
398 /* Create a new op */
399
401 if (!Op)
402 {
404 }
405 }
406
407 /* Initialize the op */
408
409#ifdef ACPI_CONSTANT_EVAL_ONLY
411#endif
412
414 {
415 /*
416 * Put the Node in the "op" object that the parser uses, so we
417 * can get it again quickly when this scope is closed
418 */
421 }
422
424 *OutOp = Op;
426}
void AcpiDmAddOpToExternalList(ACPI_PARSE_OBJECT *Op, char *Path, UINT8 Type, UINT32 Value, UINT16 Flags)
char * AcpiPsGetNextNamestring(ACPI_PARSE_STATE *ParserState)
Definition: psargs.c:172
void AcpiPsAppendArg(ACPI_PARSE_OBJECT *op, ACPI_PARSE_OBJECT *arg)
Definition: pstree.c:138
ACPI_PARSE_OBJECT * AcpiPsGetParentScope(ACPI_PARSE_STATE *state)
Definition: psscope.c:65
Referenced by AcpiDsInitCallbacks().
◆ AcpiDsLoad1EndOp()
| ACPI_STATUS AcpiDsLoad1EndOp | ( | ACPI_WALK_STATE * | WalkState | ) |
Definition at line 443 of file dswload.c.
445{
446 ACPI_PARSE_OBJECT *Op;
449#ifdef ACPI_ASL_COMPILER
450 UINT8 ParamCount;
451#endif
452
453
454 ACPI_FUNCTION_TRACE (DsLoad1EndOp);
455
456
457 Op = WalkState->Op;
459
460 /*
461 * Disassembler: handle create field operators here.
462 *
463 * CreateBufferField is a deferred op that is typically processed in load
464 * pass 2. However, disassembly of control method contents walk the parse
465 * tree with ACPI_PARSE_LOAD_PASS1 and AML_CREATE operators are processed
466 * in a later walk. This is a problem when there is a control method that
467 * has the same name as the AML_CREATE object. In this case, any use of the
468 * name segment will be detected as a method call rather than a reference
469 * to a buffer field.
470 *
471 * This earlier creation during disassembly solves this issue by inserting
472 * the named object in the ACPI namespace so that references to this name
473 * would be a name string rather than a method call.
474 */
477 {
480 }
481
482 /* We are only interested in opcodes that have an associated name */
483
485 {
487 }
488
489 /* Get the object type to determine if we should pop the scope */
490
492
494 {
495 /*
496 * If we are executing a method, do not create any namespace objects
497 * during the load phase, only during execution.
498 */
500 {
504 {
506 }
507 }
509 }
510
511 /*
512 * If we are executing a method, do not create any namespace objects
513 * during the load phase, only during execution.
514 */
516 {
518 {
520 (ACPI_ADR_SPACE_TYPE)
521 ((Op->Common.Value.Arg)->Common.Value.Integer),
522 WalkState);
524 {
526 }
527 }
529 {
531 ACPI_ADR_SPACE_DATA_TABLE, WalkState);
533 {
535 }
536 }
537 }
538
540 {
541 /* For Name opcode, get the object type from the argument */
542
544 {
547
548 /* Set node type if we have a namespace node */
549
551 {
553 }
554 }
555 }
556
557#ifdef ACPI_ASL_COMPILER
558 /*
559 * For external opcode, get the object type from the argument and
560 * get the parameter count from the argument's next.
561 */
562 if (AcpiGbl_DisasmFlag &&
563 Op->Common.Node &&
565 {
566 /*
567 * Note, if this external is not a method
568 * Op->Common.Value.Arg->Common.Next->Common.Value.Integer == 0
569 * Therefore, ParamCount will be 0.
570 */
575
577 &Op->Common.Node, ParamCount);
578
579 /*
580 * Add the external to the external list because we may be
581 * emitting code based off of the items within the external list.
582 */
585 }
586#endif
587
588 /*
589 * If we are executing a method, do not create any namespace objects
590 * during the load phase, only during execution.
591 */
593 {
595 {
596 /*
597 * MethodOp PkgLength NameString MethodFlags TermList
598 *
599 * Note: We must create the method node/object pair as soon as we
600 * see the method declaration. This allows later pass1 parsing
601 * of invocations of the method (need to know the number of
602 * arguments.)
603 */
605 "LOADING-Method: State=%p Op=%p NamedObj=%p\n",
606 WalkState, Op, Op->Named.Node));
607
609 {
611 WalkState->NumOperands = 1;
612
614 WalkState, Op->Common.Value.Arg);
616 {
619 }
620
622 WalkState->NumOperands = 0;
623
625 {
627 }
628 }
629 }
630 }
631
632 /* Pop the scope stack (only if loading a table) */
633
637 {
640
642 }
643
645}
void AcpiDmCreateSubobjectForExternal(UINT8 Type, ACPI_NAMESPACE_NODE **Node, UINT32 Value)
ACPI_STATUS AcpiDsCreateBufferField(ACPI_PARSE_OBJECT *Op, ACPI_WALK_STATE *WalkState)
Definition: dsfield.c:165
ACPI_STATUS AcpiDsInitFieldObjects(ACPI_PARSE_OBJECT *Op, ACPI_WALK_STATE *WalkState)
Definition: dsfield.c:617
ACPI_STATUS AcpiExCreateRegion(UINT8 *AmlStart, UINT32 AmlLength, UINT8 SpaceId, ACPI_WALK_STATE *WalkState)
Definition: excreate.c:268
ACPI_STATUS AcpiExCreateMethod(UINT8 *AmlStart, UINT32 AmlLength, ACPI_WALK_STATE *WalkState)
Definition: excreate.c:484
Referenced by AcpiDsInitCallbacks().
◆ AcpiDsLoad2BeginOp()
| ACPI_STATUS AcpiDsLoad2BeginOp | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_PARSE_OBJECT ** | OutOp | ||
| ) |
Definition at line 74 of file dswload2.c.
77{
78 ACPI_PARSE_OBJECT *Op;
82 char *BufferPtr;
84
85
86 ACPI_FUNCTION_TRACE (DsLoad2BeginOp);
87
88
89 Op = WalkState->Op;
91
92 if (Op)
93 {
97 {
98 /* We are executing a while loop outside of a method */
99
102 }
103
104 /* We only care about Namespace opcodes here */
105
109 {
111 }
112
113 /* Get the name we are going to enter or lookup in the namespace */
114
116 {
117 /* For Namepath op, get the path string */
118
119 BufferPtr = Op->Common.Value.String;
120 if (!BufferPtr)
121 {
122 /* No name, just exit */
123
125 }
126 }
127 else
128 {
129 /* Get name from the op */
130
132 }
133 }
134 else
135 {
136 /* Get the namestring from the raw AML */
137
139 }
140
141 /* Map the opcode into an internal object type */
142
144
147
149 {
153
156 break;
157
159 /*
160 * The NamePath is an object reference to an existing object.
161 * Don't enter the name into the namespace, but look it up
162 * for use later.
163 */
166 WalkState, &(Node));
167 break;
168
170
171 /* Special case for Scope(\) -> refers to the Root node */
172
174 {
176
179 {
181 }
182 }
183 else
184 {
185 /*
186 * The Path is an object reference to an existing object.
187 * Don't enter the name into the namespace, but look it up
188 * for use later.
189 */
192 WalkState, &(Node));
194 {
195#ifdef ACPI_ASL_COMPILER
197 {
199 }
200 else
201 {
203 BufferPtr, Status);
204 }
205#else
207 BufferPtr, Status);
208#endif
210 }
211 }
212
213 /*
214 * We must check to make sure that the target is
215 * one of the opcodes that actually opens a scope
216 */
218 {
225
226 /* These are acceptable types */
227 break;
228
232
233 /*
234 * These types we will allow, but we will change the type.
235 * This enables some existing code of the form:
236 *
237 * Name (DEB, 0)
238 * Scope (DEB) { ... }
239 */
241 "Type override - [%4.4s] had invalid type (%s) "
242 "for Scope operator, changed to type ANY",
244
247 break;
248
250
251 /*
252 * Allow scope change to root during execution of module-level
253 * code. Root is typed METHOD during this time.
254 */
257 {
258 break;
259 }
260
261 ACPI_FALLTHROUGH;
262
263 default:
264
265 /* All other types are an error */
266
268 "Invalid type (%s) for target of "
269 "Scope operator [%4.4s] (Cannot override)",
271
273 }
274 break;
275
276 default:
277
278 /* All other opcodes */
279
281 {
282 /* This op/node was previously entered into the namespace */
283
285
287 {
290 {
292 }
293 }
294
296 }
297
298 /*
299 * Enter the named type into the internal namespace. We enter the name
300 * as we go downward in the parse tree. Any necessary subobjects that
301 * involve arguments to the opcode must be created as we go back up the
302 * parse tree later.
303 *
304 * Note: Name may already exist if we are executing a deferred opcode.
305 */
307 {
308 /* This name is already in the namespace, get the node */
309
312 break;
313 }
314
317 {
318 /* Execution mode, node cannot already exist, node is temporary */
319
321
323 {
325 }
326 }
327
328#ifdef ACPI_ASL_COMPILER
329
330 /*
331 * Do not open a scope for AML_EXTERNAL_OP
332 * AcpiNsLookup can open a new scope based on the object type
333 * of this op. AML_EXTERNAL_OP is a declaration rather than a
334 * definition. In the case that this external is a method object,
335 * AcpiNsLookup will open a new scope. However, an AML_EXTERNAL_OP
336 * associated with the ACPI_TYPE_METHOD is a declaration, rather than
337 * a definition. Flags is set to avoid opening a scope for any
338 * AML_EXTERNAL_OP.
339 */
341 {
343 }
344#endif
345
346 /*
347 * For name creation opcodes, the full namepath prefix must
348 * exist, except for the final (new) nameseg.
349 */
351 {
353 }
354
355 /* Add new entry or lookup existing entry */
356
359
361 {
363 "***New Node [%4.4s] %p is temporary\n",
365 }
366 break;
367 }
368
370 {
372 BufferPtr, Status);
374 }
375
376 if (!Op)
377 {
378 /* Create a new op */
379
381 if (!Op)
382 {
384 }
385
386 /* Initialize the new op */
387
389 {
391 }
392 *OutOp = Op;
393 }
394
395 /*
396 * Put the Node in the "op" object that the parser uses, so we
397 * can get it again quickly when this scope is closed
398 */
401}
Referenced by AcpiDsExecBeginOp(), and AcpiDsInitCallbacks().
◆ AcpiDsLoad2EndOp()
| ACPI_STATUS AcpiDsLoad2EndOp | ( | ACPI_WALK_STATE * | WalkState | ) |
Definition at line 418 of file dswload2.c.
420{
421 ACPI_PARSE_OBJECT *Op;
425 ACPI_PARSE_OBJECT *Arg;
426 ACPI_NAMESPACE_NODE *NewNode;
428 UINT8 RegionSpace;
429#ifdef ACPI_EXEC_APP
430 ACPI_OPERAND_OBJECT *ObjDesc;
431 char *Namepath;
432#endif
433
434
435 ACPI_FUNCTION_TRACE (DsLoad2EndOp);
436
437 Op = WalkState->Op;
439 WalkState->OpInfo->Name, Op, WalkState));
440
441 /* Check if opcode had an associated namespace object */
442
444 {
446 }
447
449 {
451 "Ending scope Op=%p State=%p\n", Op, WalkState));
452 }
453
455
456 /*
457 * Get the Node/name from the earlier lookup
458 * (It was saved in the *op structure)
459 */
461
462 /*
463 * Put the Node on the object stack (Contains the ACPI Name of
464 * this object)
465 */
467 WalkState->NumOperands = 1;
468
469 /* Pop the scope stack */
470
473 {
476
479 {
481 }
482 }
483
484 /*
485 * Named operations are as follows:
486 *
487 * AML_ALIAS
488 * AML_BANKFIELD
489 * AML_CREATEBITFIELD
490 * AML_CREATEBYTEFIELD
491 * AML_CREATEDWORDFIELD
492 * AML_CREATEFIELD
493 * AML_CREATEQWORDFIELD
494 * AML_CREATEWORDFIELD
495 * AML_DATA_REGION
496 * AML_DEVICE
497 * AML_EVENT
498 * AML_FIELD
499 * AML_INDEXFIELD
500 * AML_METHOD
501 * AML_METHODCALL
502 * AML_MUTEX
503 * AML_NAME
504 * AML_NAMEDFIELD
505 * AML_OPREGION
506 * AML_POWERRES
507 * AML_PROCESSOR
508 * AML_SCOPE
509 * AML_THERMALZONE
510 */
511
513 "Create-Load [%s] State=%p Op=%p NamedObj=%p\n",
515
516 /* Decode the opcode */
517
518 Arg = Op->Common.Value.Arg;
519
521 {
522
524 /*
525 * Create the field object, but the field buffer and index must
526 * be evaluated later during the execution phase
527 */
530 {
533 }
534 break;
535
537 /*
538 * If we are executing a method, initialize the field
539 */
541 {
543 }
544
546 {
548
551 break;
552
554
556 break;
557
559
561 break;
562
563 default:
564
565 /* All NAMED_FIELD opcodes must be handled above */
566 break;
567 }
568 break;
569
571
574 {
576 }
577
579 {
581
583 break;
584
586
588 break;
589
591
593 break;
594
596
598 break;
599
601
603 break;
604
605 default:
606
607 /* Unknown opcode */
608
611 }
612
613 /* Delete operands */
614
616 {
619 }
620
621 break;
622
624
626 {
629
631 {
632 RegionSpace = (ACPI_ADR_SPACE_TYPE)
633 ((Op->Common.Value.Arg)->Common.Value.Integer);
634 }
635 else
636 {
637 RegionSpace = ACPI_ADR_SPACE_DATA_TABLE;
638 }
639
640 /*
641 * The OpRegion is not fully parsed at this time. The only valid
642 * argument is the SpaceId. (We must save the address of the
643 * AML of the address and length operands)
644 *
645 * If we have a valid region, initialize it. The namespace is
646 * unlocked at this point.
647 *
648 * Need to unlock interpreter if it is locked (if we are running
649 * a control method), in order to allow _REG methods to be run
650 * during AcpiEvInitializeRegion.
651 */
653 {
654 /*
655 * Executing a method: initialize the region and unlock
656 * the interpreter
657 */
661 {
663 }
664 }
665
668 break;
669
671
674 {
676 }
677
678#ifdef ACPI_EXEC_APP
679 /*
680 * AcpiExec support for namespace initialization file (initialize
681 * Name opcodes in this code.)
682 */
684 Status = AeLookupInitFileEntry (Namepath, &ObjDesc);
686 {
687 /* Detach any existing object, attach new object */
688
690 {
692 }
694 }
695 ACPI_FREE (Namepath);
697#endif
698 break;
699
701 /*
702 * MethodOp PkgLength NameString MethodFlags TermList
703 *
704 * Note: We must create the method node/object pair as soon as we
705 * see the method declaration. This allows later pass1 parsing
706 * of invocations of the method (need to know the number of
707 * arguments.)
708 */
710 "LOADING-Method: State=%p Op=%p NamedObj=%p\n",
711 WalkState, Op, Op->Named.Node));
712
714 {
716 WalkState->NumOperands = 1;
717
719 WalkState, Op->Common.Value.Arg);
721 {
724 }
725
727 WalkState->NumOperands = 0;
728
730 {
732 }
733 }
734 break;
735
736
737 default:
738
739 /* All NAMED_COMPLEX opcodes must be handled above */
740 break;
741 }
742 break;
743
745
746 /* case AML_INT_NAMEPATH_OP: */
747 break;
748
750
752 "RESOLVING-MethodCall: State=%p Op=%p NamedObj=%p\n",
753 WalkState, Op, Node));
754
755 /*
756 * Lookup the method name and save the Node
757 */
761 WalkState, &(NewNode));
763 {
764 /*
765 * Make sure that what we found is indeed a method
766 * We didn't search for a method on purpose, to see if the name
767 * would resolve
768 */
770 {
772 }
773
774 /* We could put the returned object (Node) on the object stack for
775 * later, but for now, we will put it in the "op" object that the
776 * parser uses, so we can get it again at the end of this scope
777 */
778 Op->Common.Node = NewNode;
779 }
780 else
781 {
784 }
785 break;
786
787
788 default:
789
790 break;
791 }
792
793Cleanup:
794
795 /* Remove the Node pushed at the very beginning */
796
798 WalkState->NumOperands = 0;
800}
ACPI_STATUS AcpiDsCreateField(ACPI_PARSE_OBJECT *Op, ACPI_NAMESPACE_NODE *RegionNode, ACPI_WALK_STATE *WalkState)
Definition: dsfield.c:534
ACPI_STATUS AcpiDsCreateBankField(ACPI_PARSE_OBJECT *Op, ACPI_NAMESPACE_NODE *RegionNode, ACPI_WALK_STATE *WalkState)
Definition: dsfield.c:748
ACPI_STATUS AcpiDsCreateIndexField(ACPI_PARSE_OBJECT *Op, ACPI_NAMESPACE_NODE *RegionNode, ACPI_WALK_STATE *WalkState)
Definition: dsfield.c:842
ACPI_STATUS AcpiExCreateMutex(ACPI_WALK_STATE *WalkState)
Definition: excreate.c:206
ACPI_STATUS AcpiExCreateEvent(ACPI_WALK_STATE *WalkState)
Definition: excreate.c:147
ACPI_STATUS AcpiExCreateProcessor(ACPI_WALK_STATE *WalkState)
Definition: excreate.c:381
ACPI_STATUS AcpiExCreatePowerResource(ACPI_WALK_STATE *WalkState)
Definition: excreate.c:433
Referenced by AcpiDsExecEndOp(), and AcpiDsInitCallbacks().
◆ AcpiDsMethodDataDeleteAll()
| void AcpiDsMethodDataDeleteAll | ( | ACPI_WALK_STATE * | WalkState | ) |
Definition at line 153 of file dsmthdat.c.
155{
157
158
159 ACPI_FUNCTION_TRACE (DsMethodDataDeleteAll);
160
161
162 /* Detach the locals */
163
165 {
167 {
170
171 /* Detach object (if present) and remove a reference */
172
174 }
175 }
176
177 /* Detach the arguments */
178
180 {
182 {
185
186 /* Detach object (if present) and remove a reference */
187
189 }
190 }
191
192 return_VOID;
193}
struct acpi_namespace_node LocalVariables[ACPI_METHOD_NUM_LOCALS]
Definition: acstruct.h:104
struct acpi_namespace_node Arguments[ACPI_METHOD_NUM_ARGS]
Definition: acstruct.h:103
Referenced by AcpiDsTerminateControlMethod().
◆ AcpiDsMethodDataGetEntry()
| ACPI_STATUS AcpiDsMethodDataGetEntry | ( | UINT16 | Opcode, |
| UINT32 | Index, | ||
| ACPI_WALK_STATE * | WalkState, | ||
| ACPI_OPERAND_OBJECT *** | Node | ||
| ) |
◆ AcpiDsMethodDataGetNode()
| ACPI_STATUS AcpiDsMethodDataGetNode | ( | UINT8 | Type, |
| UINT32 | Index, | ||
| ACPI_WALK_STATE * | WalkState, | ||
| ACPI_NAMESPACE_NODE ** | Node | ||
| ) |
Definition at line 275 of file dsmthdat.c.
280{
281 ACPI_FUNCTION_TRACE (DsMethodDataGetNode);
282
283
284 /*
285 * Method Locals and Arguments are supported
286 */
288 {
290
292 {
294 "Local index %u is invalid (max %u)",
297 }
298
299 /* Return a pointer to the pseudo-node */
300
302 break;
303
305
307 {
309 "Arg index %u is invalid (max %u)",
312 }
313
314 /* Return a pointer to the pseudo-node */
315
317 break;
318
319 default:
320
323 }
324
326}
Referenced by AcpiDsInitObjectFromOp(), AcpiDsMethodDataDeleteValue(), AcpiDsMethodDataGetValue(), AcpiDsMethodDataSetValue(), AcpiDsStoreObjectToLocal(), and AcpiExResolveMultiple().
◆ AcpiDsMethodDataGetValue()
| ACPI_STATUS AcpiDsMethodDataGetValue | ( | UINT8 | Type, |
| UINT32 | Index, | ||
| ACPI_WALK_STATE * | WalkState, | ||
| ACPI_OPERAND_OBJECT ** | DestDesc | ||
| ) |
Definition at line 406 of file dsmthdat.c.
411{
415
416
417 ACPI_FUNCTION_TRACE (DsMethodDataGetValue);
418
419
420 /* Validate the object descriptor */
421
422 if (!DestDesc)
423 {
426 }
427
428 /* Get the namespace node for the arg/local */
429
432 {
434 }
435
436 /* Get the object from the node */
437
439
440 /* Examine the returned object, it must be valid. */
441
443 {
444 /*
445 * Index points to uninitialized object.
446 * This means that either 1) The expected argument was
447 * not passed to the method, or 2) A local variable
448 * was referenced by the method (via the ASL)
449 * before it was initialized. Either case is an error.
450 */
451
452 /* If slack enabled, init the LocalX/ArgX to an Integer of value zero */
453
454 if (AcpiGbl_EnableInterpreterSlack)
455 {
458 {
460 }
461
463 }
464
465 /* Otherwise, return the error */
466
468 {
470
472 "Uninitialized Arg[%u] at node %p",
474
476
478 /*
479 * No error message for this case, will be trapped again later to
480 * detect and ignore cases of Store(LocalX,LocalX)
481 */
483
484 default:
485
488 }
489 }
490
491 /*
492 * The Index points to an initialized and valid object.
493 * Return an additional reference to the object
494 */
495 *DestDesc = Object;
497
499}
ACPI_OPERAND_OBJECT * AcpiUtCreateIntegerObject(UINT64 Value)
Definition: utobject.c:223
Referenced by AcpiExOpcode_1A_0T_1R(), AcpiExResolveMultiple(), and AcpiExResolveObjectToValue().
◆ AcpiDsMethodDataInit()
| void AcpiDsMethodDataInit | ( | ACPI_WALK_STATE * | WalkState | ) |
Definition at line 100 of file dsmthdat.c.
102{
104
105
106 ACPI_FUNCTION_TRACE (DsMethodDataInit);
107
108
109 /* Init the method arguments */
110
112 {
114 NAMEOF_ARG_NTE);
115
120 }
121
122 /* Init the method locals */
123
125 {
127 NAMEOF_LOCAL_NTE);
128
133 }
134
135 return_VOID;
136}
Referenced by AcpiDsCreateWalkState().
◆ AcpiDsMethodDataInitArgs()
| ACPI_STATUS AcpiDsMethodDataInitArgs | ( | ACPI_OPERAND_OBJECT ** | Params, |
| UINT32 | MaxParamCount, | ||
| ACPI_WALK_STATE * | WalkState | ||
| ) |
Definition at line 213 of file dsmthdat.c.
217{
220
221
223
224
226 {
228 "No parameter list passed to method\n"));
230 }
231
232 /* Copy passed parameters into the new method stack frame */
233
235 (Index < MaxParamCount) &&
237 {
238 /*
239 * A valid parameter.
240 * Store the argument in the method/walk descriptor.
241 * Do not copy the arg in order to implement call by reference
242 */
246 {
248 }
249
250 Index++;
251 }
252
255}
static ACPI_STATUS AcpiDsMethodDataSetValue(UINT8 Type, UINT32 Index, ACPI_OPERAND_OBJECT *Object, ACPI_WALK_STATE *WalkState)
Definition: dsmthdat.c:347
Referenced by AcpiDsInitAmlWalk().
◆ AcpiDsMethodError()
| ACPI_STATUS AcpiDsMethodError | ( | ACPI_STATUS | Status, |
| ACPI_WALK_STATE * | WalkState | ||
| ) |
Definition at line 223 of file dsmethod.c.
226{
227 UINT32 AmlOffset;
229
230
231 ACPI_FUNCTION_ENTRY ();
232
233
234 /* Ignore AE_OK and control exception codes */
235
238 {
240 }
241
242 /* Invoke the global exception handler */
243
244 if (AcpiGbl_ExceptionHandler)
245 {
246 /* Exit the interpreter, allow handler to execute methods */
247
248 AcpiExExitInterpreter ();
249
250 /*
251 * Handler can map the exception code to anything it wants, including
252 * AE_OK, in which case the executing method will not be aborted.
253 */
256
258 {
260 }
262 {
264 }
265
268 AcpiExEnterInterpreter ();
269 }
270
271 AcpiDsClearImplicitReturn (WalkState);
272
274 {
276
277 /* Display method locals/args if debugger is present */
278
279#ifdef ACPI_DEBUGGER
281#endif
282 }
283
285}
void AcpiDbDumpMethodInfo(ACPI_STATUS Status, ACPI_WALK_STATE *WalkState)
void AcpiDsDumpMethodStack(ACPI_STATUS Status, ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op)
Definition: dsdebug.c:249
Definition: apinames.c:49
Referenced by AcpiDsExecBeginOp(), AcpiDsExecEndOp(), AcpiPsGetNextNamepath(), and AcpiPsParseAml().
◆ AcpiDsObjStackPop()
| ACPI_STATUS AcpiDsObjStackPop | ( | UINT32 | PopCount, |
| ACPI_WALK_STATE * | WalkState | ||
| ) |
Definition at line 391 of file dswstate.c.
394{
396
397
398 ACPI_FUNCTION_NAME (DsObjStackPop);
399
400
402 {
403 /* Check for stack underflow */
404
406 {
408 "Object stack underflow! Count=%X State=%p #Ops=%u",
409 PopCount, WalkState, WalkState->NumOperands));
411 }
412
413 /* Just set the stack entry to null */
414
415 WalkState->NumOperands--;
417 }
418
420 PopCount, WalkState, WalkState->NumOperands));
421
423}
Referenced by AcpiDsEvalDataObjectOperands(), and AcpiDsEvaluateNamePath().
◆ AcpiDsObjStackPopAndDelete()
| void AcpiDsObjStackPopAndDelete | ( | UINT32 | PopCount, |
| ACPI_WALK_STATE * | WalkState | ||
| ) |
Definition at line 441 of file dswstate.c.
444{
446 ACPI_OPERAND_OBJECT *ObjDesc;
447
448
449 ACPI_FUNCTION_NAME (DsObjStackPopAndDelete);
450
451
452 if (PopCount == 0)
453 {
454 return;
455 }
456
458 {
460 {
461 return;
462 }
463
464 /* Pop the stack and delete an object if present in this stack entry */
465
466 WalkState->NumOperands--;
468 if (ObjDesc)
469 {
472 }
473 }
474
476 PopCount, WalkState, WalkState->NumOperands));
477}
Referenced by AcpiDsCreateOperands().
◆ AcpiDsObjStackPush()
| ACPI_STATUS AcpiDsObjStackPush | ( | void * | Object, |
| ACPI_WALK_STATE * | WalkState | ||
| ) |
Definition at line 342 of file dswstate.c.
345{
346 ACPI_FUNCTION_NAME (DsObjStackPush);
347
348
349 /* Check for stack overflow */
350
352 {
354 "Object stack overflow! Obj=%p State=%p #Ops=%u",
357 }
358
359 /* Put the object onto the stack */
360
362 WalkState->NumOperands++;
363
364 /* For the usual order of filling the operand stack */
365
366 WalkState->OperandIndex++;
367
370 WalkState, WalkState->NumOperands));
371
373}
const char * AcpiUtGetObjectTypeName(ACPI_OPERAND_OBJECT *ObjDesc)
Definition: utdecode.c:264
Referenced by AcpiDsCreateOperand().
◆ AcpiDsPopWalkState()
| ACPI_WALK_STATE * AcpiDsPopWalkState | ( | ACPI_THREAD_STATE * | Thread | ) |
Definition at line 555 of file dswstate.c.
557{
558 ACPI_WALK_STATE *WalkState;
559
560
561 ACPI_FUNCTION_TRACE (DsPopWalkState);
562
563
564 WalkState = Thread->WalkStateList;
565
566 if (WalkState)
567 {
568 /* Next walk state becomes the current walk state */
569
571
572 /*
573 * Don't clear the NEXT field, this serves as an indicator
574 * that there is a parent WALK STATE
575 * Do Not: WalkState->Next = NULL;
576 */
577 }
578
579 return_PTR (WalkState);
580}
Referenced by AcpiPsParseAml().
◆ AcpiDsPushWalkState()
| void AcpiDsPushWalkState | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_THREAD_STATE * | Thread | ||
| ) |
Definition at line 526 of file dswstate.c.
529{
530 ACPI_FUNCTION_TRACE (DsPushWalkState);
531
532
534 Thread->WalkStateList = WalkState;
535
536 return_VOID;
537}
Referenced by AcpiDsCreateWalkState(), and AcpiPsParseAml().
◆ AcpiDsResolveOperands()
| ACPI_STATUS AcpiDsResolveOperands | ( | ACPI_WALK_STATE * | WalkState | ) |
Definition at line 412 of file dsutils.c.
414{
417
418
419 ACPI_FUNCTION_TRACE_PTR (DsResolveOperands, WalkState);
420
421
422 /*
423 * Attempt to resolve each of the valid operands
424 * Method arguments are passed by reference, not by value. This means
425 * that the actual objects are passed, not copies of the objects.
426 */
428 {
431 {
432 break;
433 }
434 }
435
437}
Referenced by AcpiDsExecEndOp().
◆ AcpiDsRestartControlMethod()
| ACPI_STATUS AcpiDsRestartControlMethod | ( | ACPI_WALK_STATE * | WalkState, |
| ACPI_OPERAND_OBJECT * | ReturnDesc | ||
| ) |
Definition at line 685 of file dsmethod.c.
688{
690 int SameAsImplicitReturn;
691
692
693 ACPI_FUNCTION_TRACE_PTR (DsRestartControlMethod, WalkState);
694
695
697 "****Restart [%4.4s] Op %p ReturnValueFromCallee %p\n",
699 WalkState->MethodCallOp, ReturnDesc));
700
702 " ReturnFromThisMethodUsed?=%X ResStack %p Walk %p\n",
703 WalkState->ReturnUsed,
704 WalkState->Results, WalkState));
705
706 /* Did the called method return a value? */
707
708 if (ReturnDesc)
709 {
710 /* Is the implicit return object the same as the return desc? */
711
712 SameAsImplicitReturn = (WalkState->ImplicitReturnObj == ReturnDesc);
713
714 /* Are we actually going to use the return value? */
715
717 {
718 /* Save the return value from the previous method */
719
722 {
723 AcpiUtRemoveReference (ReturnDesc);
725 }
726
727 /*
728 * Save as THIS method's return value in case it is returned
729 * immediately to yet another method
730 */
731 WalkState->ReturnDesc = ReturnDesc;
732 }
733
734 /*
735 * The following code is the optional support for the so-called
736 * "implicit return". Some AML code assumes that the last value of the
737 * method is "implicitly" returned to the caller, in the absence of an
738 * explicit return value.
739 *
740 * Just save the last result of the method as the return value.
741 *
742 * NOTE: this is optional because the ASL language does not actually
743 * support this behavior.
744 */
746 SameAsImplicitReturn)
747 {
748 /*
749 * Delete the return value if it will not be used by the
750 * calling method or remove one reference if the explicit return
751 * is the same as the implicit return value.
752 */
753 AcpiUtRemoveReference (ReturnDesc);
754 }
755 }
756
758}
Referenced by AcpiPsParseAml().
◆ AcpiDsResultPop()
| ACPI_STATUS AcpiDsResultPop | ( | ACPI_OPERAND_OBJECT ** | Object, |
| ACPI_WALK_STATE * | WalkState | ||
| ) |
Definition at line 78 of file dswstate.c.
81{
85
86
87 ACPI_FUNCTION_NAME (DsResultPop);
88
89
91
92 /* Incorrect state of result stack */
93
95 {
98 }
99
101 {
104 }
105
106 /* Empty result stack */
107
109 {
112 }
113
114 /* Return object of the top element and clean that top element result stack */
115
116 WalkState->ResultCount--;
118
121 {
123 WalkState));
125 }
126
129 {
132 {
134 }
135 }
136
141
143}
static ACPI_STATUS AcpiDsResultStackPop(ACPI_WALK_STATE *WalkState)
Definition: dswstate.c:289
Referenced by AcpiDsCreateOperand(), AcpiDsDeleteResultIfNotUsed(), and AcpiDsGetPredicateValue().
◆ AcpiDsResultPush()
| ACPI_STATUS AcpiDsResultPush | ( | ACPI_OPERAND_OBJECT * | Object, |
| ACPI_WALK_STATE * | WalkState | ||
| ) |
Definition at line 160 of file dswstate.c.
163{
167
168
169 ACPI_FUNCTION_NAME (DsResultPush);
170
171
173 {
176 }
178 {
179 /* Extend the result stack */
180
183 {
186 }
187 }
188
190 {
193 }
194
197 {
200 }
201
203 {
205 "Null Object! Obj=%p State=%p Num=%u",
208 }
209
210 /* Assign the address of object to the top free element of result stack */
211
214 WalkState->ResultCount++;
215
219
221}
static ACPI_STATUS AcpiDsResultStackPush(ACPI_WALK_STATE *WalkState)
Definition: dswstate.c:237
Referenced by AcpiDsEvaluateNamePath(), AcpiDsExecEndOp(), and AcpiDsRestartControlMethod().
◆ AcpiDsResultStackClear()
| ACPI_STATUS AcpiDsResultStackClear | ( | ACPI_WALK_STATE * | WalkState | ) |
◆ AcpiDsScopeStackClear()
| void AcpiDsScopeStackClear | ( | ACPI_WALK_STATE * | WalkState | ) |
Definition at line 67 of file dswscope.c.
69{
70 ACPI_GENERIC_STATE *ScopeInfo;
71
72 ACPI_FUNCTION_NAME (DsScopeStackClear);
73
74
76 {
77 /* Pop a scope off the stack */
78
79 ScopeInfo = WalkState->ScopeInfo;
81
83 "Popped object type (%s)\n",
85
86 AcpiUtDeleteGenericState (ScopeInfo);
87 }
88}
Referenced by AcpiPsExecuteMethod(), and AcpiPsParseAml().
◆ AcpiDsScopeStackPop()
| ACPI_STATUS AcpiDsScopeStackPop | ( | ACPI_WALK_STATE * | WalkState | ) |
Definition at line 192 of file dswscope.c.
194{
195 ACPI_GENERIC_STATE *ScopeInfo;
196 ACPI_GENERIC_STATE *NewScopeInfo;
197
198
199 ACPI_FUNCTION_TRACE (DsScopeStackPop);
200
201
202 /*
203 * Pop scope info object off the stack.
204 */
206 if (!ScopeInfo)
207 {
209 }
210
211 WalkState->ScopeDepth--;
212
214 "[%.2d] Popped scope [%4.4s] (%s), New scope -> ",
218
219 NewScopeInfo = WalkState->ScopeInfo;
220 if (NewScopeInfo)
221 {
225 }
226 else
227 {
229 }
230
231 AcpiUtDeleteGenericState (ScopeInfo);
233}
Referenced by AcpiDsExecBeginOp(), AcpiDsLoad1EndOp(), and AcpiDsLoad2EndOp().
◆ AcpiDsScopeStackPush()
| ACPI_STATUS AcpiDsScopeStackPush | ( | ACPI_NAMESPACE_NODE * | Node, |
| ACPI_OBJECT_TYPE | Type, | ||
| ACPI_WALK_STATE * | WalkState | ||
| ) |
Definition at line 107 of file dswscope.c.
111{
112 ACPI_GENERIC_STATE *ScopeInfo;
113 ACPI_GENERIC_STATE *OldScopeInfo;
114
115
116 ACPI_FUNCTION_TRACE (DsScopeStackPush);
117
118
120 {
121 /* Invalid scope */
122
125 }
126
127 /* Make sure object type is valid */
128
130 {
133 }
134
135 /* Allocate a new scope object */
136
137 ScopeInfo = AcpiUtCreateGenericState ();
138 if (!ScopeInfo)
139 {
141 }
142
143 /* Init new scope object */
144
148
149 WalkState->ScopeDepth++;
150
153
154 OldScopeInfo = WalkState->ScopeInfo;
155 if (OldScopeInfo)
156 {
158 "[%4.4s] (%s)",
161 }
162 else
163 {
165 }
166
168 ", New scope -> [%4.4s] (%s)\n",
171
172 /* Push new scope object onto stack */
173
176}
ACPI_GENERIC_STATE * AcpiUtCreateGenericState(void)
Definition: utstate.c:130
Referenced by AcpiDsExecBeginOp(), AcpiDsInitAmlWalk(), AcpiDsLoad1BeginOp(), AcpiDsLoad2BeginOp(), AcpiNsLookup(), AcpiNsOneCompleteParse(), and AcpiPsExecuteTable().
◆ AcpiDsStoreObjectToLocal()
| ACPI_STATUS AcpiDsStoreObjectToLocal | ( | UINT8 | Type, |
| UINT32 | Index, | ||
| ACPI_OPERAND_OBJECT * | SrcDesc, | ||
| ACPI_WALK_STATE * | WalkState | ||
| ) |
Definition at line 585 of file dsmthdat.c.
590{
593 ACPI_OPERAND_OBJECT *CurrentObjDesc;
594 ACPI_OPERAND_OBJECT *NewObjDesc;
595
596
597 ACPI_FUNCTION_TRACE (DsStoreObjectToLocal);
600
601 /* Parameter validation */
602
603 if (!ObjDesc)
604 {
606 }
607
608 /* Get the namespace node for the arg/local */
609
612 {
614 }
615
617 if (CurrentObjDesc == ObjDesc)
618 {
620 ObjDesc));
622 }
623
624 /*
625 * If the reference count on the object is more than one, we must
626 * take a copy of the object before we store. A reference count
627 * of exactly 1 means that the object was just created during the
628 * evaluation of an expression, and we can safely use it since it
629 * is not used anywhere else.
630 */
631 NewObjDesc = ObjDesc;
632 if (ObjDesc->Common.ReferenceCount > 1)
633 {
635 ObjDesc, &NewObjDesc, WalkState);
637 {
639 }
640 }
641
642 /*
643 * If there is an object already in this slot, we either
644 * have to delete it, or if this is an argument and there
645 * is an object reference stored there, we have to do
646 * an indirect store!
647 */
648 if (CurrentObjDesc)
649 {
650 /*
651 * Check for an indirect store if an argument
652 * contains an object reference (stored as an Node).
653 * We don't allow this automatic dereferencing for
654 * locals, since a store to a local should overwrite
655 * anything there, including an object reference.
656 *
657 * If both Arg0 and Local0 contain RefOf (Local4):
658 *
659 * Store (1, Arg0) - Causes indirect store to local4
660 * Store (1, Local0) - Stores 1 in local0, overwriting
661 * the reference to local4
662 * Store (1, DeRefof (Local0)) - Causes indirect store to local4
663 *
664 * Weird, but true.
665 */
667 {
668 /*
669 * If we have a valid reference object that came from RefOf(),
670 * do the indirect store
671 */
673 ACPI_DESC_TYPE_OPERAND) &&
674 (CurrentObjDesc->Common.Type ==
675 ACPI_TYPE_LOCAL_REFERENCE) &&
677 ACPI_REFCLASS_REFOF))
678 {
680 "Arg (%p) is an ObjRef(Node), storing in node %p\n",
681 NewObjDesc, CurrentObjDesc));
682
683 /*
684 * Store this object to the Node (perform the indirect store)
685 * NOTE: No implicit conversion is performed, as per the ACPI
686 * specification rules on storing to Locals/Args.
687 */
691
692 /* Remove local reference if we copied the object above */
693
694 if (NewObjDesc != ObjDesc)
695 {
696 AcpiUtRemoveReference (NewObjDesc);
697 }
698
700 }
701 }
702
703 /* Delete the existing object before storing the new one */
704
706 }
707
708 /*
709 * Install the Obj descriptor (*NewObjDesc) into
710 * the descriptor for the Arg or Local.
711 * (increments the object reference count by one)
712 */
714
715 /* Remove local reference if we copied the object above */
716
717 if (NewObjDesc != ObjDesc)
718 {
719 AcpiUtRemoveReference (NewObjDesc);
720 }
721
723}
static void AcpiDsMethodDataDeleteValue(UINT8 Type, UINT32 Index, ACPI_WALK_STATE *WalkState)
Definition: dsmthdat.c:519
ACPI_STATUS AcpiExStoreObjectToNode(ACPI_OPERAND_OBJECT *SourceDesc, ACPI_NAMESPACE_NODE *Node, ACPI_WALK_STATE *WalkState, UINT8 ImplicitConversion)
Definition: exstore.c:412
Referenced by AcpiExStore().
◆ AcpiDsTerminateControlMethod()
| void AcpiDsTerminateControlMethod | ( | ACPI_OPERAND_OBJECT * | MethodDesc, |
| ACPI_WALK_STATE * | WalkState | ||
| ) |
Definition at line 779 of file dsmethod.c.
782{
783
784 ACPI_FUNCTION_TRACE_PTR (DsTerminateControlMethod, WalkState);
785
786
787 /* MethodDesc is required, WalkState is optional */
788
789 if (!MethodDesc)
790 {
791 return_VOID;
792 }
793
794 if (WalkState)
795 {
796 /* Delete all arguments and locals */
797
798 AcpiDsMethodDataDeleteAll (WalkState);
799
800 /*
801 * Delete any namespace objects created anywhere within the
802 * namespace by the execution of this method. Unless:
803 * 1) This method is a module-level executable code method, in which
804 * case we want make the objects permanent.
805 * 2) There are other threads executing the method, in which case we
806 * will wait until the last thread has completed.
807 */
810 {
811 /* Delete any direct children of (created by) this method */
812
816
817 /*
818 * Delete any objects that were created by this method
819 * elsewhere in the namespace (if any were created).
820 * Use of the ACPI_METHOD_MODIFIED_NAMESPACE optimizes the
821 * deletion such that we don't have to perform an entire
822 * namespace walk for every control method execution.
823 */
825 {
830 ~ACPI_METHOD_MODIFIED_NAMESPACE;
831 }
832 }
833
834 /*
835 * If method is serialized, release the mutex and restore the
836 * current sync level for this thread
837 */
839 {
840 /* Acquisition Depth handles recursive calls */
841
844 {
847
848 AcpiOsReleaseMutex (
851 }
852 }
853 }
854
855 /* Decrement the thread count on the method */
856
858 {
860 }
861 else
862 {
864 "Invalid zero thread count in method"));
865 }
866
867 /* Are there any other threads currently executing this method? */
868
870 {
871 /*
872 * Additional threads. Do not release the OwnerId in this case,
873 * we immediately reuse it for the next thread executing this method
874 */
876 "*** Completed execution of one thread, %u threads remaining\n",
878 }
879 else
880 {
881 /* This is the only executing thread for this method */
882
883 /*
884 * Support to dynamically change a method from NotSerialized to
885 * Serialized if it appears that the method is incorrectly written and
886 * does not support multiple thread execution. The best example of this
887 * is if such a method creates namespace objects and blocks. A second
888 * thread will fail with an AE_ALREADY_EXISTS exception.
889 *
890 * This code is here because we must wait until the last thread exits
891 * before marking the method as serialized.
892 */
894 {
895 if (WalkState)
896 {
897 ACPI_INFO ((
898 "Marking method %4.4s as Serialized "
899 "because of AE_ALREADY_EXISTS error",
900 WalkState->MethodNode->Name.Ascii));
901 }
902
903 /*
904 * Method tried to create an object twice and was marked as
905 * "pending serialized". The probable cause is that the method
906 * cannot handle reentrancy.
907 *
908 * The method was created as NotSerialized, but it tried to create
909 * a named object and then blocked, causing the second thread
910 * entrance to begin and then fail. Workaround this problem by
911 * marking the method permanently as Serialized when the last
912 * thread exits here.
913 */
915 ~ACPI_METHOD_SERIALIZED_PENDING;
916
920 }
921
922 /* No more threads, we can free the OwnerId */
923
925 {
927 }
928 }
929
931 MethodDesc, WalkState);
932
933 return_VOID;
934}
void AcpiNsDeleteNamespaceSubtree(ACPI_NAMESPACE_NODE *ParentHandle)
Definition: nsalloc.c:399
void AcpiNsDeleteNamespaceByOwner(ACPI_OWNER_ID OwnerId)
Definition: nsalloc.c:497
void AcpiDsMethodDataDeleteAll(ACPI_WALK_STATE *WalkState)
Definition: dsmthdat.c:153
void AcpiExStopTraceMethod(ACPI_NAMESPACE_NODE *MethodNode, ACPI_OPERAND_OBJECT *ObjDesc, ACPI_WALK_STATE *WalkState)
Definition: extrace.c:290
Referenced by AcpiDsCallControlMethod(), AcpiPsExecuteMethod(), and AcpiPsParseAml().
