vasilito
cb424d7448
verify-patch-sanity.py validates every active recipe .patch has internally- consistent hunk line counts — catching the 'malformed patch at line N' failure at commit/CI/preflight time instead of hours into a cook. This cycle hit that class three times (qtwaylandscanner, sddm, xwayland), each only discovered when cookbook tried to apply the patch. Running it across the repo found 29 latent malformed patches (validated against GNU patch: e.g. relibc/P3-sysv-ipc reproduces 'malformed patch at line 22'). They were harmless only because they sit in vendored recipes (baked, not re- applied) — but would fail on any version-bump re-derivation. --fix recounts the hunk headers (body untouched) and repaired all 29. Wired into build-preflight.sh (Phase 1.0D) and redbear-ci.yml, with a unit test (test-patch-sanity.sh). Skips archived/legacy trees and unvalidatable formats (empty placeholders, bare-@@ git hunks).
339 lines
13 KiB
C
339 lines
13 KiB
C
//===- pdl.c - Test of PDL dialect C API ----------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM
|
|
// Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// RUN: mlir-capi-pdl-test 2>&1 | FileCheck %s
|
|
|
|
#include "mlir-c/Dialect/PDL.h"
|
|
#include "mlir-c/BuiltinTypes.h"
|
|
#include "mlir-c/IR.h"
|
|
|
|
#include <assert.h>
|
|
#include <inttypes.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
// CHECK-LABEL: testAttributeType
|
|
void testAttributeType(MlirContext ctx) {
|
|
fprintf(stderr, "testAttributeType\n");
|
|
|
|
MlirType parsedType = mlirTypeParseGet(
|
|
ctx, mlirStringRefCreateFromCString("!pdl.attribute"));
|
|
MlirType constructedType = mlirPDLAttributeTypeGet(ctx);
|
|
|
|
assert(!mlirTypeIsNull(parsedType) && "couldn't parse PDLAttributeType");
|
|
assert(!mlirTypeIsNull(constructedType) && "couldn't construct PDLAttributeType");
|
|
|
|
// CHECK: parsedType isa PDLType: 1
|
|
fprintf(stderr, "parsedType isa PDLType: %d\n",
|
|
mlirTypeIsAPDLType(parsedType));
|
|
// CHECK: parsedType isa PDLAttributeType: 1
|
|
fprintf(stderr, "parsedType isa PDLAttributeType: %d\n",
|
|
mlirTypeIsAPDLAttributeType(parsedType));
|
|
// CHECK: parsedType isa PDLOperationType: 0
|
|
fprintf(stderr, "parsedType isa PDLOperationType: %d\n",
|
|
mlirTypeIsAPDLOperationType(parsedType));
|
|
// CHECK: parsedType isa PDLRangeType: 0
|
|
fprintf(stderr, "parsedType isa PDLRangeType: %d\n",
|
|
mlirTypeIsAPDLRangeType(parsedType));
|
|
// CHECK: parsedType isa PDLTypeType: 0
|
|
fprintf(stderr, "parsedType isa PDLTypeType: %d\n",
|
|
mlirTypeIsAPDLTypeType(parsedType));
|
|
// CHECK: parsedType isa PDLValueType: 0
|
|
fprintf(stderr, "parsedType isa PDLValueType: %d\n",
|
|
mlirTypeIsAPDLValueType(parsedType));
|
|
|
|
// CHECK: constructedType isa PDLType: 1
|
|
fprintf(stderr, "constructedType isa PDLType: %d\n",
|
|
mlirTypeIsAPDLType(constructedType));
|
|
// CHECK: constructedType isa PDLAttributeType: 1
|
|
fprintf(stderr, "constructedType isa PDLAttributeType: %d\n",
|
|
mlirTypeIsAPDLAttributeType(constructedType));
|
|
// CHECK: constructedType isa PDLOperationType: 0
|
|
fprintf(stderr, "constructedType isa PDLOperationType: %d\n",
|
|
mlirTypeIsAPDLOperationType(constructedType));
|
|
// CHECK: constructedType isa PDLRangeType: 0
|
|
fprintf(stderr, "constructedType isa PDLRangeType: %d\n",
|
|
mlirTypeIsAPDLRangeType(constructedType));
|
|
// CHECK: constructedType isa PDLTypeType: 0
|
|
fprintf(stderr, "constructedType isa PDLTypeType: %d\n",
|
|
mlirTypeIsAPDLTypeType(constructedType));
|
|
// CHECK: constructedType isa PDLValueType: 0
|
|
fprintf(stderr, "constructedType isa PDLValueType: %d\n",
|
|
mlirTypeIsAPDLValueType(constructedType));
|
|
|
|
// CHECK: equal: 1
|
|
fprintf(stderr, "equal: %d\n", mlirTypeEqual(parsedType, constructedType));
|
|
|
|
// CHECK: !pdl.attribute
|
|
mlirTypeDump(parsedType);
|
|
// CHECK: !pdl.attribute
|
|
mlirTypeDump(constructedType);
|
|
|
|
fprintf(stderr, "\n\n");
|
|
}
|
|
|
|
// CHECK-LABEL: testOperationType
|
|
void testOperationType(MlirContext ctx) {
|
|
fprintf(stderr, "testOperationType\n");
|
|
|
|
MlirType parsedType = mlirTypeParseGet(
|
|
ctx, mlirStringRefCreateFromCString("!pdl.operation"));
|
|
MlirType constructedType = mlirPDLOperationTypeGet(ctx);
|
|
|
|
assert(!mlirTypeIsNull(parsedType) && "couldn't parse PDLAttributeType");
|
|
assert(!mlirTypeIsNull(constructedType) && "couldn't construct PDLAttributeType");
|
|
|
|
// CHECK: parsedType isa PDLType: 1
|
|
fprintf(stderr, "parsedType isa PDLType: %d\n",
|
|
mlirTypeIsAPDLType(parsedType));
|
|
// CHECK: parsedType isa PDLAttributeType: 0
|
|
fprintf(stderr, "parsedType isa PDLAttributeType: %d\n",
|
|
mlirTypeIsAPDLAttributeType(parsedType));
|
|
// CHECK: parsedType isa PDLOperationType: 1
|
|
fprintf(stderr, "parsedType isa PDLOperationType: %d\n",
|
|
mlirTypeIsAPDLOperationType(parsedType));
|
|
// CHECK: parsedType isa PDLRangeType: 0
|
|
fprintf(stderr, "parsedType isa PDLRangeType: %d\n",
|
|
mlirTypeIsAPDLRangeType(parsedType));
|
|
// CHECK: parsedType isa PDLTypeType: 0
|
|
fprintf(stderr, "parsedType isa PDLTypeType: %d\n",
|
|
mlirTypeIsAPDLTypeType(parsedType));
|
|
// CHECK: parsedType isa PDLValueType: 0
|
|
fprintf(stderr, "parsedType isa PDLValueType: %d\n",
|
|
mlirTypeIsAPDLValueType(parsedType));
|
|
|
|
// CHECK: constructedType isa PDLType: 1
|
|
fprintf(stderr, "constructedType isa PDLType: %d\n",
|
|
mlirTypeIsAPDLType(constructedType));
|
|
// CHECK: constructedType isa PDLAttributeType: 0
|
|
fprintf(stderr, "constructedType isa PDLAttributeType: %d\n",
|
|
mlirTypeIsAPDLAttributeType(constructedType));
|
|
// CHECK: constructedType isa PDLOperationType: 1
|
|
fprintf(stderr, "constructedType isa PDLOperationType: %d\n",
|
|
mlirTypeIsAPDLOperationType(constructedType));
|
|
// CHECK: constructedType isa PDLRangeType: 0
|
|
fprintf(stderr, "constructedType isa PDLRangeType: %d\n",
|
|
mlirTypeIsAPDLRangeType(constructedType));
|
|
// CHECK: constructedType isa PDLTypeType: 0
|
|
fprintf(stderr, "constructedType isa PDLTypeType: %d\n",
|
|
mlirTypeIsAPDLTypeType(constructedType));
|
|
// CHECK: constructedType isa PDLValueType: 0
|
|
fprintf(stderr, "constructedType isa PDLValueType: %d\n",
|
|
mlirTypeIsAPDLValueType(constructedType));
|
|
|
|
// CHECK: equal: 1
|
|
fprintf(stderr, "equal: %d\n", mlirTypeEqual(parsedType, constructedType));
|
|
|
|
// CHECK: !pdl.operation
|
|
mlirTypeDump(parsedType);
|
|
// CHECK: !pdl.operation
|
|
mlirTypeDump(constructedType);
|
|
|
|
fprintf(stderr, "\n\n");
|
|
}
|
|
|
|
// CHECK-LABEL: testRangeType
|
|
void testRangeType(MlirContext ctx) {
|
|
fprintf(stderr, "testRangeType\n");
|
|
|
|
MlirType typeType = mlirPDLTypeTypeGet(ctx);
|
|
MlirType parsedType = mlirTypeParseGet(
|
|
ctx, mlirStringRefCreateFromCString("!pdl.range<type>"));
|
|
MlirType constructedType = mlirPDLRangeTypeGet(typeType);
|
|
MlirType elementType = mlirPDLRangeTypeGetElementType(constructedType);
|
|
|
|
assert(!mlirTypeIsNull(typeType) && "couldn't get PDLTypeType");
|
|
assert(!mlirTypeIsNull(parsedType) && "couldn't parse PDLAttributeType");
|
|
assert(!mlirTypeIsNull(constructedType) && "couldn't construct PDLAttributeType");
|
|
|
|
// CHECK: parsedType isa PDLType: 1
|
|
fprintf(stderr, "parsedType isa PDLType: %d\n",
|
|
mlirTypeIsAPDLType(parsedType));
|
|
// CHECK: parsedType isa PDLAttributeType: 0
|
|
fprintf(stderr, "parsedType isa PDLAttributeType: %d\n",
|
|
mlirTypeIsAPDLAttributeType(parsedType));
|
|
// CHECK: parsedType isa PDLOperationType: 0
|
|
fprintf(stderr, "parsedType isa PDLOperationType: %d\n",
|
|
mlirTypeIsAPDLOperationType(parsedType));
|
|
// CHECK: parsedType isa PDLRangeType: 1
|
|
fprintf(stderr, "parsedType isa PDLRangeType: %d\n",
|
|
mlirTypeIsAPDLRangeType(parsedType));
|
|
// CHECK: parsedType isa PDLTypeType: 0
|
|
fprintf(stderr, "parsedType isa PDLTypeType: %d\n",
|
|
mlirTypeIsAPDLTypeType(parsedType));
|
|
// CHECK: parsedType isa PDLValueType: 0
|
|
fprintf(stderr, "parsedType isa PDLValueType: %d\n",
|
|
mlirTypeIsAPDLValueType(parsedType));
|
|
|
|
// CHECK: constructedType isa PDLType: 1
|
|
fprintf(stderr, "constructedType isa PDLType: %d\n",
|
|
mlirTypeIsAPDLType(constructedType));
|
|
// CHECK: constructedType isa PDLAttributeType: 0
|
|
fprintf(stderr, "constructedType isa PDLAttributeType: %d\n",
|
|
mlirTypeIsAPDLAttributeType(constructedType));
|
|
// CHECK: constructedType isa PDLOperationType: 0
|
|
fprintf(stderr, "constructedType isa PDLOperationType: %d\n",
|
|
mlirTypeIsAPDLOperationType(constructedType));
|
|
// CHECK: constructedType isa PDLRangeType: 1
|
|
fprintf(stderr, "constructedType isa PDLRangeType: %d\n",
|
|
mlirTypeIsAPDLRangeType(constructedType));
|
|
// CHECK: constructedType isa PDLTypeType: 0
|
|
fprintf(stderr, "constructedType isa PDLTypeType: %d\n",
|
|
mlirTypeIsAPDLTypeType(constructedType));
|
|
// CHECK: constructedType isa PDLValueType: 0
|
|
fprintf(stderr, "constructedType isa PDLValueType: %d\n",
|
|
mlirTypeIsAPDLValueType(constructedType));
|
|
|
|
// CHECK: equal: 1
|
|
fprintf(stderr, "equal: %d\n", mlirTypeEqual(parsedType, constructedType));
|
|
// CHECK: equal: 1
|
|
fprintf(stderr, "equal: %d\n", mlirTypeEqual(typeType, elementType));
|
|
|
|
// CHECK: !pdl.range<type>
|
|
mlirTypeDump(parsedType);
|
|
// CHECK: !pdl.range<type>
|
|
mlirTypeDump(constructedType);
|
|
// CHECK: !pdl.type
|
|
mlirTypeDump(elementType);
|
|
|
|
fprintf(stderr, "\n\n");
|
|
}
|
|
|
|
// CHECK-LABEL: testTypeType
|
|
void testTypeType(MlirContext ctx) {
|
|
fprintf(stderr, "testTypeType\n");
|
|
|
|
MlirType parsedType = mlirTypeParseGet(
|
|
ctx, mlirStringRefCreateFromCString("!pdl.type"));
|
|
MlirType constructedType = mlirPDLTypeTypeGet(ctx);
|
|
|
|
assert(!mlirTypeIsNull(parsedType) && "couldn't parse PDLAttributeType");
|
|
assert(!mlirTypeIsNull(constructedType) && "couldn't construct PDLAttributeType");
|
|
|
|
// CHECK: parsedType isa PDLType: 1
|
|
fprintf(stderr, "parsedType isa PDLType: %d\n",
|
|
mlirTypeIsAPDLType(parsedType));
|
|
// CHECK: parsedType isa PDLAttributeType: 0
|
|
fprintf(stderr, "parsedType isa PDLAttributeType: %d\n",
|
|
mlirTypeIsAPDLAttributeType(parsedType));
|
|
// CHECK: parsedType isa PDLOperationType: 0
|
|
fprintf(stderr, "parsedType isa PDLOperationType: %d\n",
|
|
mlirTypeIsAPDLOperationType(parsedType));
|
|
// CHECK: parsedType isa PDLRangeType: 0
|
|
fprintf(stderr, "parsedType isa PDLRangeType: %d\n",
|
|
mlirTypeIsAPDLRangeType(parsedType));
|
|
// CHECK: parsedType isa PDLTypeType: 1
|
|
fprintf(stderr, "parsedType isa PDLTypeType: %d\n",
|
|
mlirTypeIsAPDLTypeType(parsedType));
|
|
// CHECK: parsedType isa PDLValueType: 0
|
|
fprintf(stderr, "parsedType isa PDLValueType: %d\n",
|
|
mlirTypeIsAPDLValueType(parsedType));
|
|
|
|
// CHECK: constructedType isa PDLType: 1
|
|
fprintf(stderr, "constructedType isa PDLType: %d\n",
|
|
mlirTypeIsAPDLType(constructedType));
|
|
// CHECK: constructedType isa PDLAttributeType: 0
|
|
fprintf(stderr, "constructedType isa PDLAttributeType: %d\n",
|
|
mlirTypeIsAPDLAttributeType(constructedType));
|
|
// CHECK: constructedType isa PDLOperationType: 0
|
|
fprintf(stderr, "constructedType isa PDLOperationType: %d\n",
|
|
mlirTypeIsAPDLOperationType(constructedType));
|
|
// CHECK: constructedType isa PDLRangeType: 0
|
|
fprintf(stderr, "constructedType isa PDLRangeType: %d\n",
|
|
mlirTypeIsAPDLRangeType(constructedType));
|
|
// CHECK: constructedType isa PDLTypeType: 1
|
|
fprintf(stderr, "constructedType isa PDLTypeType: %d\n",
|
|
mlirTypeIsAPDLTypeType(constructedType));
|
|
// CHECK: constructedType isa PDLValueType: 0
|
|
fprintf(stderr, "constructedType isa PDLValueType: %d\n",
|
|
mlirTypeIsAPDLValueType(constructedType));
|
|
|
|
// CHECK: equal: 1
|
|
fprintf(stderr, "equal: %d\n", mlirTypeEqual(parsedType, constructedType));
|
|
|
|
// CHECK: !pdl.type
|
|
mlirTypeDump(parsedType);
|
|
// CHECK: !pdl.type
|
|
mlirTypeDump(constructedType);
|
|
|
|
fprintf(stderr, "\n\n");
|
|
}
|
|
|
|
// CHECK-LABEL: testValueType
|
|
void testValueType(MlirContext ctx) {
|
|
fprintf(stderr, "testValueType\n");
|
|
|
|
MlirType parsedType = mlirTypeParseGet(
|
|
ctx, mlirStringRefCreateFromCString("!pdl.value"));
|
|
MlirType constructedType = mlirPDLValueTypeGet(ctx);
|
|
|
|
assert(!mlirTypeIsNull(parsedType) && "couldn't parse PDLAttributeType");
|
|
assert(!mlirTypeIsNull(constructedType) && "couldn't construct PDLAttributeType");
|
|
|
|
// CHECK: parsedType isa PDLType: 1
|
|
fprintf(stderr, "parsedType isa PDLType: %d\n",
|
|
mlirTypeIsAPDLType(parsedType));
|
|
// CHECK: parsedType isa PDLAttributeType: 0
|
|
fprintf(stderr, "parsedType isa PDLAttributeType: %d\n",
|
|
mlirTypeIsAPDLAttributeType(parsedType));
|
|
// CHECK: parsedType isa PDLOperationType: 0
|
|
fprintf(stderr, "parsedType isa PDLOperationType: %d\n",
|
|
mlirTypeIsAPDLOperationType(parsedType));
|
|
// CHECK: parsedType isa PDLRangeType: 0
|
|
fprintf(stderr, "parsedType isa PDLRangeType: %d\n",
|
|
mlirTypeIsAPDLRangeType(parsedType));
|
|
// CHECK: parsedType isa PDLTypeType: 0
|
|
fprintf(stderr, "parsedType isa PDLTypeType: %d\n",
|
|
mlirTypeIsAPDLTypeType(parsedType));
|
|
// CHECK: parsedType isa PDLValueType: 1
|
|
fprintf(stderr, "parsedType isa PDLValueType: %d\n",
|
|
mlirTypeIsAPDLValueType(parsedType));
|
|
|
|
// CHECK: constructedType isa PDLType: 1
|
|
fprintf(stderr, "constructedType isa PDLType: %d\n",
|
|
mlirTypeIsAPDLType(constructedType));
|
|
// CHECK: constructedType isa PDLAttributeType: 0
|
|
fprintf(stderr, "constructedType isa PDLAttributeType: %d\n",
|
|
mlirTypeIsAPDLAttributeType(constructedType));
|
|
// CHECK: constructedType isa PDLOperationType: 0
|
|
fprintf(stderr, "constructedType isa PDLOperationType: %d\n",
|
|
mlirTypeIsAPDLOperationType(constructedType));
|
|
// CHECK: constructedType isa PDLRangeType: 0
|
|
fprintf(stderr, "constructedType isa PDLRangeType: %d\n",
|
|
mlirTypeIsAPDLRangeType(constructedType));
|
|
// CHECK: constructedType isa PDLTypeType: 0
|
|
fprintf(stderr, "constructedType isa PDLTypeType: %d\n",
|
|
mlirTypeIsAPDLTypeType(constructedType));
|
|
// CHECK: constructedType isa PDLValueType: 1
|
|
fprintf(stderr, "constructedType isa PDLValueType: %d\n",
|
|
mlirTypeIsAPDLValueType(constructedType));
|
|
|
|
// CHECK: equal: 1
|
|
fprintf(stderr, "equal: %d\n", mlirTypeEqual(parsedType, constructedType));
|
|
|
|
// CHECK: !pdl.value
|
|
mlirTypeDump(parsedType);
|
|
// CHECK: !pdl.value
|
|
mlirTypeDump(constructedType);
|
|
|
|
fprintf(stderr, "\n\n");
|
|
}
|
|
|
|
int main(void) {
|
|
MlirContext ctx = mlirContextCreate();
|
|
mlirDialectHandleRegisterDialect(mlirGetDialectHandle__pdl__(), ctx);
|
|
testAttributeType(ctx);
|
|
testOperationType(ctx);
|
|
testRangeType(ctx);
|
|
testTypeType(ctx);
|
|
testValueType(ctx);
|
|
mlirContextDestroy(ctx);
|
|
return EXIT_SUCCESS;
|
|
}
|