1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
3 *
4 * Module Name: exmisc - ACPI AML (p-code) execution - specific opcodes
5 *
6 * Copyright (C) 2000 - 2019, Intel Corp.
7 *
8 *****************************************************************************/
9
10 #include <acpi/acpi.h>
11 #include "accommon.h"
12 #include "acinterp.h"
13 #include "amlcode.h"
14
15 #define _COMPONENT ACPI_EXECUTER
16 ACPI_MODULE_NAME("exmisc")
17
18 /*******************************************************************************
19 *
20 * FUNCTION: acpi_ex_get_object_reference
21 *
22 * PARAMETERS: obj_desc - Create a reference to this object
23 * return_desc - Where to store the reference
24 * walk_state - Current state
25 *
26 * RETURN: Status
27 *
28 * DESCRIPTION: Obtain and return a "reference" to the target object
29 * Common code for the ref_of_op and the cond_ref_of_op.
30 *
31 ******************************************************************************/
32 acpi_status
acpi_ex_get_object_reference(union acpi_operand_object * obj_desc,union acpi_operand_object ** return_desc,struct acpi_walk_state * walk_state)33 acpi_ex_get_object_reference(union acpi_operand_object *obj_desc,
34 union acpi_operand_object **return_desc,
35 struct acpi_walk_state *walk_state)
36 {
37 union acpi_operand_object *reference_obj;
38 union acpi_operand_object *referenced_obj;
39
40 ACPI_FUNCTION_TRACE_PTR(ex_get_object_reference, obj_desc);
41
42 *return_desc = NULL;
43
44 switch (ACPI_GET_DESCRIPTOR_TYPE(obj_desc)) {
45 case ACPI_DESC_TYPE_OPERAND:
46
47 if (obj_desc->common.type != ACPI_TYPE_LOCAL_REFERENCE) {
48 return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
49 }
50
51 /*
52 * Must be a reference to a Local or Arg
53 */
54 switch (obj_desc->reference.class) {
55 case ACPI_REFCLASS_LOCAL:
56 case ACPI_REFCLASS_ARG:
57 case ACPI_REFCLASS_DEBUG:
58
59 /* The referenced object is the pseudo-node for the local/arg */
60
61 referenced_obj = obj_desc->reference.object;
62 break;
63
64 default:
65
66 ACPI_ERROR((AE_INFO, "Invalid Reference Class 0x%2.2X",
67 obj_desc->reference.class));
68 return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
69 }
70 break;
71
72 case ACPI_DESC_TYPE_NAMED:
73 /*
74 * A named reference that has already been resolved to a Node
75 */
76 referenced_obj = obj_desc;
77 break;
78
79 default:
80
81 ACPI_ERROR((AE_INFO, "Invalid descriptor type 0x%X",
82 ACPI_GET_DESCRIPTOR_TYPE(obj_desc)));
83 return_ACPI_STATUS(AE_TYPE);
84 }
85
86 /* Create a new reference object */
87
88 reference_obj =
89 acpi_ut_create_internal_object(ACPI_TYPE_LOCAL_REFERENCE);
90 if (!reference_obj) {
91 return_ACPI_STATUS(AE_NO_MEMORY);
92 }
93
94 reference_obj->reference.class = ACPI_REFCLASS_REFOF;
95 reference_obj->reference.object = referenced_obj;
96 *return_desc = reference_obj;
97
98 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
99 "Object %p Type [%s], returning Reference %p\n",
100 obj_desc, acpi_ut_get_object_type_name(obj_desc),
101 *return_desc));
102
103 return_ACPI_STATUS(AE_OK);
104 }
105
106 /*******************************************************************************
107 *
108 * FUNCTION: acpi_ex_do_math_op
109 *
110 * PARAMETERS: opcode - AML opcode
111 * integer0 - Integer operand #0
112 * integer1 - Integer operand #1
113 *
114 * RETURN: Integer result of the operation
115 *
116 * DESCRIPTION: Execute a math AML opcode. The purpose of having all of the
117 * math functions here is to prevent a lot of pointer dereferencing
118 * to obtain the operands.
119 *
120 ******************************************************************************/
121
acpi_ex_do_math_op(u16 opcode,u64 integer0,u64 integer1)122 u64 acpi_ex_do_math_op(u16 opcode, u64 integer0, u64 integer1)
123 {
124
125 ACPI_FUNCTION_ENTRY();
126
127 switch (opcode) {
128 case AML_ADD_OP: /* Add (Integer0, Integer1, Result) */
129
130 return (integer0 + integer1);
131
132 case AML_BIT_AND_OP: /* And (Integer0, Integer1, Result) */
133
134 return (integer0 & integer1);
135
136 case AML_BIT_NAND_OP: /* NAnd (Integer0, Integer1, Result) */
137
138 return (~(integer0 & integer1));
139
140 case AML_BIT_OR_OP: /* Or (Integer0, Integer1, Result) */
141
142 return (integer0 | integer1);
143
144 case AML_BIT_NOR_OP: /* NOr (Integer0, Integer1, Result) */
145
146 return (~(integer0 | integer1));
147
148 case AML_BIT_XOR_OP: /* XOr (Integer0, Integer1, Result) */
149
150 return (integer0 ^ integer1);
151
152 case AML_MULTIPLY_OP: /* Multiply (Integer0, Integer1, Result) */
153
154 return (integer0 * integer1);
155
156 case AML_SHIFT_LEFT_OP: /* shift_left (Operand, shift_count, Result) */
157
158 /*
159 * We need to check if the shiftcount is larger than the integer bit
160 * width since the behavior of this is not well-defined in the C language.
161 */
162 if (integer1 >= acpi_gbl_integer_bit_width) {
163 return (0);
164 }
165 return (integer0 << integer1);
166
167 case AML_SHIFT_RIGHT_OP: /* shift_right (Operand, shift_count, Result) */
168
169 /*
170 * We need to check if the shiftcount is larger than the integer bit
171 * width since the behavior of this is not well-defined in the C language.
172 */
173 if (integer1 >= acpi_gbl_integer_bit_width) {
174 return (0);
175 }
176 return (integer0 >> integer1);
177
178 case AML_SUBTRACT_OP: /* Subtract (Integer0, Integer1, Result) */
179
180 return (integer0 - integer1);
181
182 default:
183
184 return (0);
185 }
186 }
187
188 /*******************************************************************************
189 *
190 * FUNCTION: acpi_ex_do_logical_numeric_op
191 *
192 * PARAMETERS: opcode - AML opcode
193 * integer0 - Integer operand #0
194 * integer1 - Integer operand #1
195 * logical_result - TRUE/FALSE result of the operation
196 *
197 * RETURN: Status
198 *
199 * DESCRIPTION: Execute a logical "Numeric" AML opcode. For these Numeric
200 * operators (LAnd and LOr), both operands must be integers.
201 *
202 * Note: cleanest machine code seems to be produced by the code
203 * below, rather than using statements of the form:
204 * Result = (Integer0 && Integer1);
205 *
206 ******************************************************************************/
207
208 acpi_status
acpi_ex_do_logical_numeric_op(u16 opcode,u64 integer0,u64 integer1,u8 * logical_result)209 acpi_ex_do_logical_numeric_op(u16 opcode,
210 u64 integer0, u64 integer1, u8 *logical_result)
211 {
212 acpi_status status = AE_OK;
213 u8 local_result = FALSE;
214
215 ACPI_FUNCTION_TRACE(ex_do_logical_numeric_op);
216
217 switch (opcode) {
218 case AML_LOGICAL_AND_OP: /* LAnd (Integer0, Integer1) */
219
220 if (integer0 && integer1) {
221 local_result = TRUE;
222 }
223 break;
224
225 case AML_LOGICAL_OR_OP: /* LOr (Integer0, Integer1) */
226
227 if (integer0 || integer1) {
228 local_result = TRUE;
229 }
230 break;
231
232 default:
233
234 ACPI_ERROR((AE_INFO,
235 "Invalid numeric logical opcode: %X", opcode));
236 status = AE_AML_INTERNAL;
237 break;
238 }
239
240 /* Return the logical result and status */
241
242 *logical_result = local_result;
243 return_ACPI_STATUS(status);
244 }
245
246 /*******************************************************************************
247 *
248 * FUNCTION: acpi_ex_do_logical_op
249 *
250 * PARAMETERS: opcode - AML opcode
251 * operand0 - operand #0
252 * operand1 - operand #1
253 * logical_result - TRUE/FALSE result of the operation
254 *
255 * RETURN: Status
256 *
257 * DESCRIPTION: Execute a logical AML opcode. The purpose of having all of the
258 * functions here is to prevent a lot of pointer dereferencing
259 * to obtain the operands and to simplify the generation of the
260 * logical value. For the Numeric operators (LAnd and LOr), both
261 * operands must be integers. For the other logical operators,
262 * operands can be any combination of Integer/String/Buffer. The
263 * first operand determines the type to which the second operand
264 * will be converted.
265 *
266 * Note: cleanest machine code seems to be produced by the code
267 * below, rather than using statements of the form:
268 * Result = (Operand0 == Operand1);
269 *
270 ******************************************************************************/
271
272 acpi_status
acpi_ex_do_logical_op(u16 opcode,union acpi_operand_object * operand0,union acpi_operand_object * operand1,u8 * logical_result)273 acpi_ex_do_logical_op(u16 opcode,
274 union acpi_operand_object *operand0,
275 union acpi_operand_object *operand1, u8 * logical_result)
276 {
277 union acpi_operand_object *local_operand1 = operand1;
278 u64 integer0;
279 u64 integer1;
280 u32 length0;
281 u32 length1;
282 acpi_status status = AE_OK;
283 u8 local_result = FALSE;
284 int compare;
285
286 ACPI_FUNCTION_TRACE(ex_do_logical_op);
287
288 /*
289 * Convert the second operand if necessary. The first operand
290 * determines the type of the second operand, (See the Data Types
291 * section of the ACPI 3.0+ specification.) Both object types are
292 * guaranteed to be either Integer/String/Buffer by the operand
293 * resolution mechanism.
294 */
295 switch (operand0->common.type) {
296 case ACPI_TYPE_INTEGER:
297
298 status = acpi_ex_convert_to_integer(operand1, &local_operand1,
299 ACPI_IMPLICIT_CONVERSION);
300 break;
301
302 case ACPI_TYPE_STRING:
303
304 status =
305 acpi_ex_convert_to_string(operand1, &local_operand1,
306 ACPI_IMPLICIT_CONVERT_HEX);
307 break;
308
309 case ACPI_TYPE_BUFFER:
310
311 status = acpi_ex_convert_to_buffer(operand1, &local_operand1);
312 break;
313
314 default:
315
316 ACPI_ERROR((AE_INFO,
317 "Invalid object type for logical operator: %X",
318 operand0->common.type));
319 status = AE_AML_INTERNAL;
320 break;
321 }
322
323 if (ACPI_FAILURE(status)) {
324 goto cleanup;
325 }
326
327 /*
328 * Two cases: 1) Both Integers, 2) Both Strings or Buffers
329 */
330 if (operand0->common.type == ACPI_TYPE_INTEGER) {
331 /*
332 * 1) Both operands are of type integer
333 * Note: local_operand1 may have changed above
334 */
335 integer0 = operand0->integer.value;
336 integer1 = local_operand1->integer.value;
337
338 switch (opcode) {
339 case AML_LOGICAL_EQUAL_OP: /* LEqual (Operand0, Operand1) */
340
341 if (integer0 == integer1) {
342 local_result = TRUE;
343 }
344 break;
345
346 case AML_LOGICAL_GREATER_OP: /* LGreater (Operand0, Operand1) */
347
348 if (integer0 > integer1) {
349 local_result = TRUE;
350 }
351 break;
352
353 case AML_LOGICAL_LESS_OP: /* LLess (Operand0, Operand1) */
354
355 if (integer0 < integer1) {
356 local_result = TRUE;
357 }
358 break;
359
360 default:
361
362 ACPI_ERROR((AE_INFO,
363 "Invalid comparison opcode: %X", opcode));
364 status = AE_AML_INTERNAL;
365 break;
366 }
367 } else {
368 /*
369 * 2) Both operands are Strings or both are Buffers
370 * Note: Code below takes advantage of common Buffer/String
371 * object fields. local_operand1 may have changed above. Use
372 * memcmp to handle nulls in buffers.
373 */
374 length0 = operand0->buffer.length;
375 length1 = local_operand1->buffer.length;
376
377 /* Lexicographic compare: compare the data bytes */
378
379 compare = memcmp(operand0->buffer.pointer,
380 local_operand1->buffer.pointer,
381 (length0 > length1) ? length1 : length0);
382
383 switch (opcode) {
384 case AML_LOGICAL_EQUAL_OP: /* LEqual (Operand0, Operand1) */
385
386 /* Length and all bytes must be equal */
387
388 if ((length0 == length1) && (compare == 0)) {
389
390 /* Length and all bytes match ==> TRUE */
391
392 local_result = TRUE;
393 }
394 break;
395
396 case AML_LOGICAL_GREATER_OP: /* LGreater (Operand0, Operand1) */
397
398 if (compare > 0) {
399 local_result = TRUE;
400 goto cleanup; /* TRUE */
401 }
402 if (compare < 0) {
403 goto cleanup; /* FALSE */
404 }
405
406 /* Bytes match (to shortest length), compare lengths */
407
408 if (length0 > length1) {
409 local_result = TRUE;
410 }
411 break;
412
413 case AML_LOGICAL_LESS_OP: /* LLess (Operand0, Operand1) */
414
415 if (compare > 0) {
416 goto cleanup; /* FALSE */
417 }
418 if (compare < 0) {
419 local_result = TRUE;
420 goto cleanup; /* TRUE */
421 }
422
423 /* Bytes match (to shortest length), compare lengths */
424
425 if (length0 < length1) {
426 local_result = TRUE;
427 }
428 break;
429
430 default:
431
432 ACPI_ERROR((AE_INFO,
433 "Invalid comparison opcode: %X", opcode));
434 status = AE_AML_INTERNAL;
435 break;
436 }
437 }
438
439 cleanup:
440
441 /* New object was created if implicit conversion performed - delete */
442
443 if (local_operand1 != operand1) {
444 acpi_ut_remove_reference(local_operand1);
445 }
446
447 /* Return the logical result and status */
448
449 *logical_result = local_result;
450 return_ACPI_STATUS(status);
451 }
452
