sys/contrib/dev/acpica/source/compiler/aslwalks.c

   1 /******************************************************************************
   2  *
   3  * Module Name: aslwalks.c - Miscellaneous analytical parse tree walks
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2014, 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 "aslcompiler.h"
  46 #include "aslcompiler.y.h"
  47 #include "acparser.h"
  48 #include "amlcode.h"
  49
  50
  51 #define _COMPONENT          ACPI_COMPILER
  52         ACPI_MODULE_NAME    ("aslwalks")
  53
  54
  55 /*******************************************************************************
  56  *
  57  * FUNCTION:    AnMethodTypingWalkEnd
  58  *
  59  * PARAMETERS:  ASL_WALK_CALLBACK
  60  *
  61  * RETURN:      Status
  62  *
  63  * DESCRIPTION: Ascending callback for typing walk. Complete the method
  64  *              return analysis. Check methods for:
  65  *              1) Initialized local variables
  66  *              2) Valid arguments
  67  *              3) Return types
  68  *
  69  ******************************************************************************/
  70
  71 ACPI_STATUS
  72 AnMethodTypingWalkEnd (
  73     ACPI_PARSE_OBJECT       *Op,
  74     UINT32                  Level,
  75     void                    *Context)
  76 {
  77     UINT32                  ThisNodeBtype;
  78
  79
  80     switch (Op->Asl.ParseOpcode)
  81     {
  82     case PARSEOP_METHOD:
  83
  84         Op->Asl.CompileFlags |= NODE_METHOD_TYPED;
  85         break;
  86
  87     case PARSEOP_RETURN:
  88
  89         if ((Op->Asl.Child) &&
  90             (Op->Asl.Child->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG))
  91         {
  92             ThisNodeBtype = AnGetBtype (Op->Asl.Child);
  93
  94             if ((Op->Asl.Child->Asl.ParseOpcode == PARSEOP_METHODCALL) &&
  95                 (ThisNodeBtype == (ACPI_UINT32_MAX -1)))
  96             {
  97                 /*
  98                  * The called method is untyped at this time (typically a
  99                  * forward reference).
 100                  *
 101                  * Check for a recursive method call first.
 102                  */
 103                 if (Op->Asl.ParentMethod != Op->Asl.Child->Asl.Node->Op)
 104                 {
 105                     /* We must type the method here */
 106
 107                     TrWalkParseTree (Op->Asl.Child->Asl.Node->Op,
 108                         ASL_WALK_VISIT_UPWARD, NULL,
 109                         AnMethodTypingWalkEnd, NULL);
 110
 111                     ThisNodeBtype = AnGetBtype (Op->Asl.Child);
 112                 }
 113             }
 114
 115             /* Returns a value, save the value type */
 116
 117             if (Op->Asl.ParentMethod)
 118             {
 119                 Op->Asl.ParentMethod->Asl.AcpiBtype |= ThisNodeBtype;
 120             }
 121         }
 122         break;
 123
 124     default:
 125
 126         break;
 127     }
 128
 129     return (AE_OK);
 130 }
 131
 132
 133 /*******************************************************************************
 134  *
 135  * FUNCTION:    AnOperandTypecheckWalkEnd
 136  *
 137  * PARAMETERS:  ASL_WALK_CALLBACK
 138  *
 139  * RETURN:      Status
 140  *
 141  * DESCRIPTION: Ascending callback for analysis walk. Complete method
 142  *              return analysis.
 143  *
 144  ******************************************************************************/
 145
 146 ACPI_STATUS
 147 AnOperandTypecheckWalkEnd (
 148     ACPI_PARSE_OBJECT       *Op,
 149     UINT32                  Level,
 150     void                    *Context)
 151 {
 152     const ACPI_OPCODE_INFO  *OpInfo;
 153     UINT32                  RuntimeArgTypes;
 154     UINT32                  RuntimeArgTypes2;
 155     UINT32                  RequiredBtypes;
 156     UINT32                  ThisNodeBtype;
 157     UINT32                  CommonBtypes;
 158     UINT32                  OpcodeClass;
 159     ACPI_PARSE_OBJECT       *ArgOp;
 160     UINT32                  ArgType;
 161
 162
 163     switch (Op->Asl.AmlOpcode)
 164     {
 165     case AML_RAW_DATA_BYTE:
 166     case AML_RAW_DATA_WORD:
 167     case AML_RAW_DATA_DWORD:
 168     case AML_RAW_DATA_QWORD:
 169     case AML_RAW_DATA_BUFFER:
 170     case AML_RAW_DATA_CHAIN:
 171     case AML_PACKAGE_LENGTH:
 172     case AML_UNASSIGNED_OPCODE:
 173     case AML_DEFAULT_ARG_OP:
 174
 175         /* Ignore the internal (compiler-only) AML opcodes */
 176
 177         return (AE_OK);
 178
 179     default:
 180
 181         break;
 182     }
 183
 184     OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
 185     if (!OpInfo)
 186     {
 187         return (AE_OK);
 188     }
 189
 190     ArgOp           = Op->Asl.Child;
 191     RuntimeArgTypes = OpInfo->RuntimeArgs;
 192     OpcodeClass     = OpInfo->Class;
 193
 194 #ifdef ASL_ERROR_NAMED_OBJECT_IN_WHILE
 195     /*
 196      * Update 11/2008: In practice, we can't perform this check. A simple
 197      * analysis is not sufficient. Also, it can cause errors when compiling
 198      * disassembled code because of the way Switch operators are implemented
 199      * (a While(One) loop with a named temp variable created within.)
 200      */
 201
 202     /*
 203      * If we are creating a named object, check if we are within a while loop
 204      * by checking if the parent is a WHILE op. This is a simple analysis, but
 205      * probably sufficient for many cases.
 206      *
 207      * Allow Scope(), Buffer(), and Package().
 208      */
 209     if (((OpcodeClass == AML_CLASS_NAMED_OBJECT) && (Op->Asl.AmlOpcode != AML_SCOPE_OP)) ||
 210         ((OpcodeClass == AML_CLASS_CREATE) && (OpInfo->Flags & AML_NSNODE)))
 211     {
 212         if (Op->Asl.Parent->Asl.AmlOpcode == AML_WHILE_OP)
 213         {
 214             AslError (ASL_ERROR, ASL_MSG_NAMED_OBJECT_IN_WHILE, Op, NULL);
 215         }
 216     }
 217 #endif
 218
 219     /*
 220      * Special case for control opcodes IF/RETURN/WHILE since they
 221      * have no runtime arg list (at this time)
 222      */
 223     switch (Op->Asl.AmlOpcode)
 224     {
 225     case AML_IF_OP:
 226     case AML_WHILE_OP:
 227     case AML_RETURN_OP:
 228
 229         if (ArgOp->Asl.ParseOpcode == PARSEOP_METHODCALL)
 230         {
 231             /* Check for an internal method */
 232
 233             if (AnIsInternalMethod (ArgOp))
 234             {
 235                 return (AE_OK);
 236             }
 237
 238             /* The lone arg is a method call, check it */
 239
 240             RequiredBtypes = AnMapArgTypeToBtype (ARGI_INTEGER);
 241             if (Op->Asl.AmlOpcode == AML_RETURN_OP)
 242             {
 243                 RequiredBtypes = 0xFFFFFFFF;
 244             }
 245
 246             ThisNodeBtype = AnGetBtype (ArgOp);
 247             if (ThisNodeBtype == ACPI_UINT32_MAX)
 248             {
 249                 return (AE_OK);
 250             }
 251             AnCheckMethodReturnValue (Op, OpInfo, ArgOp,
 252                 RequiredBtypes, ThisNodeBtype);
 253         }
 254         return (AE_OK);
 255
 256     default:
 257
 258         break;
 259     }
 260
 261     /* Ignore the non-executable opcodes */
 262
 263     if (RuntimeArgTypes == ARGI_INVALID_OPCODE)
 264     {
 265         return (AE_OK);
 266     }
 267
 268     switch (OpcodeClass)
 269     {
 270     case AML_CLASS_EXECUTE:
 271     case AML_CLASS_CREATE:
 272     case AML_CLASS_CONTROL:
 273     case AML_CLASS_RETURN_VALUE:
 274
 275         /* TBD: Change class or fix typechecking for these */
 276
 277         if ((Op->Asl.AmlOpcode == AML_BUFFER_OP)        ||
 278             (Op->Asl.AmlOpcode == AML_PACKAGE_OP)       ||
 279             (Op->Asl.AmlOpcode == AML_VAR_PACKAGE_OP))
 280         {
 281             break;
 282         }
 283
 284         /* Reverse the runtime argument list */
 285
 286         RuntimeArgTypes2 = 0;
 287         while ((ArgType = GET_CURRENT_ARG_TYPE (RuntimeArgTypes)))
 288         {
 289             RuntimeArgTypes2 <<= ARG_TYPE_WIDTH;
 290             RuntimeArgTypes2 |= ArgType;
 291             INCREMENT_ARG_LIST (RuntimeArgTypes);
 292         }
 293
 294         while ((ArgType = GET_CURRENT_ARG_TYPE (RuntimeArgTypes2)))
 295         {
 296             RequiredBtypes = AnMapArgTypeToBtype (ArgType);
 297
 298             ThisNodeBtype = AnGetBtype (ArgOp);
 299             if (ThisNodeBtype == ACPI_UINT32_MAX)
 300             {
 301                 goto NextArgument;
 302             }
 303
 304             /* Examine the arg based on the required type of the arg */
 305
 306             switch (ArgType)
 307             {
 308             case ARGI_TARGETREF:
 309
 310                 if (ArgOp->Asl.ParseOpcode == PARSEOP_ZERO)
 311                 {
 312                     /* ZERO is the placeholder for "don't store result" */
 313
 314                     ThisNodeBtype = RequiredBtypes;
 315                     break;
 316                 }
 317
 318                 if (ArgOp->Asl.ParseOpcode == PARSEOP_INTEGER)
 319                 {
 320                     /*
 321                      * This is the case where an original reference to a resource
 322                      * descriptor field has been replaced by an (Integer) offset.
 323                      * These named fields are supported at compile-time only;
 324                      * the names are not passed to the interpreter (via the AML).
 325                      */
 326                     if ((ArgOp->Asl.Node->Type == ACPI_TYPE_LOCAL_RESOURCE_FIELD) ||
 327                         (ArgOp->Asl.Node->Type == ACPI_TYPE_LOCAL_RESOURCE))
 328                     {
 329                         AslError (ASL_ERROR, ASL_MSG_RESOURCE_FIELD, ArgOp, NULL);
 330                     }
 331                     else
 332                     {
 333                         AslError (ASL_ERROR, ASL_MSG_INVALID_TYPE, ArgOp, NULL);
 334                     }
 335                     break;
 336                 }
 337
 338                 if ((ArgOp->Asl.ParseOpcode == PARSEOP_METHODCALL) ||
 339                     (ArgOp->Asl.ParseOpcode == PARSEOP_DEREFOF))
 340                 {
 341                     break;
 342                 }
 343
 344                 ThisNodeBtype = RequiredBtypes;
 345                 break;
 346
 347
 348             case ARGI_REFERENCE:            /* References */
 349             case ARGI_INTEGER_REF:
 350             case ARGI_OBJECT_REF:
 351             case ARGI_DEVICE_REF:
 352
 353                 switch (ArgOp->Asl.ParseOpcode)
 354                 {
 355                 case PARSEOP_LOCAL0:
 356                 case PARSEOP_LOCAL1:
 357                 case PARSEOP_LOCAL2:
 358                 case PARSEOP_LOCAL3:
 359                 case PARSEOP_LOCAL4:
 360                 case PARSEOP_LOCAL5:
 361                 case PARSEOP_LOCAL6:
 362                 case PARSEOP_LOCAL7:
 363
 364                     /* TBD: implement analysis of current value (type) of the local */
 365                     /* For now, just treat any local as a typematch */
 366
 367                     /*ThisNodeBtype = RequiredBtypes;*/
 368                     break;
 369
 370                 case PARSEOP_ARG0:
 371                 case PARSEOP_ARG1:
 372                 case PARSEOP_ARG2:
 373                 case PARSEOP_ARG3:
 374                 case PARSEOP_ARG4:
 375                 case PARSEOP_ARG5:
 376                 case PARSEOP_ARG6:
 377
 378                     /* Hard to analyze argument types, sow we won't */
 379                     /* For now, just treat any arg as a typematch */
 380
 381                     /* ThisNodeBtype = RequiredBtypes; */
 382                     break;
 383
 384                 case PARSEOP_DEBUG:
 385
 386                     break;
 387
 388                 case PARSEOP_REFOF:
 389                 case PARSEOP_INDEX:
 390                 default:
 391
 392                     break;
 393
 394                 }
 395                 break;
 396
 397             case ARGI_INTEGER:
 398             default:
 399
 400                 break;
 401             }
 402
 403
 404             CommonBtypes = ThisNodeBtype & RequiredBtypes;
 405
 406             if (ArgOp->Asl.ParseOpcode == PARSEOP_METHODCALL)
 407             {
 408                 if (AnIsInternalMethod (ArgOp))
 409                 {
 410                     return (AE_OK);
 411                 }
 412
 413                 /* Check a method call for a valid return value */
 414
 415                 AnCheckMethodReturnValue (Op, OpInfo, ArgOp,
 416                     RequiredBtypes, ThisNodeBtype);
 417             }
 418
 419             /*
 420              * Now check if the actual type(s) match at least one
 421              * bit to the required type
 422              */
 423             else if (!CommonBtypes)
 424             {
 425                 /* No match -- this is a type mismatch error */
 426
 427                 AnFormatBtype (StringBuffer, ThisNodeBtype);
 428                 AnFormatBtype (StringBuffer2, RequiredBtypes);
 429
 430                 sprintf (MsgBuffer, "[%s] found, %s operator requires [%s]",
 431                             StringBuffer, OpInfo->Name, StringBuffer2);
 432
 433                 AslError (ASL_ERROR, ASL_MSG_INVALID_TYPE, ArgOp, MsgBuffer);
 434             }
 435
 436         NextArgument:
 437             ArgOp = ArgOp->Asl.Next;
 438             INCREMENT_ARG_LIST (RuntimeArgTypes2);
 439         }
 440         break;
 441
 442     default:
 443
 444         break;
 445     }
 446
 447     return (AE_OK);
 448 }
 449
 450
 451 /*******************************************************************************
 452  *
 453  * FUNCTION:    AnOtherSemanticAnalysisWalkBegin
 454  *
 455  * PARAMETERS:  ASL_WALK_CALLBACK
 456  *
 457  * RETURN:      Status
 458  *
 459  * DESCRIPTION: Descending callback for the analysis walk. Checks for
 460  *              miscellaneous issues in the code.
 461  *
 462  ******************************************************************************/
 463
 464 ACPI_STATUS
 465 AnOtherSemanticAnalysisWalkBegin (
 466     ACPI_PARSE_OBJECT       *Op,
 467     UINT32                  Level,
 468     void                    *Context)
 469 {
 470     ACPI_PARSE_OBJECT       *ArgNode;
 471     ACPI_PARSE_OBJECT       *PrevArgNode = NULL;
 472     const ACPI_OPCODE_INFO  *OpInfo;
 473     ACPI_NAMESPACE_NODE     *Node;
 474
 475
 476     OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
 477
 478     /*
 479      * Determine if an execution class operator actually does something by
 480      * checking if it has a target and/or the function return value is used.
 481      * (Target is optional, so a standalone statement can actually do nothing.)
 482      */
 483     if ((OpInfo->Class == AML_CLASS_EXECUTE) &&
 484         (OpInfo->Flags & AML_HAS_RETVAL) &&
 485         (!AnIsResultUsed (Op)))
 486     {
 487         if (OpInfo->Flags & AML_HAS_TARGET)
 488         {
 489             /*
 490              * Find the target node, it is always the last child. If the traget
 491              * is not specified in the ASL, a default node of type Zero was
 492              * created by the parser.
 493              */
 494             ArgNode = Op->Asl.Child;
 495             while (ArgNode->Asl.Next)
 496             {
 497                 PrevArgNode = ArgNode;
 498                 ArgNode = ArgNode->Asl.Next;
 499             }
 500
 501             /* Divide() is the only weird case, it has two targets */
 502
 503             if (Op->Asl.AmlOpcode == AML_DIVIDE_OP)
 504             {
 505                 if ((ArgNode->Asl.ParseOpcode == PARSEOP_ZERO) &&
 506                     (PrevArgNode) &&
 507                     (PrevArgNode->Asl.ParseOpcode == PARSEOP_ZERO))
 508                 {
 509                     AslError (ASL_ERROR, ASL_MSG_RESULT_NOT_USED,
 510                         Op, Op->Asl.ExternalName);
 511                 }
 512             }
 513             else if (ArgNode->Asl.ParseOpcode == PARSEOP_ZERO)
 514             {
 515                 AslError (ASL_ERROR, ASL_MSG_RESULT_NOT_USED,
 516                     Op, Op->Asl.ExternalName);
 517             }
 518         }
 519         else
 520         {
 521             /*
 522              * Has no target and the result is not used. Only a couple opcodes
 523              * can have this combination.
 524              */
 525             switch (Op->Asl.ParseOpcode)
 526             {
 527             case PARSEOP_ACQUIRE:
 528             case PARSEOP_WAIT:
 529             case PARSEOP_LOADTABLE:
 530
 531                 break;
 532
 533             default:
 534
 535                 AslError (ASL_ERROR, ASL_MSG_RESULT_NOT_USED,
 536                     Op, Op->Asl.ExternalName);
 537                 break;
 538             }
 539         }
 540     }
 541
 542
 543     /*
 544      * Semantic checks for individual ASL operators
 545      */
 546     switch (Op->Asl.ParseOpcode)
 547     {
 548     case PARSEOP_ACQUIRE:
 549     case PARSEOP_WAIT:
 550         /*
 551          * Emit a warning if the timeout parameter for these operators is not
 552          * ACPI_WAIT_FOREVER, and the result value from the operator is not
 553          * checked, meaning that a timeout could happen, but the code
 554          * would not know about it.
 555          */
 556
 557         /* First child is the namepath, 2nd child is timeout */
 558
 559         ArgNode = Op->Asl.Child;
 560         ArgNode = ArgNode->Asl.Next;
 561
 562         /*
 563          * Check for the WAIT_FOREVER case - defined by the ACPI spec to be
 564          * 0xFFFF or greater
 565          */
 566         if (((ArgNode->Asl.ParseOpcode == PARSEOP_WORDCONST) ||
 567              (ArgNode->Asl.ParseOpcode == PARSEOP_INTEGER))  &&
 568              (ArgNode->Asl.Value.Integer >= (UINT64) ACPI_WAIT_FOREVER))
 569         {
 570             break;
 571         }
 572
 573         /*
 574          * The operation could timeout. If the return value is not used
 575          * (indicates timeout occurred), issue a warning
 576          */
 577         if (!AnIsResultUsed (Op))
 578         {
 579             AslError (ASL_WARNING, ASL_MSG_TIMEOUT, ArgNode,
 580                 Op->Asl.ExternalName);
 581         }
 582         break;
 583
 584     case PARSEOP_CREATEFIELD:
 585         /*
 586          * Check for a zero Length (NumBits) operand. NumBits is the 3rd operand
 587          */
 588         ArgNode = Op->Asl.Child;
 589         ArgNode = ArgNode->Asl.Next;
 590         ArgNode = ArgNode->Asl.Next;
 591
 592         if ((ArgNode->Asl.ParseOpcode == PARSEOP_ZERO) ||
 593            ((ArgNode->Asl.ParseOpcode == PARSEOP_INTEGER) &&
 594             (ArgNode->Asl.Value.Integer == 0)))
 595         {
 596             AslError (ASL_ERROR, ASL_MSG_NON_ZERO, ArgNode, NULL);
 597         }
 598         break;
 599
 600     case PARSEOP_CONNECTION:
 601         /*
 602          * Ensure that the referenced operation region has the correct SPACE_ID.
 603          * From the grammar/parser, we know the parent is a FIELD definition.
 604          */
 605         ArgNode = Op->Asl.Parent;       /* Field definition */
 606         ArgNode = ArgNode->Asl.Child;   /* First child is the OpRegion Name */
 607         Node = ArgNode->Asl.Node;       /* OpRegion namespace node */
 608         if (!Node)
 609         {
 610             break;
 611         }
 612
 613         ArgNode = Node->Op;             /* OpRegion definition */
 614         ArgNode = ArgNode->Asl.Child;   /* First child is the OpRegion Name */
 615         ArgNode = ArgNode->Asl.Next;    /* Next peer is the SPACE_ID (what we want) */
 616
 617         /*
 618          * The Connection() operator is only valid for the following operation
 619          * region SpaceIds: GeneralPurposeIo and GenericSerialBus.
 620          */
 621         if ((ArgNode->Asl.Value.Integer != ACPI_ADR_SPACE_GPIO) &&
 622             (ArgNode->Asl.Value.Integer != ACPI_ADR_SPACE_GSBUS))
 623         {
 624             AslError (ASL_ERROR, ASL_MSG_CONNECTION_INVALID, Op, NULL);
 625         }
 626         break;
 627
 628     case PARSEOP_FIELD:
 629         /*
 630          * Ensure that fields for GeneralPurposeIo and GenericSerialBus
 631          * contain at least one Connection() operator
 632          */
 633         ArgNode = Op->Asl.Child;        /* 1st child is the OpRegion Name */
 634         Node = ArgNode->Asl.Node;       /* OpRegion namespace node */
 635         if (!Node)
 636         {
 637             break;
 638         }
 639
 640         ArgNode = Node->Op;             /* OpRegion definition */
 641         ArgNode = ArgNode->Asl.Child;   /* First child is the OpRegion Name */
 642         ArgNode = ArgNode->Asl.Next;    /* Next peer is the SPACE_ID (what we want) */
 643
 644         /* We are only interested in GeneralPurposeIo and GenericSerialBus */
 645
 646         if ((ArgNode->Asl.Value.Integer != ACPI_ADR_SPACE_GPIO) &&
 647             (ArgNode->Asl.Value.Integer != ACPI_ADR_SPACE_GSBUS))
 648         {
 649             break;
 650         }
 651
 652         ArgNode = Op->Asl.Child;        /* 1st child is the OpRegion Name */
 653         ArgNode = ArgNode->Asl.Next;    /* AccessType */
 654         ArgNode = ArgNode->Asl.Next;    /* LockRule */
 655         ArgNode = ArgNode->Asl.Next;    /* UpdateRule */
 656         ArgNode = ArgNode->Asl.Next;    /* Start of FieldUnitList */
 657
 658         /* Walk the FieldUnitList */
 659
 660         while (ArgNode)
 661         {
 662             if (ArgNode->Asl.ParseOpcode == PARSEOP_CONNECTION)
 663             {
 664                 break;
 665             }
 666             else if (ArgNode->Asl.ParseOpcode == PARSEOP_NAMESEG)
 667             {
 668                 AslError (ASL_ERROR, ASL_MSG_CONNECTION_MISSING, ArgNode, NULL);
 669                 break;
 670             }
 671
 672             ArgNode = ArgNode->Asl.Next;
 673         }
 674         break;
 675
 676     default:
 677
 678         break;
 679     }
 680
 681     return (AE_OK);
 682 }