aslanalyze.c revision 228110 
1/******************************************************************************
2 *
3 * Module Name: aslanalyze.c - Support functions for parse tree walks
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2011, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions, and the following disclaimer,
16 *    without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 *    substantially similar to the "NO WARRANTY" disclaimer below
19 *    ("Disclaimer") and any redistribution must be conditioned upon
20 *    including a substantially similar Disclaimer requirement for further
21 *    binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 *    of any contributors may be used to endorse or promote products derived
24 *    from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44
45#include <contrib/dev/acpica/compiler/aslcompiler.h>
46#include "aslcompiler.y.h"
47#include <string.h>
48
49
50#define _COMPONENT          ACPI_COMPILER
51        ACPI_MODULE_NAME    ("aslanalyze")
52
53
54/*******************************************************************************
55 *
56 * FUNCTION:    AnIsInternalMethod
57 *
58 * PARAMETERS:  Op                  - Current op
59 *
60 * RETURN:      Boolean
61 *
62 * DESCRIPTION: Check for an internal control method.
63 *
64 ******************************************************************************/
65
66BOOLEAN
67AnIsInternalMethod (
68    ACPI_PARSE_OBJECT       *Op)
69{
70
71    if ((!ACPI_STRCMP (Op->Asl.ExternalName, "\\_OSI")) ||
72        (!ACPI_STRCMP (Op->Asl.ExternalName, "_OSI")))
73    {
74        return (TRUE);
75    }
76
77    return (FALSE);
78}
79
80
81/*******************************************************************************
82 *
83 * FUNCTION:    AnGetInternalMethodReturnType
84 *
85 * PARAMETERS:  Op                  - Current op
86 *
87 * RETURN:      Btype
88 *
89 * DESCRIPTION: Get the return type of an internal method
90 *
91 ******************************************************************************/
92
93UINT32
94AnGetInternalMethodReturnType (
95    ACPI_PARSE_OBJECT       *Op)
96{
97
98    if ((!ACPI_STRCMP (Op->Asl.ExternalName, "\\_OSI")) ||
99        (!ACPI_STRCMP (Op->Asl.ExternalName, "_OSI")))
100    {
101        return (ACPI_BTYPE_STRING);
102    }
103
104    return (0);
105}
106
107
108/*******************************************************************************
109 *
110 * FUNCTION:    AnCheckId
111 *
112 * PARAMETERS:  Op                  - Current parse op
113 *              Type                - HID or CID
114 *
115 * RETURN:      None
116 *
117 * DESCRIPTION: Perform various checks on _HID and _CID strings. Only limited
118 *              checks can be performed on _CID strings.
119 *
120 ******************************************************************************/
121
122void
123AnCheckId (
124    ACPI_PARSE_OBJECT       *Op,
125    ACPI_NAME               Type)
126{
127    UINT32                  i;
128    ACPI_SIZE               Length;
129
130
131    /* Only care about string versions of _HID/_CID (integers are legal) */
132
133    if (Op->Asl.ParseOpcode != PARSEOP_STRING_LITERAL)
134    {
135        return;
136    }
137
138    /* For both _HID and _CID, the string must be non-null */
139
140    Length = strlen (Op->Asl.Value.String);
141    if (!Length)
142    {
143        AslError (ASL_ERROR, ASL_MSG_NULL_STRING,
144            Op, NULL);
145        return;
146    }
147
148    /*
149     * One of the things we want to catch here is the use of a leading
150     * asterisk in the string -- an odd construct that certain platform
151     * manufacturers are fond of. Technically, a leading asterisk is OK
152     * for _CID, but a valid use of this has not been seen.
153     */
154    if (*Op->Asl.Value.String == '*')
155    {
156        AslError (ASL_ERROR, ASL_MSG_LEADING_ASTERISK,
157            Op, Op->Asl.Value.String);
158        return;
159    }
160
161    /* _CID strings are bus-specific, no more checks can be performed */
162
163    if (Type == ASL_TYPE_CID)
164    {
165        return;
166    }
167
168    /* For _HID, all characters must be alphanumeric */
169
170    for (i = 0; Op->Asl.Value.String[i]; i++)
171    {
172        if (!isalnum ((int) Op->Asl.Value.String[i]))
173        {
174            AslError (ASL_ERROR, ASL_MSG_ALPHANUMERIC_STRING,
175                Op, Op->Asl.Value.String);
176            return;
177        }
178    }
179
180    /*
181     * _HID String must be one of these forms:
182     *
183     * "AAA####"    A is an uppercase letter and # is a hex digit
184     * "ACPI####"   # is a hex digit
185     * "NNNN####"   N is an uppercase letter or decimal digit (0-9)
186     *              # is a hex digit (ACPI 5.0)
187     */
188    if ((Length < 7) || (Length > 8))
189    {
190        AslError (ASL_ERROR, ASL_MSG_HID_LENGTH,
191            Op, Op->Asl.Value.String);
192        return;
193    }
194
195    /* _HID Length is valid (7 or 8), now check the prefix (first 3 or 4 chars) */
196
197    if (Length == 7)
198    {
199        /* AAA####: Ensure the alphabetic prefix is all uppercase */
200
201        for (i = 0; i < 3; i++)
202        {
203            if (!isupper ((int) Op->Asl.Value.String[i]))
204            {
205                AslError (ASL_ERROR, ASL_MSG_UPPER_CASE,
206                    Op, &Op->Asl.Value.String[i]);
207                return;
208            }
209        }
210    }
211    else /* Length == 8 */
212    {
213        /*
214         * ACPI#### or NNNN####:
215         * Ensure the prefix contains only uppercase alpha or decimal digits
216         */
217        for (i = 0; i < 4; i++)
218        {
219            if (!isupper ((int) Op->Asl.Value.String[i]) &&
220                !isdigit ((int) Op->Asl.Value.String[i]))
221            {
222                AslError (ASL_ERROR, ASL_MSG_HID_PREFIX,
223                    Op, &Op->Asl.Value.String[i]);
224                return;
225            }
226        }
227    }
228
229    /* Remaining characters (suffix) must be hex digits */
230
231    for (; i < Length; i++)
232    {
233        if (!isxdigit ((int) Op->Asl.Value.String[i]))
234        {
235         AslError (ASL_ERROR, ASL_MSG_HID_SUFFIX,
236            Op, &Op->Asl.Value.String[i]);
237            break;
238        }
239    }
240}
241
242
243/*******************************************************************************
244 *
245 * FUNCTION:    AnLastStatementIsReturn
246 *
247 * PARAMETERS:  Op                  - A method parse node
248 *
249 * RETURN:      TRUE if last statement is an ASL RETURN. False otherwise
250 *
251 * DESCRIPTION: Walk down the list of top level statements within a method
252 *              to find the last one. Check if that last statement is in
253 *              fact a RETURN statement.
254 *
255 ******************************************************************************/
256
257BOOLEAN
258AnLastStatementIsReturn (
259    ACPI_PARSE_OBJECT       *Op)
260{
261    ACPI_PARSE_OBJECT       *Next;
262
263
264    /* Check if last statement is a return */
265
266    Next = ASL_GET_CHILD_NODE (Op);
267    while (Next)
268    {
269        if ((!Next->Asl.Next) &&
270            (Next->Asl.ParseOpcode == PARSEOP_RETURN))
271        {
272            return (TRUE);
273        }
274
275        Next = ASL_GET_PEER_NODE (Next);
276    }
277
278    return (FALSE);
279}
280
281
282/*******************************************************************************
283 *
284 * FUNCTION:    AnCheckMethodReturnValue
285 *
286 * PARAMETERS:  Op                  - Parent
287 *              OpInfo              - Parent info
288 *              ArgOp               - Method invocation op
289 *              RequiredBtypes      - What caller requires
290 *              ThisNodeBtype       - What this node returns (if anything)
291 *
292 * RETURN:      None
293 *
294 * DESCRIPTION: Check a method invocation for 1) A return value and if it does
295 *              in fact return a value, 2) check the type of the return value.
296 *
297 ******************************************************************************/
298
299void
300AnCheckMethodReturnValue (
301    ACPI_PARSE_OBJECT       *Op,
302    const ACPI_OPCODE_INFO  *OpInfo,
303    ACPI_PARSE_OBJECT       *ArgOp,
304    UINT32                  RequiredBtypes,
305    UINT32                  ThisNodeBtype)
306{
307    ACPI_PARSE_OBJECT       *OwningOp;
308    ACPI_NAMESPACE_NODE     *Node;
309
310
311    Node = ArgOp->Asl.Node;
312
313
314    /* Examine the parent op of this method */
315
316    OwningOp = Node->Op;
317    if (OwningOp->Asl.CompileFlags & NODE_METHOD_NO_RETVAL)
318    {
319        /* Method NEVER returns a value */
320
321        AslError (ASL_ERROR, ASL_MSG_NO_RETVAL, Op, Op->Asl.ExternalName);
322    }
323    else if (OwningOp->Asl.CompileFlags & NODE_METHOD_SOME_NO_RETVAL)
324    {
325        /* Method SOMETIMES returns a value, SOMETIMES not */
326
327        AslError (ASL_WARNING, ASL_MSG_SOME_NO_RETVAL, Op, Op->Asl.ExternalName);
328    }
329    else if (!(ThisNodeBtype & RequiredBtypes))
330    {
331        /* Method returns a value, but the type is wrong */
332
333        AnFormatBtype (StringBuffer, ThisNodeBtype);
334        AnFormatBtype (StringBuffer2, RequiredBtypes);
335
336        /*
337         * The case where the method does not return any value at all
338         * was already handled in the namespace cross reference
339         * -- Only issue an error if the method in fact returns a value,
340         * but it is of the wrong type
341         */
342        if (ThisNodeBtype != 0)
343        {
344            sprintf (MsgBuffer,
345                "Method returns [%s], %s operator requires [%s]",
346                StringBuffer, OpInfo->Name, StringBuffer2);
347
348            AslError (ASL_ERROR, ASL_MSG_INVALID_TYPE, ArgOp, MsgBuffer);
349        }
350    }
351}
352
353
354/*******************************************************************************
355 *
356 * FUNCTION:    AnIsResultUsed
357 *
358 * PARAMETERS:  Op                  - Parent op for the operator
359 *
360 * RETURN:      TRUE if result from this operation is actually consumed
361 *
362 * DESCRIPTION: Determine if the function result value from an operator is
363 *              used.
364 *
365 ******************************************************************************/
366
367BOOLEAN
368AnIsResultUsed (
369    ACPI_PARSE_OBJECT       *Op)
370{
371    ACPI_PARSE_OBJECT       *Parent;
372
373
374    switch (Op->Asl.ParseOpcode)
375    {
376    case PARSEOP_INCREMENT:
377    case PARSEOP_DECREMENT:
378
379        /* These are standalone operators, no return value */
380
381        return (TRUE);
382
383    default:
384        break;
385    }
386
387    /* Examine parent to determine if the return value is used */
388
389    Parent = Op->Asl.Parent;
390    switch (Parent->Asl.ParseOpcode)
391    {
392    /* If/While - check if the operator is the predicate */
393
394    case PARSEOP_IF:
395    case PARSEOP_WHILE:
396
397        /* First child is the predicate */
398
399        if (Parent->Asl.Child == Op)
400        {
401            return (TRUE);
402        }
403        return (FALSE);
404
405    /* Not used if one of these is the parent */
406
407    case PARSEOP_METHOD:
408    case PARSEOP_DEFINITIONBLOCK:
409    case PARSEOP_ELSE:
410
411        return (FALSE);
412
413    default:
414        /* Any other type of parent means that the result is used */
415
416        return (TRUE);
417    }
418}
419
420
421/*******************************************************************************
422 *
423 * FUNCTION:    ApCheckForGpeNameConflict
424 *
425 * PARAMETERS:  Op                  - Current parse op
426 *
427 * RETURN:      None
428 *
429 * DESCRIPTION: Check for a conflict between GPE names within this scope.
430 *              Conflict means two GPE names with the same GPE number, but
431 *              different types -- such as _L1C and _E1C.
432 *
433 ******************************************************************************/
434
435void
436ApCheckForGpeNameConflict (
437    ACPI_PARSE_OBJECT       *Op)
438{
439    ACPI_PARSE_OBJECT       *NextOp;
440    UINT32                  GpeNumber;
441    char                    Name[ACPI_NAME_SIZE + 1];
442    char                    Target[ACPI_NAME_SIZE];
443
444
445    /* Need a null-terminated string version of NameSeg */
446
447    ACPI_MOVE_32_TO_32 (Name, &Op->Asl.NameSeg);
448    Name[ACPI_NAME_SIZE] = 0;
449
450    /*
451     * For a GPE method:
452     * 1st char must be underscore
453     * 2nd char must be L or E
454     * 3rd/4th chars must be a hex number
455     */
456    if ((Name[0] != '_') ||
457       ((Name[1] != 'L') && (Name[1] != 'E')))
458    {
459        return;
460    }
461
462    /* Verify 3rd/4th chars are a valid hex value */
463
464    GpeNumber = ACPI_STRTOUL (&Name[2], NULL, 16);
465    if (GpeNumber == ACPI_UINT32_MAX)
466    {
467        return;
468    }
469
470    /*
471     * We are now sure we have an _Lxx or _Exx.
472     * Create the target name that would cause collision (Flip E/L)
473     */
474    ACPI_MOVE_32_TO_32 (Target, Name);
475
476    /* Inject opposite letter ("L" versus "E") */
477
478    if (Name[1] == 'L')
479    {
480        Target[1] = 'E';
481    }
482    else /* Name[1] == 'E' */
483    {
484        Target[1] = 'L';
485    }
486
487    /* Search all peers (objects within this scope) for target match */
488
489    NextOp = Op->Asl.Next;
490    while (NextOp)
491    {
492        /*
493         * We mostly care about methods, but check Name() constructs also,
494         * even though they will get another error for not being a method.
495         * All GPE names must be defined as control methods.
496         */
497        if ((NextOp->Asl.ParseOpcode == PARSEOP_METHOD) ||
498            (NextOp->Asl.ParseOpcode == PARSEOP_NAME))
499        {
500            if (ACPI_COMPARE_NAME (Target, NextOp->Asl.NameSeg))
501            {
502                /* Found both _Exy and _Lxy in the same scope, error */
503
504                AslError (ASL_ERROR, ASL_MSG_GPE_NAME_CONFLICT, NextOp,
505                    Name);
506                return;
507            }
508        }
509
510        NextOp = NextOp->Asl.Next;
511    }
512
513    /* OK, no conflict found */
514
515    return;
516}
517
518
519/*******************************************************************************
520 *
521 * FUNCTION:    ApCheckRegMethod
522 *
523 * PARAMETERS:  Op                  - Current parse op
524 *
525 * RETURN:      None
526 *
527 * DESCRIPTION: Ensure that a _REG method has a corresponding Operation
528 *              Region declaration within the same scope. Note: _REG is defined
529 *              to have two arguments and must therefore be defined as a
530 *              control method.
531 *
532 ******************************************************************************/
533
534void
535ApCheckRegMethod (
536    ACPI_PARSE_OBJECT       *Op)
537{
538    ACPI_PARSE_OBJECT       *Next;
539    ACPI_PARSE_OBJECT       *Parent;
540
541
542    /* We are only interested in _REG methods */
543
544    if (!ACPI_COMPARE_NAME (METHOD_NAME__REG, &Op->Asl.NameSeg))
545    {
546        return;
547    }
548
549    /* Get the start of the current scope */
550
551    Parent = Op->Asl.Parent;
552    Next = Parent->Asl.Child;
553
554    /* Search entire scope for an operation region declaration */
555
556    while (Next)
557    {
558        if (Next->Asl.ParseOpcode == PARSEOP_OPERATIONREGION)
559        {
560            return; /* Found region, OK */
561        }
562
563        Next = Next->Asl.Next;
564    }
565
566    /* No region found, issue warning */
567
568    AslError (ASL_WARNING, ASL_MSG_NO_REGION, Op, NULL);
569}
570