String equality checking wrong - only checks 4 bytes?

[martin-hughes]

I haven't had a chance to fully investigate yet, but consider the following ASL:

DefinitionBlock("", "DSDT", 1, "RSACPI", "StrEqual", 1) {
    Method(MAIN, 0, NotSerialized) {
        Local0 = "Hello"
        Local1 = "Hellp"

        Return(Local0 == Local1)
    }
}

This test should pass - remember that a zero result indicates success - but it actually doesn't.

From a bit of playing, the parser seems to think (with the logic the correct way around again)

• "Hello" == "Hellp"
• "Hello" == "Hell",
• "Hello" != "Help"

Which leads me to think it's only comparing the first 4 bytes (or possibly "integer-size" number of bytes)

[martin-hughes]

Ah I think there's a conflict in the spec.

Looking at the 6.4 version of the spec:
19.6.69. LEqual (Logical Equal) says "For strings and buffers, True is returned only if both lengths are the same and the result of a byte-wise compare indicates exact equality"
(Version 6.6 of the spec has a similar statement)

But also in section 20:
DefLEqual := LequalOp Operand Operand, plus
Operand := TermArg => Integer

I can see you've gone for the section 20 one in the code, but that doesn't feel quite right - are you sure we shouldn't be doing the "proper" string comparison?

[martin-hughes]

If it helps sway you @IsaacWoods then uACPI does "proper" string matching (a code extract)

    if (lhs->type == UACPI_OBJECT_STRING || lhs->type == UACPI_OBJECT_BUFFER) {
        res = lhs->buffer->size == rhs->buffer->size;

        if (res && lhs->buffer->size) {
            res = uacpi_memcmp(
                lhs->buffer->data,
                rhs->buffer->data,
                lhs->buffer->size
            ) == 0;
        }
    }

[IsaacWoods]

Huh interesting. When I originally wrote this I did some cack-handed testing against the NT interpreter which I thought treated strings and buffers the same for all logical operations (and only tested the first 4 bytes), but if uACPI disagrees it'd probably be worth repeating that testing / doing what they do.

It would certainly feel nicer to do this properly, so let's implement the sane version of the spec here. This will unfortunately require reworking the logic for most of the logical ops (bar LAnd and LOr which uACPI agrees only tests against 4 bytes of a buffer/string).