1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2/******************************************************************************
3 *
4 * Module Name: exconcat - Concatenate-type AML operators
5 *
6 * Copyright (C) 2000 - 2025, Intel Corp.
7 *
8 *****************************************************************************/
9
10#include <acpi/acpi.h>
11#include "accommon.h"
12#include "acinterp.h"
13#include "amlresrc.h"
14
15#define _COMPONENT ACPI_EXECUTER
16ACPI_MODULE_NAME("exconcat")
17
18/* Local Prototypes */
19static acpi_status
20acpi_ex_convert_to_object_type_string(union acpi_operand_object *obj_desc,
21 union acpi_operand_object **result_desc);
22
23/*******************************************************************************
24 *
25 * FUNCTION: acpi_ex_do_concatenate
26 *
27 * PARAMETERS: operand0 - First source object
28 * operand1 - Second source object
29 * actual_return_desc - Where to place the return object
30 * walk_state - Current walk state
31 *
32 * RETURN: Status
33 *
34 * DESCRIPTION: Concatenate two objects with the ACPI-defined conversion
35 * rules as necessary.
36 * NOTE:
37 * Per the ACPI spec (up to 6.1), Concatenate only supports Integer,
38 * String, and Buffer objects. However, we support all objects here
39 * as an extension. This improves the usefulness of both Concatenate
40 * and the Printf/Fprintf macros. The extension returns a string
41 * describing the object type for the other objects.
42 * 02/2016.
43 *
44 ******************************************************************************/
45
46acpi_status
47acpi_ex_do_concatenate(union acpi_operand_object *operand0,
48 union acpi_operand_object *operand1,
49 union acpi_operand_object **actual_return_desc,
50 struct acpi_walk_state *walk_state)
51{
52 union acpi_operand_object *local_operand0 = operand0;
53 union acpi_operand_object *local_operand1 = operand1;
54 union acpi_operand_object *temp_operand1 = NULL;
55 union acpi_operand_object *return_desc;
56 char *buffer;
57 acpi_object_type operand0_type;
58 acpi_object_type operand1_type;
59 acpi_status status;
60
61 ACPI_FUNCTION_TRACE(ex_do_concatenate);
62
63 /* Operand 0 preprocessing */
64
65 switch (operand0->common.type) {
66 case ACPI_TYPE_INTEGER:
67 case ACPI_TYPE_STRING:
68 case ACPI_TYPE_BUFFER:
69
70 operand0_type = operand0->common.type;
71 break;
72
73 default:
74
75 /* For all other types, get the "object type" string */
76
77 status =
78 acpi_ex_convert_to_object_type_string(obj_desc: operand0,
79 result_desc: &local_operand0);
80 if (ACPI_FAILURE(status)) {
81 goto cleanup;
82 }
83
84 operand0_type = ACPI_TYPE_STRING;
85 break;
86 }
87
88 /* Operand 1 preprocessing */
89
90 switch (operand1->common.type) {
91 case ACPI_TYPE_INTEGER:
92 case ACPI_TYPE_STRING:
93 case ACPI_TYPE_BUFFER:
94
95 operand1_type = operand1->common.type;
96 break;
97
98 default:
99
100 /* For all other types, get the "object type" string */
101
102 status =
103 acpi_ex_convert_to_object_type_string(obj_desc: operand1,
104 result_desc: &local_operand1);
105 if (ACPI_FAILURE(status)) {
106 goto cleanup;
107 }
108
109 operand1_type = ACPI_TYPE_STRING;
110 break;
111 }
112
113 /*
114 * Convert the second operand if necessary. The first operand (0)
115 * determines the type of the second operand (1) (See the Data Types
116 * section of the ACPI specification). Both object types are
117 * guaranteed to be either Integer/String/Buffer by the operand
118 * resolution mechanism.
119 */
120 switch (operand0_type) {
121 case ACPI_TYPE_INTEGER:
122
123 status =
124 acpi_ex_convert_to_integer(obj_desc: local_operand1, result_desc: &temp_operand1,
125 ACPI_IMPLICIT_CONVERSION);
126 break;
127
128 case ACPI_TYPE_BUFFER:
129
130 status =
131 acpi_ex_convert_to_buffer(obj_desc: local_operand1, result_desc: &temp_operand1);
132 break;
133
134 case ACPI_TYPE_STRING:
135
136 switch (operand1_type) {
137 case ACPI_TYPE_INTEGER:
138 case ACPI_TYPE_STRING:
139 case ACPI_TYPE_BUFFER:
140
141 /* Other types have already been converted to string */
142
143 status =
144 acpi_ex_convert_to_string(obj_desc: local_operand1,
145 result_desc: &temp_operand1,
146 ACPI_IMPLICIT_CONVERT_HEX);
147 break;
148
149 default:
150
151 status = AE_OK;
152 break;
153 }
154 break;
155
156 default:
157
158 ACPI_ERROR((AE_INFO, "Invalid object type: 0x%X",
159 operand0->common.type));
160 status = AE_AML_INTERNAL;
161 }
162
163 if (ACPI_FAILURE(status)) {
164 goto cleanup;
165 }
166
167 /* Take care with any newly created operand objects */
168
169 if ((local_operand1 != operand1) && (local_operand1 != temp_operand1)) {
170 acpi_ut_remove_reference(object: local_operand1);
171 }
172
173 local_operand1 = temp_operand1;
174
175 /*
176 * Both operands are now known to be the same object type
177 * (Both are Integer, String, or Buffer), and we can now perform
178 * the concatenation.
179 *
180 * There are three cases to handle, as per the ACPI spec:
181 *
182 * 1) Two Integers concatenated to produce a new Buffer
183 * 2) Two Strings concatenated to produce a new String
184 * 3) Two Buffers concatenated to produce a new Buffer
185 */
186 switch (operand0_type) {
187 case ACPI_TYPE_INTEGER:
188
189 /* Result of two Integers is a Buffer */
190 /* Need enough buffer space for two integers */
191
192 return_desc = acpi_ut_create_buffer_object(buffer_size: (acpi_size)
193 ACPI_MUL_2
194 (acpi_gbl_integer_byte_width));
195 if (!return_desc) {
196 status = AE_NO_MEMORY;
197 goto cleanup;
198 }
199
200 buffer = (char *)return_desc->buffer.pointer;
201
202 /* Copy the first integer, LSB first */
203
204 memcpy(to: buffer, from: &operand0->integer.value,
205 len: acpi_gbl_integer_byte_width);
206
207 /* Copy the second integer (LSB first) after the first */
208
209 memcpy(to: buffer + acpi_gbl_integer_byte_width,
210 from: &local_operand1->integer.value,
211 len: acpi_gbl_integer_byte_width);
212 break;
213
214 case ACPI_TYPE_STRING:
215
216 /* Result of two Strings is a String */
217
218 return_desc = acpi_ut_create_string_object(string_size: ((acpi_size)
219 local_operand0->
220 string.length +
221 local_operand1->
222 string.length));
223 if (!return_desc) {
224 status = AE_NO_MEMORY;
225 goto cleanup;
226 }
227
228 buffer = return_desc->string.pointer;
229
230 /* Concatenate the strings */
231
232 strcpy(buffer, local_operand0->string.pointer);
233 strcat(buffer, local_operand1->string.pointer);
234 break;
235
236 case ACPI_TYPE_BUFFER:
237
238 /* Result of two Buffers is a Buffer */
239
240 return_desc = acpi_ut_create_buffer_object(buffer_size: ((acpi_size)
241 operand0->buffer.
242 length +
243 local_operand1->
244 buffer.length));
245 if (!return_desc) {
246 status = AE_NO_MEMORY;
247 goto cleanup;
248 }
249
250 buffer = (char *)return_desc->buffer.pointer;
251
252 /* Concatenate the buffers */
253
254 memcpy(to: buffer, from: operand0->buffer.pointer,
255 len: operand0->buffer.length);
256 memcpy(to: buffer + operand0->buffer.length,
257 from: local_operand1->buffer.pointer,
258 len: local_operand1->buffer.length);
259 break;
260
261 default:
262
263 /* Invalid object type, should not happen here */
264
265 ACPI_ERROR((AE_INFO, "Invalid object type: 0x%X",
266 operand0->common.type));
267 status = AE_AML_INTERNAL;
268 goto cleanup;
269 }
270
271 *actual_return_desc = return_desc;
272
273cleanup:
274 if (local_operand0 != operand0) {
275 acpi_ut_remove_reference(object: local_operand0);
276 }
277
278 if (local_operand1 != operand1) {
279 acpi_ut_remove_reference(object: local_operand1);
280 }
281
282 return_ACPI_STATUS(status);
283}
284
285/*******************************************************************************
286 *
287 * FUNCTION: acpi_ex_convert_to_object_type_string
288 *
289 * PARAMETERS: obj_desc - Object to be converted
290 * return_desc - Where to place the return object
291 *
292 * RETURN: Status
293 *
294 * DESCRIPTION: Convert an object of arbitrary type to a string object that
295 * contains the namestring for the object. Used for the
296 * concatenate operator.
297 *
298 ******************************************************************************/
299
300static acpi_status
301acpi_ex_convert_to_object_type_string(union acpi_operand_object *obj_desc,
302 union acpi_operand_object **result_desc)
303{
304 union acpi_operand_object *return_desc;
305 const char *type_string;
306
307 type_string = acpi_ut_get_type_name(type: obj_desc->common.type);
308
309 return_desc = acpi_ut_create_string_object(string_size: ((acpi_size)strlen(type_string) + 9)); /* 9 For "[ Object]" */
310 if (!return_desc) {
311 return (AE_NO_MEMORY);
312 }
313
314 strcpy(return_desc->string.pointer, "[");
315 strcat(return_desc->string.pointer, type_string);
316 strcat(return_desc->string.pointer, " Object]");
317
318 *result_desc = return_desc;
319 return (AE_OK);
320}
321
322/*******************************************************************************
323 *
324 * FUNCTION: acpi_ex_concat_template
325 *
326 * PARAMETERS: operand0 - First source object
327 * operand1 - Second source object
328 * actual_return_desc - Where to place the return object
329 * walk_state - Current walk state
330 *
331 * RETURN: Status
332 *
333 * DESCRIPTION: Concatenate two resource templates
334 *
335 ******************************************************************************/
336
337acpi_status
338acpi_ex_concat_template(union acpi_operand_object *operand0,
339 union acpi_operand_object *operand1,
340 union acpi_operand_object **actual_return_desc,
341 struct acpi_walk_state *walk_state)
342{
343 acpi_status status;
344 union acpi_operand_object *return_desc;
345 u8 *new_buf;
346 u8 *end_tag;
347 acpi_size length0;
348 acpi_size length1;
349 acpi_size new_length;
350
351 ACPI_FUNCTION_TRACE(ex_concat_template);
352
353 /*
354 * Find the end_tag descriptor in each resource template.
355 * Note1: returned pointers point TO the end_tag, not past it.
356 * Note2: zero-length buffers are allowed; treated like one end_tag
357 */
358
359 /* Get the length of the first resource template */
360
361 status = acpi_ut_get_resource_end_tag(obj_desc: operand0, end_tag: &end_tag);
362 if (ACPI_FAILURE(status)) {
363 return_ACPI_STATUS(status);
364 }
365
366 length0 = ACPI_PTR_DIFF(end_tag, operand0->buffer.pointer);
367
368 /* Get the length of the second resource template */
369
370 status = acpi_ut_get_resource_end_tag(obj_desc: operand1, end_tag: &end_tag);
371 if (ACPI_FAILURE(status)) {
372 return_ACPI_STATUS(status);
373 }
374
375 length1 = ACPI_PTR_DIFF(end_tag, operand1->buffer.pointer);
376
377 /* Combine both lengths, minimum size will be 2 for end_tag */
378
379 new_length = length0 + length1 + sizeof(struct aml_resource_end_tag);
380
381 /* Create a new buffer object for the result (with one end_tag) */
382
383 return_desc = acpi_ut_create_buffer_object(buffer_size: new_length);
384 if (!return_desc) {
385 return_ACPI_STATUS(AE_NO_MEMORY);
386 }
387
388 /*
389 * Copy the templates to the new buffer, 0 first, then 1 follows. One
390 * end_tag descriptor is copied from Operand1.
391 */
392 new_buf = return_desc->buffer.pointer;
393 memcpy(to: new_buf, from: operand0->buffer.pointer, len: length0);
394 memcpy(to: new_buf + length0, from: operand1->buffer.pointer, len: length1);
395
396 /* Insert end_tag and set the checksum to zero, means "ignore checksum" */
397
398 new_buf[new_length - 1] = 0;
399 new_buf[new_length - 2] = ACPI_RESOURCE_NAME_END_TAG | 1;
400
401 /* Return the completed resource template */
402
403 *actual_return_desc = return_desc;
404 return_ACPI_STATUS(AE_OK);
405}
406