xref: /freebsd/sys/contrib/dev/acpica/compiler/asltransform.c (revision e4e9813eb92cd7c4d4b819a8fbed5cbd3d92f5d8)
1 
2 /******************************************************************************
3  *
4  * Module Name: asltransform - Parse tree transforms
5  *              $Revision: 1.35 $
6  *
7  *****************************************************************************/
8 
9 /******************************************************************************
10  *
11  * 1. Copyright Notice
12  *
13  * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
14  * All rights reserved.
15  *
16  * 2. License
17  *
18  * 2.1. This is your license from Intel Corp. under its intellectual property
19  * rights.  You may have additional license terms from the party that provided
20  * you this software, covering your right to use that party's intellectual
21  * property rights.
22  *
23  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
24  * copy of the source code appearing in this file ("Covered Code") an
25  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
26  * base code distributed originally by Intel ("Original Intel Code") to copy,
27  * make derivatives, distribute, use and display any portion of the Covered
28  * Code in any form, with the right to sublicense such rights; and
29  *
30  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
31  * license (with the right to sublicense), under only those claims of Intel
32  * patents that are infringed by the Original Intel Code, to make, use, sell,
33  * offer to sell, and import the Covered Code and derivative works thereof
34  * solely to the minimum extent necessary to exercise the above copyright
35  * license, and in no event shall the patent license extend to any additions
36  * to or modifications of the Original Intel Code.  No other license or right
37  * is granted directly or by implication, estoppel or otherwise;
38  *
39  * The above copyright and patent license is granted only if the following
40  * conditions are met:
41  *
42  * 3. Conditions
43  *
44  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
45  * Redistribution of source code of any substantial portion of the Covered
46  * Code or modification with rights to further distribute source must include
47  * the above Copyright Notice, the above License, this list of Conditions,
48  * and the following Disclaimer and Export Compliance provision.  In addition,
49  * Licensee must cause all Covered Code to which Licensee contributes to
50  * contain a file documenting the changes Licensee made to create that Covered
51  * Code and the date of any change.  Licensee must include in that file the
52  * documentation of any changes made by any predecessor Licensee.  Licensee
53  * must include a prominent statement that the modification is derived,
54  * directly or indirectly, from Original Intel Code.
55  *
56  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
57  * Redistribution of source code of any substantial portion of the Covered
58  * Code or modification without rights to further distribute source must
59  * include the following Disclaimer and Export Compliance provision in the
60  * documentation and/or other materials provided with distribution.  In
61  * addition, Licensee may not authorize further sublicense of source of any
62  * portion of the Covered Code, and must include terms to the effect that the
63  * license from Licensee to its licensee is limited to the intellectual
64  * property embodied in the software Licensee provides to its licensee, and
65  * not to intellectual property embodied in modifications its licensee may
66  * make.
67  *
68  * 3.3. Redistribution of Executable. Redistribution in executable form of any
69  * substantial portion of the Covered Code or modification must reproduce the
70  * above Copyright Notice, and the following Disclaimer and Export Compliance
71  * provision in the documentation and/or other materials provided with the
72  * distribution.
73  *
74  * 3.4. Intel retains all right, title, and interest in and to the Original
75  * Intel Code.
76  *
77  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
78  * Intel shall be used in advertising or otherwise to promote the sale, use or
79  * other dealings in products derived from or relating to the Covered Code
80  * without prior written authorization from Intel.
81  *
82  * 4. Disclaimer and Export Compliance
83  *
84  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
85  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
86  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
87  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
88  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
89  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
90  * PARTICULAR PURPOSE.
91  *
92  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
93  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
94  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
95  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
96  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
97  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
98  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
99  * LIMITED REMEDY.
100  *
101  * 4.3. Licensee shall not export, either directly or indirectly, any of this
102  * software or system incorporating such software without first obtaining any
103  * required license or other approval from the U. S. Department of Commerce or
104  * any other agency or department of the United States Government.  In the
105  * event Licensee exports any such software from the United States or
106  * re-exports any such software from a foreign destination, Licensee shall
107  * ensure that the distribution and export/re-export of the software is in
108  * compliance with all laws, regulations, orders, or other restrictions of the
109  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
110  * any of its subsidiaries will export/re-export any technical data, process,
111  * software, or service, directly or indirectly, to any country for which the
112  * United States government or any agency thereof requires an export license,
113  * other governmental approval, or letter of assurance, without first obtaining
114  * such license, approval or letter.
115  *
116  *****************************************************************************/
117 
118 
119 #include <contrib/dev/acpica/compiler/aslcompiler.h>
120 #include "aslcompiler.y.h"
121 
122 #define _COMPONENT          ACPI_COMPILER
123         ACPI_MODULE_NAME    ("asltransform")
124 
125 /* Local prototypes */
126 
127 static void
128 TrTransformSubtree (
129     ACPI_PARSE_OBJECT       *Op);
130 
131 static char *
132 TrAmlGetNextTempName (
133     ACPI_PARSE_OBJECT       *Op,
134     UINT8                   *TempCount);
135 
136 static void
137 TrAmlInitLineNumbers (
138     ACPI_PARSE_OBJECT       *Op,
139     ACPI_PARSE_OBJECT       *Neighbor);
140 
141 static void
142 TrAmlInitNode (
143     ACPI_PARSE_OBJECT       *Op,
144     UINT16                  ParseOpcode);
145 
146 static void
147 TrAmlSetSubtreeParent (
148     ACPI_PARSE_OBJECT       *Op,
149     ACPI_PARSE_OBJECT       *Parent);
150 
151 static void
152 TrAmlInsertPeer (
153     ACPI_PARSE_OBJECT       *Op,
154     ACPI_PARSE_OBJECT       *NewPeer);
155 
156 static void
157 TrDoDefinitionBlock (
158     ACPI_PARSE_OBJECT       *Op);
159 
160 static void
161 TrDoSwitch (
162     ACPI_PARSE_OBJECT       *StartNode);
163 
164 
165 /*******************************************************************************
166  *
167  * FUNCTION:    TrAmlGetNextTempName
168  *
169  * PARAMETERS:  Op              - Current parse op
170  *              TempCount       - Current temporary counter. Was originally
171  *                                per-module; Currently per method, could be
172  *                                expanded to per-scope.
173  *
174  * RETURN:      A pointer to name (allocated here).
175  *
176  * DESCRIPTION: Generate an ACPI name of the form _T_x.  These names are
177  *              reserved for use by the ASL compiler. (_T_0 through _T_Z)
178  *
179  ******************************************************************************/
180 
181 static char *
182 TrAmlGetNextTempName (
183     ACPI_PARSE_OBJECT       *Op,
184     UINT8                   *TempCount)
185 {
186     char                    *TempName;
187 
188 
189     if (*TempCount >= (10+26))  /* 0-35 valid: 0-9 and A-Z for TempName[3] */
190     {
191         /* Too many temps */
192 
193         AslError (ASL_ERROR, ASL_MSG_TOO_MANY_TEMPS, Op, NULL);
194         return (NULL);
195     }
196 
197     TempName = UtLocalCalloc (5);
198 
199     if (*TempCount < 10)    /* 0-9 */
200     {
201         TempName[3] = (char) (*TempCount + '0');
202     }
203     else                    /* 10-35: A-Z */
204     {
205         TempName[3] = (char) (*TempCount + ('A' - 10));
206     }
207     (*TempCount)++;
208 
209     /* First three characters are always "_T_" */
210 
211     TempName[0] = '_';
212     TempName[1] = 'T';
213     TempName[2] = '_';
214 
215     return (TempName);
216 }
217 
218 
219 /*******************************************************************************
220  *
221  * FUNCTION:    TrAmlInitLineNumbers
222  *
223  * PARAMETERS:  Op              - Op to be initialized
224  *              Neighbor        - Op used for initialization values
225  *
226  * RETURN:      None
227  *
228  * DESCRIPTION: Initialized the various line numbers for a parse node.
229  *
230  ******************************************************************************/
231 
232 static void
233 TrAmlInitLineNumbers (
234     ACPI_PARSE_OBJECT       *Op,
235     ACPI_PARSE_OBJECT       *Neighbor)
236 {
237 
238     Op->Asl.EndLine           = Neighbor->Asl.EndLine;
239     Op->Asl.EndLogicalLine    = Neighbor->Asl.EndLogicalLine;
240     Op->Asl.LineNumber        = Neighbor->Asl.LineNumber;
241     Op->Asl.LogicalByteOffset = Neighbor->Asl.LogicalByteOffset;
242     Op->Asl.LogicalLineNumber = Neighbor->Asl.LogicalLineNumber;
243 }
244 
245 
246 /*******************************************************************************
247  *
248  * FUNCTION:    TrAmlInitNode
249  *
250  * PARAMETERS:  Op              - Op to be initialized
251  *              ParseOpcode     - Opcode for this node
252  *
253  * RETURN:      None
254  *
255  * DESCRIPTION: Initialize a node with the parse opcode and opcode name.
256  *
257  ******************************************************************************/
258 
259 static void
260 TrAmlInitNode (
261     ACPI_PARSE_OBJECT       *Op,
262     UINT16                  ParseOpcode)
263 {
264 
265     Op->Asl.ParseOpcode = ParseOpcode;
266     UtSetParseOpName (Op);
267 }
268 
269 
270 /*******************************************************************************
271  *
272  * FUNCTION:    TrAmlSetSubtreeParent
273  *
274  * PARAMETERS:  Op              - First node in a list of peer nodes
275  *              Parent          - Parent of the subtree
276  *
277  * RETURN:      None
278  *
279  * DESCRIPTION: Set the parent for all peer nodes in a subtree
280  *
281  ******************************************************************************/
282 
283 static void
284 TrAmlSetSubtreeParent (
285     ACPI_PARSE_OBJECT       *Op,
286     ACPI_PARSE_OBJECT       *Parent)
287 {
288     ACPI_PARSE_OBJECT       *Next;
289 
290 
291     Next = Op;
292     while (Next)
293     {
294         Next->Asl.Parent = Parent;
295         Next             = Next->Asl.Next;
296     }
297 }
298 
299 
300 /*******************************************************************************
301  *
302  * FUNCTION:    TrAmlInsertPeer
303  *
304  * PARAMETERS:  Op              - First node in a list of peer nodes
305  *              NewPeer         - Peer node to insert
306  *
307  * RETURN:      None
308  *
309  * DESCRIPTION: Insert a new peer node into a list of peers.
310  *
311  ******************************************************************************/
312 
313 static void
314 TrAmlInsertPeer (
315     ACPI_PARSE_OBJECT       *Op,
316     ACPI_PARSE_OBJECT       *NewPeer)
317 {
318 
319     NewPeer->Asl.Next = Op->Asl.Next;
320     Op->Asl.Next      = NewPeer;
321 }
322 
323 
324 /*******************************************************************************
325  *
326  * FUNCTION:    TrAmlTransformWalk
327  *
328  * PARAMETERS:  ASL_WALK_CALLBACK
329  *
330  * RETURN:      None
331  *
332  * DESCRIPTION: Parse tree walk to generate both the AML opcodes and the AML
333  *              operands.
334  *
335  ******************************************************************************/
336 
337 ACPI_STATUS
338 TrAmlTransformWalk (
339     ACPI_PARSE_OBJECT       *Op,
340     UINT32                  Level,
341     void                    *Context)
342 {
343 
344     TrTransformSubtree (Op);
345     return (AE_OK);
346 }
347 
348 
349 /*******************************************************************************
350  *
351  * FUNCTION:    TrTransformSubtree
352  *
353  * PARAMETERS:  Op        - The parent parse node
354  *
355  * RETURN:      None
356  *
357  * DESCRIPTION: Prepare nodes to be output as AML data and operands.  The more
358  *              complex AML opcodes require processing of the child nodes
359  *              (arguments/operands).
360  *
361  ******************************************************************************/
362 
363 static void
364 TrTransformSubtree (
365     ACPI_PARSE_OBJECT           *Op)
366 {
367 
368     if (Op->Asl.AmlOpcode == AML_RAW_DATA_BYTE)
369     {
370         return;
371     }
372 
373     switch (Op->Asl.ParseOpcode)
374     {
375     case PARSEOP_DEFINITIONBLOCK:
376         TrDoDefinitionBlock (Op);
377         break;
378 
379     case PARSEOP_SWITCH:
380         TrDoSwitch (Op);
381         break;
382 
383     case PARSEOP_METHOD:
384 
385         /*
386          * TBD: Zero the tempname (_T_x) count. Probably shouldn't be a global,
387          * however
388          */
389         Gbl_TempCount = 0;
390         break;
391 
392     default:
393         /* Nothing to do here for other opcodes */
394         break;
395     }
396 }
397 
398 
399 /*******************************************************************************
400  *
401  * FUNCTION:    TrDoDefinitionBlock
402  *
403  * PARAMETERS:  Op        - Parse node
404  *
405  * RETURN:      None
406  *
407  * DESCRIPTION: Find the end of the definition block and set a global to this
408  *              node.  It is used by the compiler to insert compiler-generated
409  *              names at the root level of the namespace.
410  *
411  ******************************************************************************/
412 
413 static void
414 TrDoDefinitionBlock (
415     ACPI_PARSE_OBJECT       *Op)
416 {
417     ACPI_PARSE_OBJECT       *Next;
418     UINT32                  i;
419 
420 
421     Next = Op->Asl.Child;
422     for (i = 0; i < 5; i++)
423     {
424         Next = Next->Asl.Next;
425         if (i == 0)
426         {
427             /*
428              * This is the table signature. Only the DSDT can be assumed
429              * to be at the root of the namespace;  Therefore, namepath
430              * optimization can only be performed on the DSDT.
431              */
432             if (ACPI_STRNCMP (Next->Asl.Value.String, "DSDT", 4))
433             {
434                 Gbl_ReferenceOptimizationFlag = FALSE;
435             }
436         }
437     }
438 
439     Gbl_FirstLevelInsertionNode = Next;
440 }
441 
442 
443 /*******************************************************************************
444  *
445  * FUNCTION:    TrDoSwitch
446  *
447  * PARAMETERS:  StartNode        - Parse node for SWITCH
448  *
449  * RETURN:      None
450  *
451  *
452  * DESCRIPTION: Translate ASL SWITCH statement to if/else pairs.  There is
453  *              no actual AML opcode for SWITCH -- it must be simulated.
454  *
455  ******************************************************************************/
456 
457 static void
458 TrDoSwitch (
459     ACPI_PARSE_OBJECT       *StartNode)
460 {
461     ACPI_PARSE_OBJECT       *Next;
462     ACPI_PARSE_OBJECT       *CaseOp = NULL;
463     ACPI_PARSE_OBJECT       *CaseBlock = NULL;
464     ACPI_PARSE_OBJECT       *DefaultOp = NULL;
465     ACPI_PARSE_OBJECT       *CurrentParentNode;
466     ACPI_PARSE_OBJECT       *Conditional = NULL;
467     ACPI_PARSE_OBJECT       *Predicate;
468     ACPI_PARSE_OBJECT       *Peer;
469     ACPI_PARSE_OBJECT       *NewOp;
470     ACPI_PARSE_OBJECT       *NewOp2;
471     char                    *PredicateValueName;
472     UINT16                  Index;
473     UINT32                  Btype;
474 
475 
476     /* Start node is the Switch() node */
477 
478     CurrentParentNode  = StartNode;
479 
480     /* Create a new temp name of the form _T_x */
481 
482     PredicateValueName = TrAmlGetNextTempName (StartNode, &Gbl_TempCount);
483     if (!PredicateValueName)
484     {
485         return;
486     }
487 
488     /* First child is the Switch() predicate */
489 
490     Next = StartNode->Asl.Child;
491 
492     /*
493      * Examine the return type of the Switch Value -
494      * must be Integer/Buffer/String
495      */
496     Index = (UINT16) (Next->Asl.ParseOpcode - ASL_PARSE_OPCODE_BASE);
497     Btype = AslKeywordMapping[Index].AcpiBtype;
498     if ((Btype != ACPI_BTYPE_INTEGER) &&
499         (Btype != ACPI_BTYPE_STRING)  &&
500         (Btype != ACPI_BTYPE_BUFFER))
501     {
502         AslError (ASL_WARNING, ASL_MSG_SWITCH_TYPE, Next, NULL);
503         Btype = ACPI_BTYPE_INTEGER;
504     }
505 
506     /* CASE statements start at next child */
507 
508     Peer = Next->Asl.Next;
509     while (Peer)
510     {
511         Next = Peer;
512         Peer = Next->Asl.Next;
513 
514         if (Next->Asl.ParseOpcode == PARSEOP_CASE)
515         {
516             if (CaseOp)
517             {
518                 /* Add an ELSE to complete the previous CASE */
519 
520                 if (!Conditional)
521                 {
522                     return;
523                 }
524                 NewOp             = TrCreateLeafNode (PARSEOP_ELSE);
525                 NewOp->Asl.Parent = Conditional->Asl.Parent;
526                 TrAmlInitLineNumbers (NewOp, NewOp->Asl.Parent);
527 
528                 /* Link ELSE node as a peer to the previous IF */
529 
530                 TrAmlInsertPeer (Conditional, NewOp);
531                 CurrentParentNode = NewOp;
532             }
533 
534             CaseOp      = Next;
535             Conditional = CaseOp;
536             CaseBlock   = CaseOp->Asl.Child->Asl.Next;
537             Conditional->Asl.Child->Asl.Next = NULL;
538             Predicate = CaseOp->Asl.Child;
539 
540             if ((Predicate->Asl.ParseOpcode == PARSEOP_PACKAGE) ||
541                 (Predicate->Asl.ParseOpcode == PARSEOP_VAR_PACKAGE))
542             {
543                 /*
544                  * Convert the package declaration to this form:
545                  *
546                  * If (LNotEqual (Match (Package(<size>){<data>},
547                  *                       MEQ, _T_x, MTR, Zero, Zero), Ones))
548                  */
549                 NewOp2              = TrCreateLeafNode (PARSEOP_MATCHTYPE_MEQ);
550                 Predicate->Asl.Next = NewOp2;
551                 TrAmlInitLineNumbers (NewOp2, Conditional);
552 
553                 NewOp               = NewOp2;
554                 NewOp2              = TrCreateValuedLeafNode (PARSEOP_NAMESTRING,
555                                         (ACPI_INTEGER) ACPI_TO_INTEGER (PredicateValueName));
556                 NewOp->Asl.Next     = NewOp2;
557                 TrAmlInitLineNumbers (NewOp2, Predicate);
558 
559                 NewOp               = NewOp2;
560                 NewOp2              = TrCreateLeafNode (PARSEOP_MATCHTYPE_MTR);
561                 NewOp->Asl.Next     = NewOp2;
562                 TrAmlInitLineNumbers (NewOp2, Predicate);
563 
564                 NewOp               = NewOp2;
565                 NewOp2              = TrCreateLeafNode (PARSEOP_ZERO);
566                 NewOp->Asl.Next     = NewOp2;
567                 TrAmlInitLineNumbers (NewOp2, Predicate);
568 
569                 NewOp               = NewOp2;
570                 NewOp2              = TrCreateLeafNode (PARSEOP_ZERO);
571                 NewOp->Asl.Next     = NewOp2;
572                 TrAmlInitLineNumbers (NewOp2, Predicate);
573 
574                 NewOp2              = TrCreateLeafNode (PARSEOP_MATCH);
575                 NewOp2->Asl.Child   = Predicate;  /* PARSEOP_PACKAGE */
576                 TrAmlInitLineNumbers (NewOp2, Conditional);
577                 TrAmlSetSubtreeParent (Predicate, NewOp2);
578 
579                 NewOp               = NewOp2;
580                 NewOp2              = TrCreateLeafNode (PARSEOP_ONES);
581                 NewOp->Asl.Next     = NewOp2;
582                 TrAmlInitLineNumbers (NewOp2, Conditional);
583 
584                 NewOp2              = TrCreateLeafNode (PARSEOP_LEQUAL);
585                 NewOp2->Asl.Child   = NewOp;
586                 NewOp->Asl.Parent   = NewOp2;
587                 TrAmlInitLineNumbers (NewOp2, Conditional);
588                 TrAmlSetSubtreeParent (NewOp, NewOp2);
589 
590                 NewOp               = NewOp2;
591                 NewOp2              = TrCreateLeafNode (PARSEOP_LNOT);
592                 NewOp2->Asl.Child   = NewOp;
593                 NewOp2->Asl.Parent  = Conditional;
594                 NewOp->Asl.Parent   = NewOp2;
595                 TrAmlInitLineNumbers (NewOp2, Conditional);
596 
597                 Conditional->Asl.Child = NewOp2;
598                 NewOp2->Asl.Next = CaseBlock;
599             }
600             else
601             {
602                 /*
603                  * Integer and Buffer case.
604                  *
605                  * Change CaseOp() to:  If (LEqual (SwitchValue, CaseValue)) {...}
606                  * Note: SwitchValue is first to allow the CaseValue to be implicitly
607                  * converted to the type of SwitchValue if necessary.
608                  *
609                  * CaseOp->Child is the case value
610                  * CaseOp->Child->Peer is the beginning of the case block
611                  */
612                 NewOp = TrCreateValuedLeafNode (PARSEOP_NAMESTRING,
613                             (ACPI_INTEGER) ACPI_TO_INTEGER (PredicateValueName));
614                 NewOp->Asl.Next = Predicate;
615                 TrAmlInitLineNumbers (NewOp, Predicate);
616 
617                 NewOp2              = TrCreateLeafNode (PARSEOP_LEQUAL);
618                 NewOp2->Asl.Parent  = Conditional;
619                 NewOp2->Asl.Child   = NewOp;
620                 TrAmlInitLineNumbers (NewOp2, Conditional);
621 
622                 TrAmlSetSubtreeParent (NewOp, NewOp2);
623 
624                 Predicate           = NewOp2;
625                 Predicate->Asl.Next = CaseBlock;
626 
627                 TrAmlSetSubtreeParent (Predicate, Conditional);
628                 Conditional->Asl.Child = Predicate;
629             }
630 
631             /* Reinitialize the CASE node to an IF node */
632 
633             TrAmlInitNode (Conditional, PARSEOP_IF);
634 
635             /*
636              * The first CASE(IF) is not nested under an ELSE.
637              * All other CASEs are children of a parent ELSE.
638              */
639             if (CurrentParentNode == StartNode)
640             {
641                 Conditional->Asl.Parent = CurrentParentNode->Asl.Parent;
642 
643                 /* Link IF into the peer list */
644 
645                 TrAmlInsertPeer (CurrentParentNode, Conditional);
646             }
647             else
648             {
649                 /*
650                  * The IF is a child of previous IF/ELSE.  It
651                  * is therefore without peer.
652                  */
653                 CurrentParentNode->Asl.Child = Conditional;
654                 Conditional->Asl.Parent      = CurrentParentNode;
655                 Conditional->Asl.Next        = NULL;
656             }
657         }
658         else if (Next->Asl.ParseOpcode == PARSEOP_DEFAULT)
659         {
660             if (DefaultOp)
661             {
662                 /*
663                  * More than one Default
664                  * (Parser should catch this, should not get here)
665                  */
666                 AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Next,
667                     "Found more than one Default()");
668             }
669 
670             /* Save the DEFAULT node for later, after CASEs */
671 
672             DefaultOp = Next;
673         }
674         else
675         {
676             /* Unknown peer opcode */
677 
678             AcpiOsPrintf ("Unknown parse opcode for switch statement: %s (%d)\n",
679                         Next->Asl.ParseOpName, Next->Asl.ParseOpcode);
680         }
681     }
682 
683     /* Add the default case at the end of the if/else construct */
684 
685     if (DefaultOp)
686     {
687         /* If no CASE statements, this is an error - see below */
688 
689         if (CaseOp)
690         {
691             /* Convert the DEFAULT node to an ELSE */
692 
693             if (!Conditional)
694             {
695                 return;
696             }
697             TrAmlInitNode (DefaultOp, PARSEOP_ELSE);
698             DefaultOp->Asl.Parent = Conditional->Asl.Parent;
699 
700             /* Link ELSE node as a peer to the previous IF */
701 
702             TrAmlInsertPeer (Conditional, DefaultOp);
703         }
704     }
705 
706     if (!CaseOp)
707     {
708         AslError (ASL_ERROR, ASL_MSG_NO_CASES, StartNode, NULL);
709     }
710 
711     /*
712      * Add a NAME node for the temp integer:
713      * Change the SWITCH node to a Name (_T_x, Type)
714      */
715     Predicate = StartNode->Asl.Child;
716     TrAmlInitNode (StartNode, PARSEOP_NAME);
717 
718     NewOp = StartNode;
719 
720     NewOp->Asl.CompileFlags |= NODE_COMPILER_EMITTED;
721 
722     NewOp2 = TrCreateValuedLeafNode (PARSEOP_NAMESEG,
723                 (ACPI_INTEGER) ACPI_TO_INTEGER (PredicateValueName));
724     NewOp2->Asl.CompileFlags |= NODE_IS_NAME_DECLARATION;
725     NewOp->Asl.Child  = NewOp2;
726 
727     /* Btype was already validated above */
728 
729     switch (Btype)
730     {
731     case ACPI_BTYPE_INTEGER:
732         NewOp2->Asl.Next  = TrCreateValuedLeafNode (PARSEOP_ZERO,
733                                 (ACPI_INTEGER) 0);
734         break;
735 
736     case ACPI_BTYPE_STRING:
737         NewOp2->Asl.Next = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL,
738                                 (ACPI_INTEGER) "");
739         break;
740 
741     case ACPI_BTYPE_BUFFER:
742         (void) TrLinkPeerNode (NewOp2, TrCreateValuedLeafNode (PARSEOP_BUFFER,
743                                     (ACPI_INTEGER) 0));
744         Next = NewOp2->Asl.Next;
745         (void) TrLinkChildren (Next, 1, TrCreateValuedLeafNode (PARSEOP_ZERO,
746                                     (ACPI_INTEGER) 1));
747         (void) TrLinkPeerNode (Next->Asl.Child,
748             TrCreateValuedLeafNode (PARSEOP_DEFAULT_ARG, (ACPI_INTEGER) 0));
749 
750         TrAmlSetSubtreeParent (Next->Asl.Child, Next);
751         break;
752 
753     default:
754         break;
755     }
756 
757     TrAmlSetSubtreeParent (NewOp2, NewOp);
758 
759     /*
760      * Create and insert a new Store() node which will be used to save the
761      * Switch() value.  The store is of the form: Store (Value, _T_x)
762      * where _T_x is the temp variable.
763      */
764     Next = TrCreateLeafNode (PARSEOP_STORE);
765     TrAmlInsertPeer (StartNode, Next);
766     TrAmlSetSubtreeParent (Next, StartNode->Asl.Parent);
767 
768     TrAmlInitLineNumbers (Next, StartNode);
769     TrAmlInitLineNumbers (NewOp2, StartNode);
770     TrAmlInitLineNumbers (NewOp2->Asl.Next, StartNode);
771 
772     /* Complete the Store subtree */
773 
774     Next->Asl.Child       = Predicate;
775     Predicate->Asl.Parent = Next;
776 
777     NewOp = TrCreateValuedLeafNode (PARSEOP_NAMESEG,
778                 (ACPI_INTEGER) ACPI_TO_INTEGER (PredicateValueName));
779     NewOp->Asl.Parent    = Next;
780     Predicate->Asl.Next  = NewOp;
781 }
782 
783 
784