aslwalks.c revision 1.1.1.1 1 1.1 jruoho /******************************************************************************
2 1.1 jruoho *
3 1.1 jruoho * Module Name: aslwalks.c - major analytical parse tree walks
4 1.1 jruoho *
5 1.1 jruoho *****************************************************************************/
6 1.1 jruoho
7 1.1 jruoho /*
8 1.1 jruoho * Copyright (C) 2000 - 2011, Intel Corp.
9 1.1 jruoho * All rights reserved.
10 1.1 jruoho *
11 1.1 jruoho * Redistribution and use in source and binary forms, with or without
12 1.1 jruoho * modification, are permitted provided that the following conditions
13 1.1 jruoho * are met:
14 1.1 jruoho * 1. Redistributions of source code must retain the above copyright
15 1.1 jruoho * notice, this list of conditions, and the following disclaimer,
16 1.1 jruoho * without modification.
17 1.1 jruoho * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 1.1 jruoho * substantially similar to the "NO WARRANTY" disclaimer below
19 1.1 jruoho * ("Disclaimer") and any redistribution must be conditioned upon
20 1.1 jruoho * including a substantially similar Disclaimer requirement for further
21 1.1 jruoho * binary redistribution.
22 1.1 jruoho * 3. Neither the names of the above-listed copyright holders nor the names
23 1.1 jruoho * of any contributors may be used to endorse or promote products derived
24 1.1 jruoho * from this software without specific prior written permission.
25 1.1 jruoho *
26 1.1 jruoho * Alternatively, this software may be distributed under the terms of the
27 1.1 jruoho * GNU General Public License ("GPL") version 2 as published by the Free
28 1.1 jruoho * Software Foundation.
29 1.1 jruoho *
30 1.1 jruoho * NO WARRANTY
31 1.1 jruoho * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 1.1 jruoho * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 1.1 jruoho * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 1.1 jruoho * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 1.1 jruoho * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 1.1 jruoho * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 1.1 jruoho * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 1.1 jruoho * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 1.1 jruoho * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 1.1 jruoho * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 1.1 jruoho * POSSIBILITY OF SUCH DAMAGES.
42 1.1 jruoho */
43 1.1 jruoho
44 1.1 jruoho
45 1.1 jruoho #include "aslcompiler.h"
46 1.1 jruoho #include "aslcompiler.y.h"
47 1.1 jruoho #include "acparser.h"
48 1.1 jruoho #include "amlcode.h"
49 1.1 jruoho
50 1.1 jruoho
51 1.1 jruoho #define _COMPONENT ACPI_COMPILER
52 1.1 jruoho ACPI_MODULE_NAME ("aslwalks")
53 1.1 jruoho
54 1.1 jruoho
55 1.1 jruoho /*******************************************************************************
56 1.1 jruoho *
57 1.1 jruoho * FUNCTION: AnMethodAnalysisWalkBegin
58 1.1 jruoho *
59 1.1 jruoho * PARAMETERS: ASL_WALK_CALLBACK
60 1.1 jruoho *
61 1.1 jruoho * RETURN: Status
62 1.1 jruoho *
63 1.1 jruoho * DESCRIPTION: Descending callback for the analysis walk. Check methods for:
64 1.1 jruoho * 1) Initialized local variables
65 1.1 jruoho * 2) Valid arguments
66 1.1 jruoho * 3) Return types
67 1.1 jruoho *
68 1.1 jruoho ******************************************************************************/
69 1.1 jruoho
70 1.1 jruoho ACPI_STATUS
71 1.1 jruoho AnMethodAnalysisWalkBegin (
72 1.1 jruoho ACPI_PARSE_OBJECT *Op,
73 1.1 jruoho UINT32 Level,
74 1.1 jruoho void *Context)
75 1.1 jruoho {
76 1.1 jruoho ASL_ANALYSIS_WALK_INFO *WalkInfo = (ASL_ANALYSIS_WALK_INFO *) Context;
77 1.1 jruoho ASL_METHOD_INFO *MethodInfo = WalkInfo->MethodStack;
78 1.1 jruoho ACPI_PARSE_OBJECT *Next;
79 1.1 jruoho UINT32 RegisterNumber;
80 1.1 jruoho UINT32 i;
81 1.1 jruoho char LocalName[] = "Local0";
82 1.1 jruoho char ArgName[] = "Arg0";
83 1.1 jruoho ACPI_PARSE_OBJECT *ArgNode;
84 1.1 jruoho ACPI_PARSE_OBJECT *NextType;
85 1.1 jruoho ACPI_PARSE_OBJECT *NextParamType;
86 1.1 jruoho UINT8 ActualArgs = 0;
87 1.1 jruoho
88 1.1 jruoho
89 1.1 jruoho switch (Op->Asl.ParseOpcode)
90 1.1 jruoho {
91 1.1 jruoho case PARSEOP_METHOD:
92 1.1 jruoho
93 1.1 jruoho TotalMethods++;
94 1.1 jruoho
95 1.1 jruoho /* Create and init method info */
96 1.1 jruoho
97 1.1 jruoho MethodInfo = UtLocalCalloc (sizeof (ASL_METHOD_INFO));
98 1.1 jruoho MethodInfo->Next = WalkInfo->MethodStack;
99 1.1 jruoho MethodInfo->Op = Op;
100 1.1 jruoho
101 1.1 jruoho WalkInfo->MethodStack = MethodInfo;
102 1.1 jruoho
103 1.1 jruoho /* Get the name node, ignored here */
104 1.1 jruoho
105 1.1 jruoho Next = Op->Asl.Child;
106 1.1 jruoho
107 1.1 jruoho /* Get the NumArguments node */
108 1.1 jruoho
109 1.1 jruoho Next = Next->Asl.Next;
110 1.1 jruoho MethodInfo->NumArguments = (UINT8)
111 1.1 jruoho (((UINT8) Next->Asl.Value.Integer) & 0x07);
112 1.1 jruoho
113 1.1 jruoho /* Get the SerializeRule and SyncLevel nodes, ignored here */
114 1.1 jruoho
115 1.1 jruoho Next = Next->Asl.Next;
116 1.1 jruoho Next = Next->Asl.Next;
117 1.1 jruoho ArgNode = Next;
118 1.1 jruoho
119 1.1 jruoho /* Get the ReturnType node */
120 1.1 jruoho
121 1.1 jruoho Next = Next->Asl.Next;
122 1.1 jruoho
123 1.1 jruoho NextType = Next->Asl.Child;
124 1.1 jruoho while (NextType)
125 1.1 jruoho {
126 1.1 jruoho /* Get and map each of the ReturnTypes */
127 1.1 jruoho
128 1.1 jruoho MethodInfo->ValidReturnTypes |= AnMapObjTypeToBtype (NextType);
129 1.1 jruoho NextType->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
130 1.1 jruoho NextType = NextType->Asl.Next;
131 1.1 jruoho }
132 1.1 jruoho
133 1.1 jruoho /* Get the ParameterType node */
134 1.1 jruoho
135 1.1 jruoho Next = Next->Asl.Next;
136 1.1 jruoho
137 1.1 jruoho NextType = Next->Asl.Child;
138 1.1 jruoho while (NextType)
139 1.1 jruoho {
140 1.1 jruoho if (NextType->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
141 1.1 jruoho {
142 1.1 jruoho NextParamType = NextType->Asl.Child;
143 1.1 jruoho while (NextParamType)
144 1.1 jruoho {
145 1.1 jruoho MethodInfo->ValidArgTypes[ActualArgs] |= AnMapObjTypeToBtype (NextParamType);
146 1.1 jruoho NextParamType->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
147 1.1 jruoho NextParamType = NextParamType->Asl.Next;
148 1.1 jruoho }
149 1.1 jruoho }
150 1.1 jruoho else
151 1.1 jruoho {
152 1.1 jruoho MethodInfo->ValidArgTypes[ActualArgs] =
153 1.1 jruoho AnMapObjTypeToBtype (NextType);
154 1.1 jruoho NextType->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
155 1.1 jruoho ActualArgs++;
156 1.1 jruoho }
157 1.1 jruoho
158 1.1 jruoho NextType = NextType->Asl.Next;
159 1.1 jruoho }
160 1.1 jruoho
161 1.1 jruoho if ((MethodInfo->NumArguments) &&
162 1.1 jruoho (MethodInfo->NumArguments != ActualArgs))
163 1.1 jruoho {
164 1.1 jruoho /* error: Param list did not match number of args */
165 1.1 jruoho }
166 1.1 jruoho
167 1.1 jruoho /* Allow numarguments == 0 for Function() */
168 1.1 jruoho
169 1.1 jruoho if ((!MethodInfo->NumArguments) && (ActualArgs))
170 1.1 jruoho {
171 1.1 jruoho MethodInfo->NumArguments = ActualArgs;
172 1.1 jruoho ArgNode->Asl.Value.Integer |= ActualArgs;
173 1.1 jruoho }
174 1.1 jruoho
175 1.1 jruoho /*
176 1.1 jruoho * Actual arguments are initialized at method entry.
177 1.1 jruoho * All other ArgX "registers" can be used as locals, so we
178 1.1 jruoho * track their initialization.
179 1.1 jruoho */
180 1.1 jruoho for (i = 0; i < MethodInfo->NumArguments; i++)
181 1.1 jruoho {
182 1.1 jruoho MethodInfo->ArgInitialized[i] = TRUE;
183 1.1 jruoho }
184 1.1 jruoho break;
185 1.1 jruoho
186 1.1 jruoho
187 1.1 jruoho case PARSEOP_METHODCALL:
188 1.1 jruoho
189 1.1 jruoho if (MethodInfo &&
190 1.1 jruoho (Op->Asl.Node == MethodInfo->Op->Asl.Node))
191 1.1 jruoho {
192 1.1 jruoho AslError (ASL_REMARK, ASL_MSG_RECURSION, Op, Op->Asl.ExternalName);
193 1.1 jruoho }
194 1.1 jruoho break;
195 1.1 jruoho
196 1.1 jruoho
197 1.1 jruoho case PARSEOP_LOCAL0:
198 1.1 jruoho case PARSEOP_LOCAL1:
199 1.1 jruoho case PARSEOP_LOCAL2:
200 1.1 jruoho case PARSEOP_LOCAL3:
201 1.1 jruoho case PARSEOP_LOCAL4:
202 1.1 jruoho case PARSEOP_LOCAL5:
203 1.1 jruoho case PARSEOP_LOCAL6:
204 1.1 jruoho case PARSEOP_LOCAL7:
205 1.1 jruoho
206 1.1 jruoho if (!MethodInfo)
207 1.1 jruoho {
208 1.1 jruoho /*
209 1.1 jruoho * Local was used outside a control method, or there was an error
210 1.1 jruoho * in the method declaration.
211 1.1 jruoho */
212 1.1 jruoho AslError (ASL_REMARK, ASL_MSG_LOCAL_OUTSIDE_METHOD, Op, Op->Asl.ExternalName);
213 1.1 jruoho return (AE_ERROR);
214 1.1 jruoho }
215 1.1 jruoho
216 1.1 jruoho RegisterNumber = (Op->Asl.AmlOpcode & 0x000F);
217 1.1 jruoho
218 1.1 jruoho /*
219 1.1 jruoho * If the local is being used as a target, mark the local
220 1.1 jruoho * initialized
221 1.1 jruoho */
222 1.1 jruoho if (Op->Asl.CompileFlags & NODE_IS_TARGET)
223 1.1 jruoho {
224 1.1 jruoho MethodInfo->LocalInitialized[RegisterNumber] = TRUE;
225 1.1 jruoho }
226 1.1 jruoho
227 1.1 jruoho /*
228 1.1 jruoho * Otherwise, this is a reference, check if the local
229 1.1 jruoho * has been previously initialized.
230 1.1 jruoho *
231 1.1 jruoho * The only operator that accepts an uninitialized value is ObjectType()
232 1.1 jruoho */
233 1.1 jruoho else if ((!MethodInfo->LocalInitialized[RegisterNumber]) &&
234 1.1 jruoho (Op->Asl.Parent->Asl.ParseOpcode != PARSEOP_OBJECTTYPE))
235 1.1 jruoho {
236 1.1 jruoho LocalName[strlen (LocalName) -1] = (char) (RegisterNumber + 0x30);
237 1.1 jruoho AslError (ASL_ERROR, ASL_MSG_LOCAL_INIT, Op, LocalName);
238 1.1 jruoho }
239 1.1 jruoho break;
240 1.1 jruoho
241 1.1 jruoho
242 1.1 jruoho case PARSEOP_ARG0:
243 1.1 jruoho case PARSEOP_ARG1:
244 1.1 jruoho case PARSEOP_ARG2:
245 1.1 jruoho case PARSEOP_ARG3:
246 1.1 jruoho case PARSEOP_ARG4:
247 1.1 jruoho case PARSEOP_ARG5:
248 1.1 jruoho case PARSEOP_ARG6:
249 1.1 jruoho
250 1.1 jruoho if (!MethodInfo)
251 1.1 jruoho {
252 1.1 jruoho /*
253 1.1 jruoho * Arg was used outside a control method, or there was an error
254 1.1 jruoho * in the method declaration.
255 1.1 jruoho */
256 1.1 jruoho AslError (ASL_REMARK, ASL_MSG_LOCAL_OUTSIDE_METHOD, Op, Op->Asl.ExternalName);
257 1.1 jruoho return (AE_ERROR);
258 1.1 jruoho }
259 1.1 jruoho
260 1.1 jruoho RegisterNumber = (Op->Asl.AmlOpcode & 0x000F) - 8;
261 1.1 jruoho ArgName[strlen (ArgName) -1] = (char) (RegisterNumber + 0x30);
262 1.1 jruoho
263 1.1 jruoho /*
264 1.1 jruoho * If the Arg is being used as a target, mark the local
265 1.1 jruoho * initialized
266 1.1 jruoho */
267 1.1 jruoho if (Op->Asl.CompileFlags & NODE_IS_TARGET)
268 1.1 jruoho {
269 1.1 jruoho MethodInfo->ArgInitialized[RegisterNumber] = TRUE;
270 1.1 jruoho }
271 1.1 jruoho
272 1.1 jruoho /*
273 1.1 jruoho * Otherwise, this is a reference, check if the Arg
274 1.1 jruoho * has been previously initialized.
275 1.1 jruoho *
276 1.1 jruoho * The only operator that accepts an uninitialized value is ObjectType()
277 1.1 jruoho */
278 1.1 jruoho else if ((!MethodInfo->ArgInitialized[RegisterNumber]) &&
279 1.1 jruoho (Op->Asl.Parent->Asl.ParseOpcode != PARSEOP_OBJECTTYPE))
280 1.1 jruoho {
281 1.1 jruoho AslError (ASL_ERROR, ASL_MSG_ARG_INIT, Op, ArgName);
282 1.1 jruoho }
283 1.1 jruoho
284 1.1 jruoho /* Flag this arg if it is not a "real" argument to the method */
285 1.1 jruoho
286 1.1 jruoho if (RegisterNumber >= MethodInfo->NumArguments)
287 1.1 jruoho {
288 1.1 jruoho AslError (ASL_REMARK, ASL_MSG_NOT_PARAMETER, Op, ArgName);
289 1.1 jruoho }
290 1.1 jruoho break;
291 1.1 jruoho
292 1.1 jruoho
293 1.1 jruoho case PARSEOP_RETURN:
294 1.1 jruoho
295 1.1 jruoho if (!MethodInfo)
296 1.1 jruoho {
297 1.1 jruoho /*
298 1.1 jruoho * Probably was an error in the method declaration,
299 1.1 jruoho * no additional error here
300 1.1 jruoho */
301 1.1 jruoho ACPI_WARNING ((AE_INFO, "%p, No parent method", Op));
302 1.1 jruoho return (AE_ERROR);
303 1.1 jruoho }
304 1.1 jruoho
305 1.1 jruoho /* Child indicates a return value */
306 1.1 jruoho
307 1.1 jruoho if ((Op->Asl.Child) &&
308 1.1 jruoho (Op->Asl.Child->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG))
309 1.1 jruoho {
310 1.1 jruoho MethodInfo->NumReturnWithValue++;
311 1.1 jruoho }
312 1.1 jruoho else
313 1.1 jruoho {
314 1.1 jruoho MethodInfo->NumReturnNoValue++;
315 1.1 jruoho }
316 1.1 jruoho break;
317 1.1 jruoho
318 1.1 jruoho
319 1.1 jruoho case PARSEOP_BREAK:
320 1.1 jruoho case PARSEOP_CONTINUE:
321 1.1 jruoho
322 1.1 jruoho Next = Op->Asl.Parent;
323 1.1 jruoho while (Next)
324 1.1 jruoho {
325 1.1 jruoho if (Next->Asl.ParseOpcode == PARSEOP_WHILE)
326 1.1 jruoho {
327 1.1 jruoho break;
328 1.1 jruoho }
329 1.1 jruoho Next = Next->Asl.Parent;
330 1.1 jruoho }
331 1.1 jruoho
332 1.1 jruoho if (!Next)
333 1.1 jruoho {
334 1.1 jruoho AslError (ASL_ERROR, ASL_MSG_NO_WHILE, Op, NULL);
335 1.1 jruoho }
336 1.1 jruoho break;
337 1.1 jruoho
338 1.1 jruoho
339 1.1 jruoho case PARSEOP_STALL:
340 1.1 jruoho
341 1.1 jruoho /* We can range check if the argument is an integer */
342 1.1 jruoho
343 1.1 jruoho if ((Op->Asl.Child->Asl.ParseOpcode == PARSEOP_INTEGER) &&
344 1.1 jruoho (Op->Asl.Child->Asl.Value.Integer > ACPI_UINT8_MAX))
345 1.1 jruoho {
346 1.1 jruoho AslError (ASL_ERROR, ASL_MSG_INVALID_TIME, Op, NULL);
347 1.1 jruoho }
348 1.1 jruoho break;
349 1.1 jruoho
350 1.1 jruoho
351 1.1 jruoho case PARSEOP_DEVICE:
352 1.1 jruoho case PARSEOP_EVENT:
353 1.1 jruoho case PARSEOP_MUTEX:
354 1.1 jruoho case PARSEOP_OPERATIONREGION:
355 1.1 jruoho case PARSEOP_POWERRESOURCE:
356 1.1 jruoho case PARSEOP_PROCESSOR:
357 1.1 jruoho case PARSEOP_THERMALZONE:
358 1.1 jruoho
359 1.1 jruoho /*
360 1.1 jruoho * The first operand is a name to be created in the namespace.
361 1.1 jruoho * Check against the reserved list.
362 1.1 jruoho */
363 1.1 jruoho i = ApCheckForPredefinedName (Op, Op->Asl.NameSeg);
364 1.1 jruoho if (i < ACPI_VALID_RESERVED_NAME_MAX)
365 1.1 jruoho {
366 1.1 jruoho AslError (ASL_ERROR, ASL_MSG_RESERVED_USE, Op, Op->Asl.ExternalName);
367 1.1 jruoho }
368 1.1 jruoho break;
369 1.1 jruoho
370 1.1 jruoho
371 1.1 jruoho case PARSEOP_NAME:
372 1.1 jruoho
373 1.1 jruoho /* Typecheck any predefined names statically defined with Name() */
374 1.1 jruoho
375 1.1 jruoho ApCheckForPredefinedObject (Op, Op->Asl.NameSeg);
376 1.1 jruoho
377 1.1 jruoho /* Special typechecking for _HID */
378 1.1 jruoho
379 1.1 jruoho if (!ACPI_STRCMP (METHOD_NAME__HID, Op->Asl.NameSeg))
380 1.1 jruoho {
381 1.1 jruoho Next = Op->Asl.Child->Asl.Next;
382 1.1 jruoho AnCheckId (Next, ASL_TYPE_HID);
383 1.1 jruoho }
384 1.1 jruoho
385 1.1 jruoho /* Special typechecking for _CID */
386 1.1 jruoho
387 1.1 jruoho else if (!ACPI_STRCMP (METHOD_NAME__CID, Op->Asl.NameSeg))
388 1.1 jruoho {
389 1.1 jruoho Next = Op->Asl.Child->Asl.Next;
390 1.1 jruoho
391 1.1 jruoho if ((Next->Asl.ParseOpcode == PARSEOP_PACKAGE) ||
392 1.1 jruoho (Next->Asl.ParseOpcode == PARSEOP_VAR_PACKAGE))
393 1.1 jruoho {
394 1.1 jruoho Next = Next->Asl.Child;
395 1.1 jruoho while (Next)
396 1.1 jruoho {
397 1.1 jruoho AnCheckId (Next, ASL_TYPE_CID);
398 1.1 jruoho Next = Next->Asl.Next;
399 1.1 jruoho }
400 1.1 jruoho }
401 1.1 jruoho else
402 1.1 jruoho {
403 1.1 jruoho AnCheckId (Next, ASL_TYPE_CID);
404 1.1 jruoho }
405 1.1 jruoho }
406 1.1 jruoho break;
407 1.1 jruoho
408 1.1 jruoho
409 1.1 jruoho default:
410 1.1 jruoho break;
411 1.1 jruoho }
412 1.1 jruoho
413 1.1 jruoho return (AE_OK);
414 1.1 jruoho }
415 1.1 jruoho
416 1.1 jruoho
417 1.1 jruoho /*******************************************************************************
418 1.1 jruoho *
419 1.1 jruoho * FUNCTION: AnMethodAnalysisWalkEnd
420 1.1 jruoho *
421 1.1 jruoho * PARAMETERS: ASL_WALK_CALLBACK
422 1.1 jruoho *
423 1.1 jruoho * RETURN: Status
424 1.1 jruoho *
425 1.1 jruoho * DESCRIPTION: Ascending callback for analysis walk. Complete method
426 1.1 jruoho * return analysis.
427 1.1 jruoho *
428 1.1 jruoho ******************************************************************************/
429 1.1 jruoho
430 1.1 jruoho ACPI_STATUS
431 1.1 jruoho AnMethodAnalysisWalkEnd (
432 1.1 jruoho ACPI_PARSE_OBJECT *Op,
433 1.1 jruoho UINT32 Level,
434 1.1 jruoho void *Context)
435 1.1 jruoho {
436 1.1 jruoho ASL_ANALYSIS_WALK_INFO *WalkInfo = (ASL_ANALYSIS_WALK_INFO *) Context;
437 1.1 jruoho ASL_METHOD_INFO *MethodInfo = WalkInfo->MethodStack;
438 1.1 jruoho
439 1.1 jruoho
440 1.1 jruoho switch (Op->Asl.ParseOpcode)
441 1.1 jruoho {
442 1.1 jruoho case PARSEOP_METHOD:
443 1.1 jruoho case PARSEOP_RETURN:
444 1.1 jruoho if (!MethodInfo)
445 1.1 jruoho {
446 1.1 jruoho printf ("No method info for method! [%s]\n", Op->Asl.Namepath);
447 1.1 jruoho AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
448 1.1 jruoho "No method info for this method");
449 1.1 jruoho
450 1.1 jruoho CmCleanupAndExit ();
451 1.1 jruoho return (AE_AML_INTERNAL);
452 1.1 jruoho }
453 1.1 jruoho break;
454 1.1 jruoho
455 1.1 jruoho default:
456 1.1 jruoho break;
457 1.1 jruoho }
458 1.1 jruoho
459 1.1 jruoho switch (Op->Asl.ParseOpcode)
460 1.1 jruoho {
461 1.1 jruoho case PARSEOP_METHOD:
462 1.1 jruoho
463 1.1 jruoho WalkInfo->MethodStack = MethodInfo->Next;
464 1.1 jruoho
465 1.1 jruoho /*
466 1.1 jruoho * Check if there is no return statement at the end of the
467 1.1 jruoho * method AND we can actually get there -- i.e., the execution
468 1.1 jruoho * of the method can possibly terminate without a return statement.
469 1.1 jruoho */
470 1.1 jruoho if ((!AnLastStatementIsReturn (Op)) &&
471 1.1 jruoho (!(Op->Asl.CompileFlags & NODE_HAS_NO_EXIT)))
472 1.1 jruoho {
473 1.1 jruoho /*
474 1.1 jruoho * No return statement, and execution can possibly exit
475 1.1 jruoho * via this path. This is equivalent to Return ()
476 1.1 jruoho */
477 1.1 jruoho MethodInfo->NumReturnNoValue++;
478 1.1 jruoho }
479 1.1 jruoho
480 1.1 jruoho /*
481 1.1 jruoho * Check for case where some return statements have a return value
482 1.1 jruoho * and some do not. Exit without a return statement is a return with
483 1.1 jruoho * no value
484 1.1 jruoho */
485 1.1 jruoho if (MethodInfo->NumReturnNoValue &&
486 1.1 jruoho MethodInfo->NumReturnWithValue)
487 1.1 jruoho {
488 1.1 jruoho AslError (ASL_WARNING, ASL_MSG_RETURN_TYPES, Op,
489 1.1 jruoho Op->Asl.ExternalName);
490 1.1 jruoho }
491 1.1 jruoho
492 1.1 jruoho /*
493 1.1 jruoho * If there are any RETURN() statements with no value, or there is a
494 1.1 jruoho * control path that allows the method to exit without a return value,
495 1.1 jruoho * we mark the method as a method that does not return a value. This
496 1.1 jruoho * knowledge can be used to check method invocations that expect a
497 1.1 jruoho * returned value.
498 1.1 jruoho */
499 1.1 jruoho if (MethodInfo->NumReturnNoValue)
500 1.1 jruoho {
501 1.1 jruoho if (MethodInfo->NumReturnWithValue)
502 1.1 jruoho {
503 1.1 jruoho Op->Asl.CompileFlags |= NODE_METHOD_SOME_NO_RETVAL;
504 1.1 jruoho }
505 1.1 jruoho else
506 1.1 jruoho {
507 1.1 jruoho Op->Asl.CompileFlags |= NODE_METHOD_NO_RETVAL;
508 1.1 jruoho }
509 1.1 jruoho }
510 1.1 jruoho
511 1.1 jruoho /*
512 1.1 jruoho * Check predefined method names for correct return behavior
513 1.1 jruoho * and correct number of arguments
514 1.1 jruoho */
515 1.1 jruoho ApCheckForPredefinedMethod (Op, MethodInfo);
516 1.1 jruoho
517 1.1 jruoho /* Special check for two names like _L01 and _E01 in same scope */
518 1.1 jruoho
519 1.1 jruoho ApCheckForGpeNameConflict (Op);
520 1.1 jruoho ACPI_FREE (MethodInfo);
521 1.1 jruoho break;
522 1.1 jruoho
523 1.1 jruoho
524 1.1 jruoho case PARSEOP_NAME:
525 1.1 jruoho
526 1.1 jruoho /* Special check for two names like _L01 and _E01 in same scope */
527 1.1 jruoho
528 1.1 jruoho ApCheckForGpeNameConflict (Op);
529 1.1 jruoho break;
530 1.1 jruoho
531 1.1 jruoho
532 1.1 jruoho case PARSEOP_RETURN:
533 1.1 jruoho
534 1.1 jruoho /*
535 1.1 jruoho * If the parent is a predefined method name, attempt to typecheck
536 1.1 jruoho * the return value. Only static types can be validated.
537 1.1 jruoho */
538 1.1 jruoho ApCheckPredefinedReturnValue (Op, MethodInfo);
539 1.1 jruoho
540 1.1 jruoho /*
541 1.1 jruoho * The parent block does not "exit" and continue execution -- the
542 1.1 jruoho * method is terminated here with the Return() statement.
543 1.1 jruoho */
544 1.1 jruoho Op->Asl.Parent->Asl.CompileFlags |= NODE_HAS_NO_EXIT;
545 1.1 jruoho
546 1.1 jruoho /* Used in the "typing" pass later */
547 1.1 jruoho
548 1.1 jruoho Op->Asl.ParentMethod = MethodInfo->Op;
549 1.1 jruoho
550 1.1 jruoho /*
551 1.1 jruoho * If there is a peer node after the return statement, then this
552 1.1 jruoho * node is unreachable code -- i.e., it won't be executed because of
553 1.1 jruoho * the preceeding Return() statement.
554 1.1 jruoho */
555 1.1 jruoho if (Op->Asl.Next)
556 1.1 jruoho {
557 1.1 jruoho AslError (ASL_WARNING, ASL_MSG_UNREACHABLE_CODE, Op->Asl.Next, NULL);
558 1.1 jruoho }
559 1.1 jruoho break;
560 1.1 jruoho
561 1.1 jruoho
562 1.1 jruoho case PARSEOP_IF:
563 1.1 jruoho
564 1.1 jruoho if ((Op->Asl.CompileFlags & NODE_HAS_NO_EXIT) &&
565 1.1 jruoho (Op->Asl.Next) &&
566 1.1 jruoho (Op->Asl.Next->Asl.ParseOpcode == PARSEOP_ELSE))
567 1.1 jruoho {
568 1.1 jruoho /*
569 1.1 jruoho * This IF has a corresponding ELSE. The IF block has no exit,
570 1.1 jruoho * (it contains an unconditional Return)
571 1.1 jruoho * mark the ELSE block to remember this fact.
572 1.1 jruoho */
573 1.1 jruoho Op->Asl.Next->Asl.CompileFlags |= NODE_IF_HAS_NO_EXIT;
574 1.1 jruoho }
575 1.1 jruoho break;
576 1.1 jruoho
577 1.1 jruoho
578 1.1 jruoho case PARSEOP_ELSE:
579 1.1 jruoho
580 1.1 jruoho if ((Op->Asl.CompileFlags & NODE_HAS_NO_EXIT) &&
581 1.1 jruoho (Op->Asl.CompileFlags & NODE_IF_HAS_NO_EXIT))
582 1.1 jruoho {
583 1.1 jruoho /*
584 1.1 jruoho * This ELSE block has no exit and the corresponding IF block
585 1.1 jruoho * has no exit either. Therefore, the parent node has no exit.
586 1.1 jruoho */
587 1.1 jruoho Op->Asl.Parent->Asl.CompileFlags |= NODE_HAS_NO_EXIT;
588 1.1 jruoho }
589 1.1 jruoho break;
590 1.1 jruoho
591 1.1 jruoho
592 1.1 jruoho default:
593 1.1 jruoho
594 1.1 jruoho if ((Op->Asl.CompileFlags & NODE_HAS_NO_EXIT) &&
595 1.1 jruoho (Op->Asl.Parent))
596 1.1 jruoho {
597 1.1 jruoho /* If this node has no exit, then the parent has no exit either */
598 1.1 jruoho
599 1.1 jruoho Op->Asl.Parent->Asl.CompileFlags |= NODE_HAS_NO_EXIT;
600 1.1 jruoho }
601 1.1 jruoho break;
602 1.1 jruoho }
603 1.1 jruoho
604 1.1 jruoho return (AE_OK);
605 1.1 jruoho }
606 1.1 jruoho
607 1.1 jruoho
608 1.1 jruoho /*******************************************************************************
609 1.1 jruoho *
610 1.1 jruoho * FUNCTION: AnMethodTypingWalkEnd
611 1.1 jruoho *
612 1.1 jruoho * PARAMETERS: ASL_WALK_CALLBACK
613 1.1 jruoho *
614 1.1 jruoho * RETURN: Status
615 1.1 jruoho *
616 1.1 jruoho * DESCRIPTION: Ascending callback for typing walk. Complete the method
617 1.1 jruoho * return analysis. Check methods for:
618 1.1 jruoho * 1) Initialized local variables
619 1.1 jruoho * 2) Valid arguments
620 1.1 jruoho * 3) Return types
621 1.1 jruoho *
622 1.1 jruoho ******************************************************************************/
623 1.1 jruoho
624 1.1 jruoho ACPI_STATUS
625 1.1 jruoho AnMethodTypingWalkEnd (
626 1.1 jruoho ACPI_PARSE_OBJECT *Op,
627 1.1 jruoho UINT32 Level,
628 1.1 jruoho void *Context)
629 1.1 jruoho {
630 1.1 jruoho UINT32 ThisNodeBtype;
631 1.1 jruoho
632 1.1 jruoho
633 1.1 jruoho switch (Op->Asl.ParseOpcode)
634 1.1 jruoho {
635 1.1 jruoho case PARSEOP_METHOD:
636 1.1 jruoho
637 1.1 jruoho Op->Asl.CompileFlags |= NODE_METHOD_TYPED;
638 1.1 jruoho break;
639 1.1 jruoho
640 1.1 jruoho case PARSEOP_RETURN:
641 1.1 jruoho
642 1.1 jruoho if ((Op->Asl.Child) &&
643 1.1 jruoho (Op->Asl.Child->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG))
644 1.1 jruoho {
645 1.1 jruoho ThisNodeBtype = AnGetBtype (Op->Asl.Child);
646 1.1 jruoho
647 1.1 jruoho if ((Op->Asl.Child->Asl.ParseOpcode == PARSEOP_METHODCALL) &&
648 1.1 jruoho (ThisNodeBtype == (ACPI_UINT32_MAX -1)))
649 1.1 jruoho {
650 1.1 jruoho /*
651 1.1 jruoho * The called method is untyped at this time (typically a
652 1.1 jruoho * forward reference).
653 1.1 jruoho *
654 1.1 jruoho * Check for a recursive method call first.
655 1.1 jruoho */
656 1.1 jruoho if (Op->Asl.ParentMethod != Op->Asl.Child->Asl.Node->Op)
657 1.1 jruoho {
658 1.1 jruoho /* We must type the method here */
659 1.1 jruoho
660 1.1 jruoho TrWalkParseTree (Op->Asl.Child->Asl.Node->Op,
661 1.1 jruoho ASL_WALK_VISIT_UPWARD, NULL,
662 1.1 jruoho AnMethodTypingWalkEnd, NULL);
663 1.1 jruoho
664 1.1 jruoho ThisNodeBtype = AnGetBtype (Op->Asl.Child);
665 1.1 jruoho }
666 1.1 jruoho }
667 1.1 jruoho
668 1.1 jruoho /* Returns a value, save the value type */
669 1.1 jruoho
670 1.1 jruoho if (Op->Asl.ParentMethod)
671 1.1 jruoho {
672 1.1 jruoho Op->Asl.ParentMethod->Asl.AcpiBtype |= ThisNodeBtype;
673 1.1 jruoho }
674 1.1 jruoho }
675 1.1 jruoho break;
676 1.1 jruoho
677 1.1 jruoho default:
678 1.1 jruoho break;
679 1.1 jruoho }
680 1.1 jruoho
681 1.1 jruoho return (AE_OK);
682 1.1 jruoho }
683 1.1 jruoho
684 1.1 jruoho
685 1.1 jruoho /*******************************************************************************
686 1.1 jruoho *
687 1.1 jruoho * FUNCTION: AnOperandTypecheckWalkEnd
688 1.1 jruoho *
689 1.1 jruoho * PARAMETERS: ASL_WALK_CALLBACK
690 1.1 jruoho *
691 1.1 jruoho * RETURN: Status
692 1.1 jruoho *
693 1.1 jruoho * DESCRIPTION: Ascending callback for analysis walk. Complete method
694 1.1 jruoho * return analysis.
695 1.1 jruoho *
696 1.1 jruoho ******************************************************************************/
697 1.1 jruoho
698 1.1 jruoho ACPI_STATUS
699 1.1 jruoho AnOperandTypecheckWalkEnd (
700 1.1 jruoho ACPI_PARSE_OBJECT *Op,
701 1.1 jruoho UINT32 Level,
702 1.1 jruoho void *Context)
703 1.1 jruoho {
704 1.1 jruoho const ACPI_OPCODE_INFO *OpInfo;
705 1.1 jruoho UINT32 RuntimeArgTypes;
706 1.1 jruoho UINT32 RuntimeArgTypes2;
707 1.1 jruoho UINT32 RequiredBtypes;
708 1.1 jruoho UINT32 ThisNodeBtype;
709 1.1 jruoho UINT32 CommonBtypes;
710 1.1 jruoho UINT32 OpcodeClass;
711 1.1 jruoho ACPI_PARSE_OBJECT *ArgOp;
712 1.1 jruoho UINT32 ArgType;
713 1.1 jruoho
714 1.1 jruoho
715 1.1 jruoho switch (Op->Asl.AmlOpcode)
716 1.1 jruoho {
717 1.1 jruoho case AML_RAW_DATA_BYTE:
718 1.1 jruoho case AML_RAW_DATA_WORD:
719 1.1 jruoho case AML_RAW_DATA_DWORD:
720 1.1 jruoho case AML_RAW_DATA_QWORD:
721 1.1 jruoho case AML_RAW_DATA_BUFFER:
722 1.1 jruoho case AML_RAW_DATA_CHAIN:
723 1.1 jruoho case AML_PACKAGE_LENGTH:
724 1.1 jruoho case AML_UNASSIGNED_OPCODE:
725 1.1 jruoho case AML_DEFAULT_ARG_OP:
726 1.1 jruoho
727 1.1 jruoho /* Ignore the internal (compiler-only) AML opcodes */
728 1.1 jruoho
729 1.1 jruoho return (AE_OK);
730 1.1 jruoho
731 1.1 jruoho default:
732 1.1 jruoho break;
733 1.1 jruoho }
734 1.1 jruoho
735 1.1 jruoho OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
736 1.1 jruoho if (!OpInfo)
737 1.1 jruoho {
738 1.1 jruoho return (AE_OK);
739 1.1 jruoho }
740 1.1 jruoho
741 1.1 jruoho ArgOp = Op->Asl.Child;
742 1.1 jruoho RuntimeArgTypes = OpInfo->RuntimeArgs;
743 1.1 jruoho OpcodeClass = OpInfo->Class;
744 1.1 jruoho
745 1.1 jruoho #ifdef ASL_ERROR_NAMED_OBJECT_IN_WHILE
746 1.1 jruoho /*
747 1.1 jruoho * Update 11/2008: In practice, we can't perform this check. A simple
748 1.1 jruoho * analysis is not sufficient. Also, it can cause errors when compiling
749 1.1 jruoho * disassembled code because of the way Switch operators are implemented
750 1.1 jruoho * (a While(One) loop with a named temp variable created within.)
751 1.1 jruoho */
752 1.1 jruoho
753 1.1 jruoho /*
754 1.1 jruoho * If we are creating a named object, check if we are within a while loop
755 1.1 jruoho * by checking if the parent is a WHILE op. This is a simple analysis, but
756 1.1 jruoho * probably sufficient for many cases.
757 1.1 jruoho *
758 1.1 jruoho * Allow Scope(), Buffer(), and Package().
759 1.1 jruoho */
760 1.1 jruoho if (((OpcodeClass == AML_CLASS_NAMED_OBJECT) && (Op->Asl.AmlOpcode != AML_SCOPE_OP)) ||
761 1.1 jruoho ((OpcodeClass == AML_CLASS_CREATE) && (OpInfo->Flags & AML_NSNODE)))
762 1.1 jruoho {
763 1.1 jruoho if (Op->Asl.Parent->Asl.AmlOpcode == AML_WHILE_OP)
764 1.1 jruoho {
765 1.1 jruoho AslError (ASL_ERROR, ASL_MSG_NAMED_OBJECT_IN_WHILE, Op, NULL);
766 1.1 jruoho }
767 1.1 jruoho }
768 1.1 jruoho #endif
769 1.1 jruoho
770 1.1 jruoho /*
771 1.1 jruoho * Special case for control opcodes IF/RETURN/WHILE since they
772 1.1 jruoho * have no runtime arg list (at this time)
773 1.1 jruoho */
774 1.1 jruoho switch (Op->Asl.AmlOpcode)
775 1.1 jruoho {
776 1.1 jruoho case AML_IF_OP:
777 1.1 jruoho case AML_WHILE_OP:
778 1.1 jruoho case AML_RETURN_OP:
779 1.1 jruoho
780 1.1 jruoho if (ArgOp->Asl.ParseOpcode == PARSEOP_METHODCALL)
781 1.1 jruoho {
782 1.1 jruoho /* Check for an internal method */
783 1.1 jruoho
784 1.1 jruoho if (AnIsInternalMethod (ArgOp))
785 1.1 jruoho {
786 1.1 jruoho return (AE_OK);
787 1.1 jruoho }
788 1.1 jruoho
789 1.1 jruoho /* The lone arg is a method call, check it */
790 1.1 jruoho
791 1.1 jruoho RequiredBtypes = AnMapArgTypeToBtype (ARGI_INTEGER);
792 1.1 jruoho if (Op->Asl.AmlOpcode == AML_RETURN_OP)
793 1.1 jruoho {
794 1.1 jruoho RequiredBtypes = 0xFFFFFFFF;
795 1.1 jruoho }
796 1.1 jruoho
797 1.1 jruoho ThisNodeBtype = AnGetBtype (ArgOp);
798 1.1 jruoho if (ThisNodeBtype == ACPI_UINT32_MAX)
799 1.1 jruoho {
800 1.1 jruoho return (AE_OK);
801 1.1 jruoho }
802 1.1 jruoho AnCheckMethodReturnValue (Op, OpInfo, ArgOp,
803 1.1 jruoho RequiredBtypes, ThisNodeBtype);
804 1.1 jruoho }
805 1.1 jruoho return (AE_OK);
806 1.1 jruoho
807 1.1 jruoho default:
808 1.1 jruoho break;
809 1.1 jruoho }
810 1.1 jruoho
811 1.1 jruoho /* Ignore the non-executable opcodes */
812 1.1 jruoho
813 1.1 jruoho if (RuntimeArgTypes == ARGI_INVALID_OPCODE)
814 1.1 jruoho {
815 1.1 jruoho return (AE_OK);
816 1.1 jruoho }
817 1.1 jruoho
818 1.1 jruoho switch (OpcodeClass)
819 1.1 jruoho {
820 1.1 jruoho case AML_CLASS_EXECUTE:
821 1.1 jruoho case AML_CLASS_CREATE:
822 1.1 jruoho case AML_CLASS_CONTROL:
823 1.1 jruoho case AML_CLASS_RETURN_VALUE:
824 1.1 jruoho
825 1.1 jruoho /* TBD: Change class or fix typechecking for these */
826 1.1 jruoho
827 1.1 jruoho if ((Op->Asl.AmlOpcode == AML_BUFFER_OP) ||
828 1.1 jruoho (Op->Asl.AmlOpcode == AML_PACKAGE_OP) ||
829 1.1 jruoho (Op->Asl.AmlOpcode == AML_VAR_PACKAGE_OP))
830 1.1 jruoho {
831 1.1 jruoho break;
832 1.1 jruoho }
833 1.1 jruoho
834 1.1 jruoho /* Reverse the runtime argument list */
835 1.1 jruoho
836 1.1 jruoho RuntimeArgTypes2 = 0;
837 1.1 jruoho while ((ArgType = GET_CURRENT_ARG_TYPE (RuntimeArgTypes)))
838 1.1 jruoho {
839 1.1 jruoho RuntimeArgTypes2 <<= ARG_TYPE_WIDTH;
840 1.1 jruoho RuntimeArgTypes2 |= ArgType;
841 1.1 jruoho INCREMENT_ARG_LIST (RuntimeArgTypes);
842 1.1 jruoho }
843 1.1 jruoho
844 1.1 jruoho while ((ArgType = GET_CURRENT_ARG_TYPE (RuntimeArgTypes2)))
845 1.1 jruoho {
846 1.1 jruoho RequiredBtypes = AnMapArgTypeToBtype (ArgType);
847 1.1 jruoho
848 1.1 jruoho ThisNodeBtype = AnGetBtype (ArgOp);
849 1.1 jruoho if (ThisNodeBtype == ACPI_UINT32_MAX)
850 1.1 jruoho {
851 1.1 jruoho goto NextArgument;
852 1.1 jruoho }
853 1.1 jruoho
854 1.1 jruoho /* Examine the arg based on the required type of the arg */
855 1.1 jruoho
856 1.1 jruoho switch (ArgType)
857 1.1 jruoho {
858 1.1 jruoho case ARGI_TARGETREF:
859 1.1 jruoho
860 1.1 jruoho if (ArgOp->Asl.ParseOpcode == PARSEOP_ZERO)
861 1.1 jruoho {
862 1.1 jruoho /* ZERO is the placeholder for "don't store result" */
863 1.1 jruoho
864 1.1 jruoho ThisNodeBtype = RequiredBtypes;
865 1.1 jruoho break;
866 1.1 jruoho }
867 1.1 jruoho
868 1.1 jruoho if (ArgOp->Asl.ParseOpcode == PARSEOP_INTEGER)
869 1.1 jruoho {
870 1.1 jruoho /*
871 1.1 jruoho * This is the case where an original reference to a resource
872 1.1 jruoho * descriptor field has been replaced by an (Integer) offset.
873 1.1 jruoho * These named fields are supported at compile-time only;
874 1.1 jruoho * the names are not passed to the interpreter (via the AML).
875 1.1 jruoho */
876 1.1 jruoho if ((ArgOp->Asl.Node->Type == ACPI_TYPE_LOCAL_RESOURCE_FIELD) ||
877 1.1 jruoho (ArgOp->Asl.Node->Type == ACPI_TYPE_LOCAL_RESOURCE))
878 1.1 jruoho {
879 1.1 jruoho AslError (ASL_ERROR, ASL_MSG_RESOURCE_FIELD, ArgOp, NULL);
880 1.1 jruoho }
881 1.1 jruoho else
882 1.1 jruoho {
883 1.1 jruoho AslError (ASL_ERROR, ASL_MSG_INVALID_TYPE, ArgOp, NULL);
884 1.1 jruoho }
885 1.1 jruoho break;
886 1.1 jruoho }
887 1.1 jruoho
888 1.1 jruoho if ((ArgOp->Asl.ParseOpcode == PARSEOP_METHODCALL) ||
889 1.1 jruoho (ArgOp->Asl.ParseOpcode == PARSEOP_DEREFOF))
890 1.1 jruoho {
891 1.1 jruoho break;
892 1.1 jruoho }
893 1.1 jruoho
894 1.1 jruoho ThisNodeBtype = RequiredBtypes;
895 1.1 jruoho break;
896 1.1 jruoho
897 1.1 jruoho
898 1.1 jruoho case ARGI_REFERENCE: /* References */
899 1.1 jruoho case ARGI_INTEGER_REF:
900 1.1 jruoho case ARGI_OBJECT_REF:
901 1.1 jruoho case ARGI_DEVICE_REF:
902 1.1 jruoho
903 1.1 jruoho switch (ArgOp->Asl.ParseOpcode)
904 1.1 jruoho {
905 1.1 jruoho case PARSEOP_LOCAL0:
906 1.1 jruoho case PARSEOP_LOCAL1:
907 1.1 jruoho case PARSEOP_LOCAL2:
908 1.1 jruoho case PARSEOP_LOCAL3:
909 1.1 jruoho case PARSEOP_LOCAL4:
910 1.1 jruoho case PARSEOP_LOCAL5:
911 1.1 jruoho case PARSEOP_LOCAL6:
912 1.1 jruoho case PARSEOP_LOCAL7:
913 1.1 jruoho
914 1.1 jruoho /* TBD: implement analysis of current value (type) of the local */
915 1.1 jruoho /* For now, just treat any local as a typematch */
916 1.1 jruoho
917 1.1 jruoho /*ThisNodeBtype = RequiredBtypes;*/
918 1.1 jruoho break;
919 1.1 jruoho
920 1.1 jruoho case PARSEOP_ARG0:
921 1.1 jruoho case PARSEOP_ARG1:
922 1.1 jruoho case PARSEOP_ARG2:
923 1.1 jruoho case PARSEOP_ARG3:
924 1.1 jruoho case PARSEOP_ARG4:
925 1.1 jruoho case PARSEOP_ARG5:
926 1.1 jruoho case PARSEOP_ARG6:
927 1.1 jruoho
928 1.1 jruoho /* Hard to analyze argument types, sow we won't */
929 1.1 jruoho /* For now, just treat any arg as a typematch */
930 1.1 jruoho
931 1.1 jruoho /* ThisNodeBtype = RequiredBtypes; */
932 1.1 jruoho break;
933 1.1 jruoho
934 1.1 jruoho case PARSEOP_DEBUG:
935 1.1 jruoho break;
936 1.1 jruoho
937 1.1 jruoho case PARSEOP_REFOF:
938 1.1 jruoho case PARSEOP_INDEX:
939 1.1 jruoho default:
940 1.1 jruoho break;
941 1.1 jruoho
942 1.1 jruoho }
943 1.1 jruoho break;
944 1.1 jruoho
945 1.1 jruoho case ARGI_INTEGER:
946 1.1 jruoho default:
947 1.1 jruoho break;
948 1.1 jruoho }
949 1.1 jruoho
950 1.1 jruoho
951 1.1 jruoho CommonBtypes = ThisNodeBtype & RequiredBtypes;
952 1.1 jruoho
953 1.1 jruoho if (ArgOp->Asl.ParseOpcode == PARSEOP_METHODCALL)
954 1.1 jruoho {
955 1.1 jruoho if (AnIsInternalMethod (ArgOp))
956 1.1 jruoho {
957 1.1 jruoho return (AE_OK);
958 1.1 jruoho }
959 1.1 jruoho
960 1.1 jruoho /* Check a method call for a valid return value */
961 1.1 jruoho
962 1.1 jruoho AnCheckMethodReturnValue (Op, OpInfo, ArgOp,
963 1.1 jruoho RequiredBtypes, ThisNodeBtype);
964 1.1 jruoho }
965 1.1 jruoho
966 1.1 jruoho /*
967 1.1 jruoho * Now check if the actual type(s) match at least one
968 1.1 jruoho * bit to the required type
969 1.1 jruoho */
970 1.1 jruoho else if (!CommonBtypes)
971 1.1 jruoho {
972 1.1 jruoho /* No match -- this is a type mismatch error */
973 1.1 jruoho
974 1.1 jruoho AnFormatBtype (StringBuffer, ThisNodeBtype);
975 1.1 jruoho AnFormatBtype (StringBuffer2, RequiredBtypes);
976 1.1 jruoho
977 1.1 jruoho sprintf (MsgBuffer, "[%s] found, %s operator requires [%s]",
978 1.1 jruoho StringBuffer, OpInfo->Name, StringBuffer2);
979 1.1 jruoho
980 1.1 jruoho AslError (ASL_ERROR, ASL_MSG_INVALID_TYPE, ArgOp, MsgBuffer);
981 1.1 jruoho }
982 1.1 jruoho
983 1.1 jruoho NextArgument:
984 1.1 jruoho ArgOp = ArgOp->Asl.Next;
985 1.1 jruoho INCREMENT_ARG_LIST (RuntimeArgTypes2);
986 1.1 jruoho }
987 1.1 jruoho break;
988 1.1 jruoho
989 1.1 jruoho default:
990 1.1 jruoho break;
991 1.1 jruoho }
992 1.1 jruoho
993 1.1 jruoho return (AE_OK);
994 1.1 jruoho }
995 1.1 jruoho
996 1.1 jruoho
997 1.1 jruoho /*******************************************************************************
998 1.1 jruoho *
999 1.1 jruoho * FUNCTION: AnOtherSemanticAnalysisWalkBegin
1000 1.1 jruoho *
1001 1.1 jruoho * PARAMETERS: ASL_WALK_CALLBACK
1002 1.1 jruoho *
1003 1.1 jruoho * RETURN: Status
1004 1.1 jruoho *
1005 1.1 jruoho * DESCRIPTION: Descending callback for the analysis walk. Checks for
1006 1.1 jruoho * miscellaneous issues in the code.
1007 1.1 jruoho *
1008 1.1 jruoho ******************************************************************************/
1009 1.1 jruoho
1010 1.1 jruoho ACPI_STATUS
1011 1.1 jruoho AnOtherSemanticAnalysisWalkBegin (
1012 1.1 jruoho ACPI_PARSE_OBJECT *Op,
1013 1.1 jruoho UINT32 Level,
1014 1.1 jruoho void *Context)
1015 1.1 jruoho {
1016 1.1 jruoho ACPI_PARSE_OBJECT *ArgNode;
1017 1.1 jruoho ACPI_PARSE_OBJECT *PrevArgNode = NULL;
1018 1.1 jruoho const ACPI_OPCODE_INFO *OpInfo;
1019 1.1 jruoho
1020 1.1 jruoho
1021 1.1 jruoho OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
1022 1.1 jruoho
1023 1.1 jruoho /*
1024 1.1 jruoho * Determine if an execution class operator actually does something by
1025 1.1 jruoho * checking if it has a target and/or the function return value is used.
1026 1.1 jruoho * (Target is optional, so a standalone statement can actually do nothing.)
1027 1.1 jruoho */
1028 1.1 jruoho if ((OpInfo->Class == AML_CLASS_EXECUTE) &&
1029 1.1 jruoho (OpInfo->Flags & AML_HAS_RETVAL) &&
1030 1.1 jruoho (!AnIsResultUsed (Op)))
1031 1.1 jruoho {
1032 1.1 jruoho if (OpInfo->Flags & AML_HAS_TARGET)
1033 1.1 jruoho {
1034 1.1 jruoho /*
1035 1.1 jruoho * Find the target node, it is always the last child. If the traget
1036 1.1 jruoho * is not specified in the ASL, a default node of type Zero was
1037 1.1 jruoho * created by the parser.
1038 1.1 jruoho */
1039 1.1 jruoho ArgNode = Op->Asl.Child;
1040 1.1 jruoho while (ArgNode->Asl.Next)
1041 1.1 jruoho {
1042 1.1 jruoho PrevArgNode = ArgNode;
1043 1.1 jruoho ArgNode = ArgNode->Asl.Next;
1044 1.1 jruoho }
1045 1.1 jruoho
1046 1.1 jruoho /* Divide() is the only weird case, it has two targets */
1047 1.1 jruoho
1048 1.1 jruoho if (Op->Asl.AmlOpcode == AML_DIVIDE_OP)
1049 1.1 jruoho {
1050 1.1 jruoho if ((ArgNode->Asl.ParseOpcode == PARSEOP_ZERO) &&
1051 1.1 jruoho (PrevArgNode) &&
1052 1.1 jruoho (PrevArgNode->Asl.ParseOpcode == PARSEOP_ZERO))
1053 1.1 jruoho {
1054 1.1 jruoho AslError (ASL_WARNING, ASL_MSG_RESULT_NOT_USED,
1055 1.1 jruoho Op, Op->Asl.ExternalName);
1056 1.1 jruoho }
1057 1.1 jruoho }
1058 1.1 jruoho else if (ArgNode->Asl.ParseOpcode == PARSEOP_ZERO)
1059 1.1 jruoho {
1060 1.1 jruoho AslError (ASL_WARNING, ASL_MSG_RESULT_NOT_USED,
1061 1.1 jruoho Op, Op->Asl.ExternalName);
1062 1.1 jruoho }
1063 1.1 jruoho }
1064 1.1 jruoho else
1065 1.1 jruoho {
1066 1.1 jruoho /*
1067 1.1 jruoho * Has no target and the result is not used. Only a couple opcodes
1068 1.1 jruoho * can have this combination.
1069 1.1 jruoho */
1070 1.1 jruoho switch (Op->Asl.ParseOpcode)
1071 1.1 jruoho {
1072 1.1 jruoho case PARSEOP_ACQUIRE:
1073 1.1 jruoho case PARSEOP_WAIT:
1074 1.1 jruoho case PARSEOP_LOADTABLE:
1075 1.1 jruoho break;
1076 1.1 jruoho
1077 1.1 jruoho default:
1078 1.1 jruoho AslError (ASL_WARNING, ASL_MSG_RESULT_NOT_USED,
1079 1.1 jruoho Op, Op->Asl.ExternalName);
1080 1.1 jruoho break;
1081 1.1 jruoho }
1082 1.1 jruoho }
1083 1.1 jruoho }
1084 1.1 jruoho
1085 1.1 jruoho
1086 1.1 jruoho /*
1087 1.1 jruoho * Semantic checks for individual ASL operators
1088 1.1 jruoho */
1089 1.1 jruoho switch (Op->Asl.ParseOpcode)
1090 1.1 jruoho {
1091 1.1 jruoho case PARSEOP_ACQUIRE:
1092 1.1 jruoho case PARSEOP_WAIT:
1093 1.1 jruoho /*
1094 1.1 jruoho * Emit a warning if the timeout parameter for these operators is not
1095 1.1 jruoho * ACPI_WAIT_FOREVER, and the result value from the operator is not
1096 1.1 jruoho * checked, meaning that a timeout could happen, but the code
1097 1.1 jruoho * would not know about it.
1098 1.1 jruoho */
1099 1.1 jruoho
1100 1.1 jruoho /* First child is the namepath, 2nd child is timeout */
1101 1.1 jruoho
1102 1.1 jruoho ArgNode = Op->Asl.Child;
1103 1.1 jruoho ArgNode = ArgNode->Asl.Next;
1104 1.1 jruoho
1105 1.1 jruoho /*
1106 1.1 jruoho * Check for the WAIT_FOREVER case - defined by the ACPI spec to be
1107 1.1 jruoho * 0xFFFF or greater
1108 1.1 jruoho */
1109 1.1 jruoho if (((ArgNode->Asl.ParseOpcode == PARSEOP_WORDCONST) ||
1110 1.1 jruoho (ArgNode->Asl.ParseOpcode == PARSEOP_INTEGER)) &&
1111 1.1 jruoho (ArgNode->Asl.Value.Integer >= (UINT64) ACPI_WAIT_FOREVER))
1112 1.1 jruoho {
1113 1.1 jruoho break;
1114 1.1 jruoho }
1115 1.1 jruoho
1116 1.1 jruoho /*
1117 1.1 jruoho * The operation could timeout. If the return value is not used
1118 1.1 jruoho * (indicates timeout occurred), issue a warning
1119 1.1 jruoho */
1120 1.1 jruoho if (!AnIsResultUsed (Op))
1121 1.1 jruoho {
1122 1.1 jruoho AslError (ASL_WARNING, ASL_MSG_TIMEOUT, ArgNode,
1123 1.1 jruoho Op->Asl.ExternalName);
1124 1.1 jruoho }
1125 1.1 jruoho break;
1126 1.1 jruoho
1127 1.1 jruoho case PARSEOP_CREATEFIELD:
1128 1.1 jruoho /*
1129 1.1 jruoho * Check for a zero Length (NumBits) operand. NumBits is the 3rd operand
1130 1.1 jruoho */
1131 1.1 jruoho ArgNode = Op->Asl.Child;
1132 1.1 jruoho ArgNode = ArgNode->Asl.Next;
1133 1.1 jruoho ArgNode = ArgNode->Asl.Next;
1134 1.1 jruoho
1135 1.1 jruoho if ((ArgNode->Asl.ParseOpcode == PARSEOP_ZERO) ||
1136 1.1 jruoho ((ArgNode->Asl.ParseOpcode == PARSEOP_INTEGER) &&
1137 1.1 jruoho (ArgNode->Asl.Value.Integer == 0)))
1138 1.1 jruoho {
1139 1.1 jruoho AslError (ASL_ERROR, ASL_MSG_NON_ZERO, ArgNode, NULL);
1140 1.1 jruoho }
1141 1.1 jruoho break;
1142 1.1 jruoho
1143 1.1 jruoho default:
1144 1.1 jruoho break;
1145 1.1 jruoho }
1146 1.1 jruoho
1147 1.1 jruoho return (AE_OK);
1148 1.1 jruoho }
1149