1 /******************************************************************************
3 * Module Name: exconcat - Concatenate-type AML operators
5 *****************************************************************************/
7 /******************************************************************************
11 * Some or all of this work - Copyright (c) 1999 - 2017, Intel Corp.
12 * All rights reserved.
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights. You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code. No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
37 * The above copyright and patent license is granted only if the following
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision. In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change. Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee. Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution. In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
72 * 3.4. Intel retains all right, title, and interest in and to the Original
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
80 * 4. Disclaimer and Export Compliance
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
87 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
88 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
91 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
92 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
93 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
94 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
95 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
96 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
97 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
100 * 4.3. Licensee shall not export, either directly or indirectly, any of this
101 * software or system incorporating such software without first obtaining any
102 * required license or other approval from the U. S. Department of Commerce or
103 * any other agency or department of the United States Government. In the
104 * event Licensee exports any such software from the United States or
105 * re-exports any such software from a foreign destination, Licensee shall
106 * ensure that the distribution and export/re-export of the software is in
107 * compliance with all laws, regulations, orders, or other restrictions of the
108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
109 * any of its subsidiaries will export/re-export any technical data, process,
110 * software, or service, directly or indirectly, to any country for which the
111 * United States government or any agency thereof requires an export license,
112 * other governmental approval, or letter of assurance, without first obtaining
113 * such license, approval or letter.
115 *****************************************************************************
117 * Alternatively, you may choose to be licensed under the terms of the
120 * Redistribution and use in source and binary forms, with or without
121 * modification, are permitted provided that the following conditions
123 * 1. Redistributions of source code must retain the above copyright
124 * notice, this list of conditions, and the following disclaimer,
125 * without modification.
126 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
127 * substantially similar to the "NO WARRANTY" disclaimer below
128 * ("Disclaimer") and any redistribution must be conditioned upon
129 * including a substantially similar Disclaimer requirement for further
130 * binary redistribution.
131 * 3. Neither the names of the above-listed copyright holders nor the names
132 * of any contributors may be used to endorse or promote products derived
133 * from this software without specific prior written permission.
135 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
136 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
137 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
138 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
139 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
140 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
141 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
142 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
143 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
144 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
145 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
147 * Alternatively, you may choose to be licensed under the terms of the
148 * GNU General Public License ("GPL") version 2 as published by the Free
149 * Software Foundation.
151 *****************************************************************************/
154 #include "accommon.h"
155 #include "acinterp.h"
156 #include "amlresrc.h"
159 #define _COMPONENT ACPI_EXECUTER
160 ACPI_MODULE_NAME ("exconcat")
162 /* Local Prototypes */
165 AcpiExConvertToObjectTypeString (
166 ACPI_OPERAND_OBJECT
*ObjDesc
,
167 ACPI_OPERAND_OBJECT
**ResultDesc
);
170 /*******************************************************************************
172 * FUNCTION: AcpiExDoConcatenate
174 * PARAMETERS: Operand0 - First source object
175 * Operand1 - Second source object
176 * ActualReturnDesc - Where to place the return object
177 * WalkState - Current walk state
181 * DESCRIPTION: Concatenate two objects with the ACPI-defined conversion
182 * rules as necessary.
184 * Per the ACPI spec (up to 6.1), Concatenate only supports Integer,
185 * String, and Buffer objects. However, we support all objects here
186 * as an extension. This improves the usefulness of both Concatenate
187 * and the Printf/Fprintf macros. The extension returns a string
188 * describing the object type for the other objects.
191 ******************************************************************************/
194 AcpiExDoConcatenate (
195 ACPI_OPERAND_OBJECT
*Operand0
,
196 ACPI_OPERAND_OBJECT
*Operand1
,
197 ACPI_OPERAND_OBJECT
**ActualReturnDesc
,
198 ACPI_WALK_STATE
*WalkState
)
200 ACPI_OPERAND_OBJECT
*LocalOperand0
= Operand0
;
201 ACPI_OPERAND_OBJECT
*LocalOperand1
= Operand1
;
202 ACPI_OPERAND_OBJECT
*TempOperand1
= NULL
;
203 ACPI_OPERAND_OBJECT
*ReturnDesc
;
205 ACPI_OBJECT_TYPE Operand0Type
;
206 ACPI_OBJECT_TYPE Operand1Type
;
210 ACPI_FUNCTION_TRACE (ExDoConcatenate
);
213 /* Operand 0 preprocessing */
215 switch (Operand0
->Common
.Type
)
217 case ACPI_TYPE_INTEGER
:
218 case ACPI_TYPE_STRING
:
219 case ACPI_TYPE_BUFFER
:
221 Operand0Type
= Operand0
->Common
.Type
;
226 /* For all other types, get the "object type" string */
228 Status
= AcpiExConvertToObjectTypeString (
229 Operand0
, &LocalOperand0
);
230 if (ACPI_FAILURE (Status
))
235 Operand0Type
= ACPI_TYPE_STRING
;
239 /* Operand 1 preprocessing */
241 switch (Operand1
->Common
.Type
)
243 case ACPI_TYPE_INTEGER
:
244 case ACPI_TYPE_STRING
:
245 case ACPI_TYPE_BUFFER
:
247 Operand1Type
= Operand1
->Common
.Type
;
252 /* For all other types, get the "object type" string */
254 Status
= AcpiExConvertToObjectTypeString (
255 Operand1
, &LocalOperand1
);
256 if (ACPI_FAILURE (Status
))
261 Operand1Type
= ACPI_TYPE_STRING
;
266 * Convert the second operand if necessary. The first operand (0)
267 * determines the type of the second operand (1) (See the Data Types
268 * section of the ACPI specification). Both object types are
269 * guaranteed to be either Integer/String/Buffer by the operand
270 * resolution mechanism.
272 switch (Operand0Type
)
274 case ACPI_TYPE_INTEGER
:
276 Status
= AcpiExConvertToInteger (LocalOperand1
, &TempOperand1
,
277 ACPI_IMPLICIT_CONVERSION
);
280 case ACPI_TYPE_BUFFER
:
282 Status
= AcpiExConvertToBuffer (LocalOperand1
, &TempOperand1
);
285 case ACPI_TYPE_STRING
:
287 switch (Operand1Type
)
289 case ACPI_TYPE_INTEGER
:
290 case ACPI_TYPE_STRING
:
291 case ACPI_TYPE_BUFFER
:
293 /* Other types have already been converted to string */
295 Status
= AcpiExConvertToString (
296 LocalOperand1
, &TempOperand1
, ACPI_IMPLICIT_CONVERT_HEX
);
308 ACPI_ERROR ((AE_INFO
, "Invalid object type: 0x%X",
309 Operand0
->Common
.Type
));
310 Status
= AE_AML_INTERNAL
;
313 if (ACPI_FAILURE (Status
))
318 /* Take care with any newly created operand objects */
320 if ((LocalOperand1
!= Operand1
) &&
321 (LocalOperand1
!= TempOperand1
))
323 AcpiUtRemoveReference (LocalOperand1
);
326 LocalOperand1
= TempOperand1
;
329 * Both operands are now known to be the same object type
330 * (Both are Integer, String, or Buffer), and we can now perform
333 * There are three cases to handle, as per the ACPI spec:
335 * 1) Two Integers concatenated to produce a new Buffer
336 * 2) Two Strings concatenated to produce a new String
337 * 3) Two Buffers concatenated to produce a new Buffer
339 switch (Operand0Type
)
341 case ACPI_TYPE_INTEGER
:
343 /* Result of two Integers is a Buffer */
344 /* Need enough buffer space for two integers */
346 ReturnDesc
= AcpiUtCreateBufferObject (
347 (ACPI_SIZE
) ACPI_MUL_2 (AcpiGbl_IntegerByteWidth
));
350 Status
= AE_NO_MEMORY
;
354 Buffer
= (char *) ReturnDesc
->Buffer
.Pointer
;
356 /* Copy the first integer, LSB first */
358 memcpy (Buffer
, &Operand0
->Integer
.Value
,
359 AcpiGbl_IntegerByteWidth
);
361 /* Copy the second integer (LSB first) after the first */
363 memcpy (Buffer
+ AcpiGbl_IntegerByteWidth
,
364 &LocalOperand1
->Integer
.Value
, AcpiGbl_IntegerByteWidth
);
367 case ACPI_TYPE_STRING
:
369 /* Result of two Strings is a String */
371 ReturnDesc
= AcpiUtCreateStringObject (
372 ((ACPI_SIZE
) LocalOperand0
->String
.Length
+
373 LocalOperand1
->String
.Length
));
376 Status
= AE_NO_MEMORY
;
380 Buffer
= ReturnDesc
->String
.Pointer
;
382 /* Concatenate the strings */
384 strcpy (Buffer
, LocalOperand0
->String
.Pointer
);
385 strcat (Buffer
, LocalOperand1
->String
.Pointer
);
388 case ACPI_TYPE_BUFFER
:
390 /* Result of two Buffers is a Buffer */
392 ReturnDesc
= AcpiUtCreateBufferObject (
393 ((ACPI_SIZE
) Operand0
->Buffer
.Length
+
394 LocalOperand1
->Buffer
.Length
));
397 Status
= AE_NO_MEMORY
;
401 Buffer
= (char *) ReturnDesc
->Buffer
.Pointer
;
403 /* Concatenate the buffers */
405 memcpy (Buffer
, Operand0
->Buffer
.Pointer
,
406 Operand0
->Buffer
.Length
);
407 memcpy (Buffer
+ Operand0
->Buffer
.Length
,
408 LocalOperand1
->Buffer
.Pointer
,
409 LocalOperand1
->Buffer
.Length
);
414 /* Invalid object type, should not happen here */
416 ACPI_ERROR ((AE_INFO
, "Invalid object type: 0x%X",
417 Operand0
->Common
.Type
));
418 Status
= AE_AML_INTERNAL
;
422 *ActualReturnDesc
= ReturnDesc
;
425 if (LocalOperand0
!= Operand0
)
427 AcpiUtRemoveReference (LocalOperand0
);
430 if (LocalOperand1
!= Operand1
)
432 AcpiUtRemoveReference (LocalOperand1
);
435 return_ACPI_STATUS (Status
);
439 /*******************************************************************************
441 * FUNCTION: AcpiExConvertToObjectTypeString
443 * PARAMETERS: ObjDesc - Object to be converted
444 * ReturnDesc - Where to place the return object
448 * DESCRIPTION: Convert an object of arbitrary type to a string object that
449 * contains the namestring for the object. Used for the
450 * concatenate operator.
452 ******************************************************************************/
455 AcpiExConvertToObjectTypeString (
456 ACPI_OPERAND_OBJECT
*ObjDesc
,
457 ACPI_OPERAND_OBJECT
**ResultDesc
)
459 ACPI_OPERAND_OBJECT
*ReturnDesc
;
460 const char *TypeString
;
463 TypeString
= AcpiUtGetTypeName (ObjDesc
->Common
.Type
);
465 ReturnDesc
= AcpiUtCreateStringObject (
466 ((ACPI_SIZE
) strlen (TypeString
) + 9)); /* 9 For "[ Object]" */
469 return (AE_NO_MEMORY
);
472 strcpy (ReturnDesc
->String
.Pointer
, "[");
473 strcat (ReturnDesc
->String
.Pointer
, TypeString
);
474 strcat (ReturnDesc
->String
.Pointer
, " Object]");
476 *ResultDesc
= ReturnDesc
;
481 /*******************************************************************************
483 * FUNCTION: AcpiExConcatTemplate
485 * PARAMETERS: Operand0 - First source object
486 * Operand1 - Second source object
487 * ActualReturnDesc - Where to place the return object
488 * WalkState - Current walk state
492 * DESCRIPTION: Concatenate two resource templates
494 ******************************************************************************/
497 AcpiExConcatTemplate (
498 ACPI_OPERAND_OBJECT
*Operand0
,
499 ACPI_OPERAND_OBJECT
*Operand1
,
500 ACPI_OPERAND_OBJECT
**ActualReturnDesc
,
501 ACPI_WALK_STATE
*WalkState
)
504 ACPI_OPERAND_OBJECT
*ReturnDesc
;
512 ACPI_FUNCTION_TRACE (ExConcatTemplate
);
516 * Find the EndTag descriptor in each resource template.
517 * Note1: returned pointers point TO the EndTag, not past it.
518 * Note2: zero-length buffers are allowed; treated like one EndTag
521 /* Get the length of the first resource template */
523 Status
= AcpiUtGetResourceEndTag (Operand0
, &EndTag
);
524 if (ACPI_FAILURE (Status
))
526 return_ACPI_STATUS (Status
);
529 Length0
= ACPI_PTR_DIFF (EndTag
, Operand0
->Buffer
.Pointer
);
531 /* Get the length of the second resource template */
533 Status
= AcpiUtGetResourceEndTag (Operand1
, &EndTag
);
534 if (ACPI_FAILURE (Status
))
536 return_ACPI_STATUS (Status
);
539 Length1
= ACPI_PTR_DIFF (EndTag
, Operand1
->Buffer
.Pointer
);
541 /* Combine both lengths, minimum size will be 2 for EndTag */
543 NewLength
= Length0
+ Length1
+ sizeof (AML_RESOURCE_END_TAG
);
545 /* Create a new buffer object for the result (with one EndTag) */
547 ReturnDesc
= AcpiUtCreateBufferObject (NewLength
);
550 return_ACPI_STATUS (AE_NO_MEMORY
);
554 * Copy the templates to the new buffer, 0 first, then 1 follows. One
555 * EndTag descriptor is copied from Operand1.
557 NewBuf
= ReturnDesc
->Buffer
.Pointer
;
558 memcpy (NewBuf
, Operand0
->Buffer
.Pointer
, Length0
);
559 memcpy (NewBuf
+ Length0
, Operand1
->Buffer
.Pointer
, Length1
);
561 /* Insert EndTag and set the checksum to zero, means "ignore checksum" */
563 NewBuf
[NewLength
- 1] = 0;
564 NewBuf
[NewLength
- 2] = ACPI_RESOURCE_NAME_END_TAG
| 1;
566 /* Return the completed resource template */
568 *ActualReturnDesc
= ReturnDesc
;
569 return_ACPI_STATUS (AE_OK
);