[mlir] Restructure C API tests for IR

[ftynse]

Summary

The test file is a long list of functions, followed by equally long FileCheck
comments inside "main". Distribute FileCheck comments closer to the functions
that produce the output we are checking.

[stellaraccident]

Thanks, looks good. This had been annoying me but never quite enough to fix it.

[mehdi_amini]

Thanks! That's also how I intuitively wrote the CHECKs for the pass manager tests.

mlir/test/CAPI/ir.c

void populateLoopBody(MlirContext ctx, MlirBlock loopBody,
   MlirOperation store = mlirOperationCreate(&storeState);
   mlirBlockAppendOwnedOperation(loopBody, store);
 
   MlirOperationState yieldState = mlirOperationStateGet("scf.yield", location);
   MlirOperation yield = mlirOperationCreate(&yieldState);
   mlirBlockAppendOwnedOperation(loopBody, yield);
 }
 
-MlirModule makeAdd(MlirContext ctx, MlirLocation location) {
+MlirModule makeAndDumpAdd(MlirContext ctx, MlirLocation location) {
   MlirModule moduleOp = mlirModuleCreateEmpty(location);
   MlirBlock moduleBody = mlirModuleGetBody(moduleOp);
 
   MlirType memrefType = mlirTypeParseGet(ctx, "memref<?xf32>");
   MlirType funcBodyArgTypes[] = {memrefType, memrefType};
   MlirRegion funcBodyRegion = mlirRegionCreate();
   MlirBlock funcBody = mlirBlockCreate(
       sizeof(funcBodyArgTypes) / sizeof(MlirType), funcBodyArgTypes);
MlirModule makeAndDumpAdd(MlirContext ctx, MlirLocation location) {
   mlirBlockAppendOwnedOperation(funcBody, loop);
 
   populateLoopBody(ctx, loopBody, location, funcBody);
 
   MlirOperationState retState = mlirOperationStateGet("std.return", location);
   MlirOperation ret = mlirOperationCreate(&retState);
   mlirBlockAppendOwnedOperation(funcBody, ret);
 
+  MlirOperation module = mlirModuleGetOperation(moduleOp);
+  mlirOperationDump(module);
+  // clang-format off
+  // CHECK: module {
+  // CHECK:   func @add(%[[ARG0:.*]]: memref<?xf32>, %[[ARG1:.*]]: memref<?xf32>) {
+  // CHECK:     %[[C0:.*]] = constant 0 : index
+  // CHECK:     %[[DIM:.*]] = dim %[[ARG0]], %[[C0]] : memref<?xf32>
+  // CHECK:     %[[C1:.*]] = constant 1 : index
+  // CHECK:     scf.for %[[I:.*]] = %[[C0]] to %[[DIM]] step %[[C1]] {
+  // CHECK:       %[[LHS:.*]] = load %[[ARG0]][%[[I]]] : memref<?xf32>
+  // CHECK:       %[[RHS:.*]] = load %[[ARG1]][%[[I]]] : memref<?xf32>
+  // CHECK:       %[[SUM:.*]] = addf %[[LHS]], %[[RHS]] : f32
+  // CHECK:       store %[[SUM]], %[[ARG0]][%[[I]]] : memref<?xf32>
+  // CHECK:     }
+  // CHECK:     return
+  // CHECK:   }
+  // CHECK: }
+  // clang-format on
+
   return moduleOp;
 }
 
 struct OpListNode {
   MlirOperation op;
   struct OpListNode *next;
 };
 typedef struct OpListNode OpListNode;
do {
     int retval = collectStatsSingle(head, &stats);
     if (retval)
       return retval;
     OpListNode *next = head->next;
     free(head);
     head = next;
   } while (head);
 
+  if (stats.numValues != stats.numBlockArguments + stats.numOpResults)
+    return 100;
+
+  fprintf(stderr, "@stats\n");
   fprintf(stderr, "Number of operations: %u\n", stats.numOperations);
   fprintf(stderr, "Number of attributes: %u\n", stats.numAttributes);
   fprintf(stderr, "Number of blocks: %u\n", stats.numBlocks);
   fprintf(stderr, "Number of regions: %u\n", stats.numRegions);
   fprintf(stderr, "Number of values: %u\n", stats.numValues);
   fprintf(stderr, "Number of block arguments: %u\n", stats.numBlockArguments);
   fprintf(stderr, "Number of op results: %u\n", stats.numOpResults);
-  if (stats.numValues != stats.numBlockArguments + stats.numOpResults)
-    return 100;
+  // clang-format off
+  // CHECK-LABEL: @stats
+  // CHECK: Number of operations: 13
+  // CHECK: Number of attributes: 4
+  // CHECK: Number of blocks: 3
+  // CHECK: Number of regions: 3
+  // CHECK: Number of values: 9
+  // CHECK: Number of block arguments: 3
+  // CHECK: Number of op results: 6
+  // clang-format on
   return 0;
 }
 
 static void printToStderr(const char *str, intptr_t len, void *userData) {
   (void)userData;
   fwrite(str, 1, len, stderr);
 }
 
static void printFirstOfEach(MlirContext ctx, MlirOperation operation) {
   operation = mlirBlockGetFirstOperation(block);
 
   // Verify that parent operation and block report correctly.
   fprintf(stderr, "Parent operation eq: %d\n",
           mlirOperationEqual(mlirOperationGetParentOperation(operation),
                              parentOperation));
   fprintf(stderr, "Block eq: %d\n",
           mlirBlockEqual(mlirOperationGetBlock(operation), block));
+  // CHECK: Parent operation eq: 1
+  // CHECK: Block eq: 1
 
   // In the module we created, the first operation of the first function is
   // an "std.dim", which has an attribute and a single result that we can
   // use to test the printing mechanism.
   mlirBlockPrint(block, printToStderr, NULL);
   fprintf(stderr, "\n");
   fprintf(stderr, "First operation: ");
   mlirOperationPrint(operation, printToStderr, NULL);
   fprintf(stderr, "\n");
+  // clang-format off
+  // CHECK:   %[[C0:.*]] = constant 0 : index
+  // CHECK:   %[[DIM:.*]] = dim %{{.*}}, %[[C0]] : memref<?xf32>
+  // CHECK:   %[[C1:.*]] = constant 1 : index
+  // CHECK:   scf.for %[[I:.*]] = %[[C0]] to %[[DIM]] step %[[C1]] {
+  // CHECK:     %[[LHS:.*]] = load %{{.*}}[%[[I]]] : memref<?xf32>
+  // CHECK:     %[[RHS:.*]] = load %{{.*}}[%[[I]]] : memref<?xf32>
+  // CHECK:     %[[SUM:.*]] = addf %[[LHS]], %[[RHS]] : f32
+  // CHECK:     store %[[SUM]], %{{.*}}[%[[I]]] : memref<?xf32>
+  // CHECK:   }
+  // CHECK: return
+  // CHECK: First operation: {{.*}} = constant 0 : index
+  // clang-format on
 
   // Get the operation name and print it.
   MlirIdentifier ident = mlirOperationGetName(operation);
   MlirStringRef identStr = mlirIdentifierStr(ident);
   fprintf(stderr, "Operation name: '");
   for (size_t i = 0; i < identStr.length; ++i)
     fputc(identStr.data[i], stderr);
   fprintf(stderr, "'\n");
+  // CHECK: Operation name: 'std.constant'
 
   // Get the identifier again and verify equal.
   MlirIdentifier identAgain = mlirIdentifierGet(ctx, identStr);
   fprintf(stderr, "Identifier equal: %d\n",
           mlirIdentifierEqual(ident, identAgain));
+  // CHECK: Identifier equal: 1
 
   // Get the block terminator and print it.
   MlirOperation terminator = mlirBlockGetTerminator(block);
   fprintf(stderr, "Terminator: ");
   mlirOperationPrint(terminator, printToStderr, NULL);
   fprintf(stderr, "\n");
+  // CHECK: Terminator: return
 
   // Get the attribute by index.
   MlirNamedAttribute namedAttr0 = mlirOperationGetAttribute(operation, 0);
   fprintf(stderr, "Get attr 0: ");
   mlirAttributePrint(namedAttr0.attribute, printToStderr, NULL);
   fprintf(stderr, "\n");
+  // CHECK: Get attr 0: 0 : index
 
   // Now re-get the attribute by name.
   MlirAttribute attr0ByName =
       mlirOperationGetAttributeByName(operation, namedAttr0.name);
   fprintf(stderr, "Get attr 0 by name: ");
   mlirAttributePrint(attr0ByName, printToStderr, NULL);
   fprintf(stderr, "\n");
+  // CHECK: Get attr 0 by name: 0 : index
 
   // Get a non-existing attribute and assert that it is null (sanity).
   fprintf(stderr, "does_not_exist is null: %d\n",
           mlirAttributeIsNull(
               mlirOperationGetAttributeByName(operation, "does_not_exist")));
+  // CHECK: does_not_exist is null: 1
 
   // Get result 0 and its type.
   MlirValue value = mlirOperationGetResult(operation, 0);
   fprintf(stderr, "Result 0: ");
   mlirValuePrint(value, printToStderr, NULL);
   fprintf(stderr, "\n");
   fprintf(stderr, "Value is null: %d\n", mlirValueIsNull(value));
+  // CHECK: Result 0: {{.*}} = constant 0 : index
+  // CHECK: Value is null: 0
 
   MlirType type = mlirValueGetType(value);
   fprintf(stderr, "Result 0 type: ");
   mlirTypePrint(type, printToStderr, NULL);
   fprintf(stderr, "\n");
+  // CHECK: Result 0 type: index
 
   // Set a custom attribute.
   mlirOperationSetAttributeByName(operation, "custom_attr",
                                   mlirBoolAttrGet(ctx, 1));
   fprintf(stderr, "Op with set attr: ");
   mlirOperationPrint(operation, printToStderr, NULL);
   fprintf(stderr, "\n");
+  // CHECK: Op with set attr: {{.*}} {custom_attr = true}
 
   // Remove the attribute.
   fprintf(stderr, "Remove attr: %d\n",
           mlirOperationRemoveAttributeByName(operation, "custom_attr"));
   fprintf(stderr, "Remove attr again: %d\n",
           mlirOperationRemoveAttributeByName(operation, "custom_attr"));
   fprintf(stderr, "Removed attr is null: %d\n",
           mlirAttributeIsNull(
               mlirOperationGetAttributeByName(operation, "custom_attr")));
+  // CHECK: Remove attr: 1
+  // CHECK: Remove attr again: 0
+  // CHECK: Removed attr is null: 1
 
   // Add a large attribute to verify printing flags.
   int64_t eltsShape[] = {4};
   int32_t eltsData[] = {1, 2, 3, 4};
   mlirOperationSetAttributeByName(
       operation, "elts",
       mlirDenseElementsAttrInt32Get(
           mlirRankedTensorTypeGet(1, eltsShape, mlirIntegerTypeGet(ctx, 32)), 4,
           eltsData));
   MlirOpPrintingFlags flags = mlirOpPrintingFlagsCreate();
   mlirOpPrintingFlagsElideLargeElementsAttrs(flags, 2);
   mlirOpPrintingFlagsPrintGenericOpForm(flags);
   mlirOpPrintingFlagsEnableDebugInfo(flags, /*prettyForm=*/0);
   mlirOpPrintingFlagsUseLocalScope(flags);
   fprintf(stderr, "Op print with all flags: ");
   mlirOperationPrintWithFlags(operation, flags, printToStderr, NULL);
   fprintf(stderr, "\n");
+  // CHECK: Op print with all flags: %{{.*}} = "std.constant"() {elts = opaque<"", "0xDEADBEEF"> : tensor<4xi32>, value = 0 : index} : () -> index loc(unknown)
 
   mlirOpPrintingFlagsDestroy(flags);
 }
 
+static int constructAndTraverseIr(MlirContext ctx) {
+  MlirLocation location = mlirLocationUnknownGet(ctx);
+
+  MlirModule moduleOp = makeAndDumpAdd(ctx, location);
+  MlirOperation module = mlirModuleGetOperation(moduleOp);
+
+  int errcode = collectStats(module);
+  if (errcode)
+    return errcode;
+
+  printFirstOfEach(ctx, module);
+
+  mlirModuleDestroy(moduleOp);
+  return 0;
+}
+
 /// Creates an operation with a region containing multiple blocks with
 /// operations and dumps it. The blocks and operations are inserted using
 /// block/operation-relative API and their final order is checked.
 static void buildWithInsertionsAndPrint(MlirContext ctx) {
   MlirLocation loc = mlirLocationUnknownGet(ctx);
 
   MlirRegion owningRegion = mlirRegionCreate();
   MlirBlock nullBlock = mlirRegionGetFirstBlock(owningRegion);
static void buildWithInsertionsAndPrint(MlirContext ctx) {
   // Append operations to the rest of blocks to make them non-empty and thus
   // printable.
   mlirBlockAppendOwnedOperation(block2, op5);
   mlirBlockAppendOwnedOperation(block3, op6);
   mlirBlockAppendOwnedOperation(block4, op7);
 
   mlirOperationDump(op);
   mlirOperationDestroy(op);
+  // clang-format off
+  // CHECK-LABEL:  "insertion.order.test"
+  // CHECK:      ^{{.*}}(%{{.*}}: i1
+  // CHECK:        "dummy.op1"
+  // CHECK-NEXT:   "dummy.op2"
+  // CHECK-NEXT:   "dummy.op3"
+  // CHECK-NEXT:   "dummy.op4"
+  // CHECK:      ^{{.*}}(%{{.*}}: i2
+  // CHECK:        "dummy.op5"
+  // CHECK:      ^{{.*}}(%{{.*}}: i3
+  // CHECK:        "dummy.op6"
+  // CHECK:      ^{{.*}}(%{{.*}}: i4
+  // CHECK:        "dummy.op7"
+  // clang-format on
 }
 
 /// Dumps instances of all standard types to check that C API works correctly.
 /// Additionally, performs simple identity checks that a standard type
 /// constructed with C API can be inspected and has the expected type. The
 /// latter achieves full coverage of C API for standard types. Returns 0 on
 /// success and a non-zero error code on failure.
 static int printStandardTypes(MlirContext ctx) {
   // Integer types.
   MlirType i32 = mlirIntegerTypeGet(ctx, 32);
   MlirType si32 = mlirIntegerTypeSignedGet(ctx, 32);
   MlirType ui32 = mlirIntegerTypeUnsignedGet(ctx, 32);
   if (!mlirTypeIsAInteger(i32) || mlirTypeIsAF32(i32))
     return 1;
   if (!mlirTypeIsAInteger(si32) || !mlirIntegerTypeIsSigned(si32))
     return 2;
   if (!mlirTypeIsAInteger(ui32) || !mlirIntegerTypeIsUnsigned(ui32))
     return 3;
   if (mlirTypeEqual(i32, ui32) || mlirTypeEqual(i32, si32))
     return 4;
   if (mlirIntegerTypeGetWidth(i32) != mlirIntegerTypeGetWidth(si32))
     return 5;
+  fprintf(stderr, "@types\n");
   mlirTypeDump(i32);
   fprintf(stderr, "\n");
   mlirTypeDump(si32);
   fprintf(stderr, "\n");
   mlirTypeDump(ui32);
   fprintf(stderr, "\n");
+  // CHECK-LABEL: @types
+  // CHECK: i32
+  // CHECK: si32
+  // CHECK: ui32
 
   // Index type.
   MlirType index = mlirIndexTypeGet(ctx);
   if (!mlirTypeIsAIndex(index))
     return 6;
   mlirTypeDump(index);
   fprintf(stderr, "\n");
+  // CHECK: index
 
   // Floating-point types.
   MlirType bf16 = mlirBF16TypeGet(ctx);
   MlirType f16 = mlirF16TypeGet(ctx);
   MlirType f32 = mlirF32TypeGet(ctx);
   MlirType f64 = mlirF64TypeGet(ctx);
   if (!mlirTypeIsABF16(bf16))
     return 7;
   if (!mlirTypeIsAF16(f16))
     return 9;
   if (!mlirTypeIsAF32(f32))
     return 10;
   if (!mlirTypeIsAF64(f64))
     return 11;
   mlirTypeDump(bf16);
   fprintf(stderr, "\n");
   mlirTypeDump(f16);
   fprintf(stderr, "\n");
   mlirTypeDump(f32);
   fprintf(stderr, "\n");
   mlirTypeDump(f64);
   fprintf(stderr, "\n");
+  // CHECK: bf16
+  // CHECK: f16
+  // CHECK: f32
+  // CHECK: f64
 
   // None type.
   MlirType none = mlirNoneTypeGet(ctx);
   if (!mlirTypeIsANone(none))
     return 12;
   mlirTypeDump(none);
   fprintf(stderr, "\n");
+  // CHECK: none
 
   // Complex type.
   MlirType cplx = mlirComplexTypeGet(f32);
   if (!mlirTypeIsAComplex(cplx) ||
       !mlirTypeEqual(mlirComplexTypeGetElementType(cplx), f32))
     return 13;
   mlirTypeDump(cplx);
   fprintf(stderr, "\n");
+  // CHECK: complex<f32>
 
   // Vector (and Shaped) type. ShapedType is a common base class for vectors,
   // memrefs and tensors, one cannot create instances of this class so it is
   // tested on an instance of vector type.
   int64_t shape[] = {2, 3};
   MlirType vector =
       mlirVectorTypeGet(sizeof(shape) / sizeof(int64_t), shape, f32);
   if (!mlirTypeIsAVector(vector) || !mlirTypeIsAShaped(vector))
     return 14;
   if (!mlirTypeEqual(mlirShapedTypeGetElementType(vector), f32) ||
       !mlirShapedTypeHasRank(vector) || mlirShapedTypeGetRank(vector) != 2 ||
       mlirShapedTypeGetDimSize(vector, 0) != 2 ||
       mlirShapedTypeIsDynamicDim(vector, 0) ||
       mlirShapedTypeGetDimSize(vector, 1) != 3 ||
       !mlirShapedTypeHasStaticShape(vector))
     return 15;
   mlirTypeDump(vector);
   fprintf(stderr, "\n");
+  // CHECK: vector<2x3xf32>
 
   // Ranked tensor type.
   MlirType rankedTensor =
       mlirRankedTensorTypeGet(sizeof(shape) / sizeof(int64_t), shape, f32);
   if (!mlirTypeIsATensor(rankedTensor) ||
       !mlirTypeIsARankedTensor(rankedTensor))
     return 16;
   mlirTypeDump(rankedTensor);
   fprintf(stderr, "\n");
+  // CHECK: tensor<2x3xf32>
 
   // Unranked tensor type.
   MlirType unrankedTensor = mlirUnrankedTensorTypeGet(f32);
   if (!mlirTypeIsATensor(unrankedTensor) ||
       !mlirTypeIsAUnrankedTensor(unrankedTensor) ||
       mlirShapedTypeHasRank(unrankedTensor))
     return 17;
   mlirTypeDump(unrankedTensor);
   fprintf(stderr, "\n");
+  // CHECK: tensor<*xf32>
 
   // MemRef type.
   MlirType memRef = mlirMemRefTypeContiguousGet(
       f32, sizeof(shape) / sizeof(int64_t), shape, 2);
   if (!mlirTypeIsAMemRef(memRef) ||
       mlirMemRefTypeGetNumAffineMaps(memRef) != 0 ||
       mlirMemRefTypeGetMemorySpace(memRef) != 2)
     return 18;
   mlirTypeDump(memRef);
   fprintf(stderr, "\n");
+  // CHECK: memref<2x3xf32, 2>
 
   // Unranked MemRef type.
   MlirType unrankedMemRef = mlirUnrankedMemRefTypeGet(f32, 4);
   if (!mlirTypeIsAUnrankedMemRef(unrankedMemRef) ||
       mlirTypeIsAMemRef(unrankedMemRef) ||
       mlirUnrankedMemrefGetMemorySpace(unrankedMemRef) != 4)
     return 19;
   mlirTypeDump(unrankedMemRef);
   fprintf(stderr, "\n");
+  // CHECK: memref<*xf32, 4>
 
   // Tuple type.
   MlirType types[] = {unrankedMemRef, f32};
   MlirType tuple = mlirTupleTypeGet(ctx, 2, types);
   if (!mlirTypeIsATuple(tuple) || mlirTupleTypeGetNumTypes(tuple) != 2 ||
       !mlirTypeEqual(mlirTupleTypeGetType(tuple, 0), unrankedMemRef) ||
       !mlirTypeEqual(mlirTupleTypeGetType(tuple, 1), f32))
     return 20;
   mlirTypeDump(tuple);
   fprintf(stderr, "\n");
+  // CHECK: tuple<memref<*xf32, 4>, f32>
 
   // Function type.
   MlirType funcInputs[2] = {mlirIndexTypeGet(ctx), mlirIntegerTypeGet(ctx, 1)};
   MlirType funcResults[3] = {mlirIntegerTypeGet(ctx, 16),
                              mlirIntegerTypeGet(ctx, 32),
                              mlirIntegerTypeGet(ctx, 64)};
   MlirType funcType = mlirFunctionTypeGet(ctx, 2, funcInputs, 3, funcResults);
   if (mlirFunctionTypeGetNumInputs(funcType) != 2)
     return 21;
   if (mlirFunctionTypeGetNumResults(funcType) != 3)
     return 22;
   if (!mlirTypeEqual(funcInputs[0], mlirFunctionTypeGetInput(funcType, 0)) ||
       !mlirTypeEqual(funcInputs[1], mlirFunctionTypeGetInput(funcType, 1)))
     return 23;
   if (!mlirTypeEqual(funcResults[0], mlirFunctionTypeGetResult(funcType, 0)) ||
       !mlirTypeEqual(funcResults[1], mlirFunctionTypeGetResult(funcType, 1)) ||
       !mlirTypeEqual(funcResults[2], mlirFunctionTypeGetResult(funcType, 2)))
     return 24;
   mlirTypeDump(funcType);
   fprintf(stderr, "\n");
+  // CHECK: (index, i1) -> (i16, i32, i64)
 
   return 0;
 }
 
 void callbackSetFixedLengthString(const char *data, intptr_t len,
                                   void *userData) {
   strncpy(userData, data, len);
 }
 
 int printStandardAttributes(MlirContext ctx) {
   MlirAttribute floating =
       mlirFloatAttrDoubleGet(ctx, mlirF64TypeGet(ctx), 2.0);
   if (!mlirAttributeIsAFloat(floating) ||
       fabs(mlirFloatAttrGetValueDouble(floating) - 2.0) > 1E-6)
     return 1;
+  fprintf(stderr, "@attrs\n");
   mlirAttributeDump(floating);
+  // CHECK-LABEL: @attrs
+  // CHECK: 2.000000e+00 : f64
 
   // Exercise mlirAttributeGetType() just for the first one.
   MlirType floatingType = mlirAttributeGetType(floating);
   mlirTypeDump(floatingType);
+  // CHECK: f64
 
   MlirAttribute integer = mlirIntegerAttrGet(mlirIntegerTypeGet(ctx, 32), 42);
   if (!mlirAttributeIsAInteger(integer) ||
       mlirIntegerAttrGetValueInt(integer) != 42)
     return 2;
   mlirAttributeDump(integer);
+  // CHECK: 42 : i32
 
   MlirAttribute boolean = mlirBoolAttrGet(ctx, 1);
   if (!mlirAttributeIsABool(boolean) || !mlirBoolAttrGetValue(boolean))
     return 3;
   mlirAttributeDump(boolean);
+  // CHECK: true
 
   const char data[] = "abcdefghijklmnopqestuvwxyz";
   MlirAttribute opaque =
       mlirOpaqueAttrGet(ctx, "std", 3, data, mlirNoneTypeGet(ctx));
   if (!mlirAttributeIsAOpaque(opaque) ||
       strcmp("std", mlirOpaqueAttrGetDialectNamespace(opaque)))
     return 4;
 
   MlirStringRef opaqueData = mlirOpaqueAttrGetData(opaque);
   if (opaqueData.length != 3 ||
       strncmp(data, opaqueData.data, opaqueData.length))
     return 5;
   mlirAttributeDump(opaque);
+  // CHECK: #std.abc
 
   MlirAttribute string = mlirStringAttrGet(ctx, 2, data + 3);
   if (!mlirAttributeIsAString(string))
     return 6;
 
   MlirStringRef stringValue = mlirStringAttrGetValue(string);
   if (stringValue.length != 2 ||
       strncmp(data + 3, stringValue.data, stringValue.length))
     return 7;
   mlirAttributeDump(string);
+  // CHECK: "de"
 
   MlirAttribute flatSymbolRef = mlirFlatSymbolRefAttrGet(ctx, 3, data + 5);
   if (!mlirAttributeIsAFlatSymbolRef(flatSymbolRef))
     return 8;
 
   MlirStringRef flatSymbolRefValue =
       mlirFlatSymbolRefAttrGetValue(flatSymbolRef);
   if (flatSymbolRefValue.length != 3 ||
       strncmp(data + 5, flatSymbolRefValue.data, flatSymbolRefValue.length))
     return 9;
   mlirAttributeDump(flatSymbolRef);
+  // CHECK: @fgh
 
   MlirAttribute symbols[] = {flatSymbolRef, flatSymbolRef};
   MlirAttribute symbolRef = mlirSymbolRefAttrGet(ctx, 2, data + 8, 2, symbols);
   if (!mlirAttributeIsASymbolRef(symbolRef) ||
       mlirSymbolRefAttrGetNumNestedReferences(symbolRef) != 2 ||
       !mlirAttributeEqual(mlirSymbolRefAttrGetNestedReference(symbolRef, 0),
                           flatSymbolRef) ||
       !mlirAttributeEqual(mlirSymbolRefAttrGetNestedReference(symbolRef, 1),
                           flatSymbolRef))
     return 10;
 
   MlirStringRef symbolRefLeaf = mlirSymbolRefAttrGetLeafReference(symbolRef);
   MlirStringRef symbolRefRoot = mlirSymbolRefAttrGetRootReference(symbolRef);
   if (symbolRefLeaf.length != 3 ||
       strncmp(data + 5, symbolRefLeaf.data, symbolRefLeaf.length) ||
       symbolRefRoot.length != 2 ||
       strncmp(data + 8, symbolRefRoot.data, symbolRefRoot.length))
     return 11;
   mlirAttributeDump(symbolRef);
+  // CHECK: @ij::@fgh::@fgh
 
   MlirAttribute type = mlirTypeAttrGet(mlirF32TypeGet(ctx));
   if (!mlirAttributeIsAType(type) ||
       !mlirTypeEqual(mlirF32TypeGet(ctx), mlirTypeAttrGetValue(type)))
     return 12;
   mlirAttributeDump(type);
+  // CHECK: f32
 
   MlirAttribute unit = mlirUnitAttrGet(ctx);
   if (!mlirAttributeIsAUnit(unit))
     return 13;
   mlirAttributeDump(unit);
+  // CHECK: unit
 
   int64_t shape[] = {1, 2};
 
   int bools[] = {0, 1};
   uint32_t uints32[] = {0u, 1u};
   int32_t ints32[] = {0, 1};
   uint64_t uints64[] = {0u, 1u};
   int64_t ints64[] = {0, 1};
int printStandardAttributes(MlirContext ctx) {
 
   mlirAttributeDump(boolElements);
   mlirAttributeDump(uint32Elements);
   mlirAttributeDump(int32Elements);
   mlirAttributeDump(uint64Elements);
   mlirAttributeDump(int64Elements);
   mlirAttributeDump(floatElements);
   mlirAttributeDump(doubleElements);
+  // CHECK: dense<{{\[}}[false, true]]> : tensor<1x2xi1>
+  // CHECK: dense<{{\[}}[0, 1]]> : tensor<1x2xui32>
+  // CHECK: dense<{{\[}}[0, 1]]> : tensor<1x2xi32>
+  // CHECK: dense<{{\[}}[0, 1]]> : tensor<1x2xui64>
+  // CHECK: dense<{{\[}}[0, 1]]> : tensor<1x2xi64>
+  // CHECK: dense<{{\[}}[0.000000e+00, 1.000000e+00]]> : tensor<1x2xf32>
+  // CHECK: dense<{{\[}}[0.000000e+00, 1.000000e+00]]> : tensor<1x2xf64>
 
   MlirAttribute splatBool = mlirDenseElementsAttrBoolSplatGet(
       mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 1)), 1);
   MlirAttribute splatUInt32 = mlirDenseElementsAttrUInt32SplatGet(
       mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 32)), 1);
   MlirAttribute splatInt32 = mlirDenseElementsAttrInt32SplatGet(
       mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 32)), 1);
   MlirAttribute splatUInt64 = mlirDenseElementsAttrUInt64SplatGet(
int printStandardAttributes(MlirContext ctx) {
 
   mlirAttributeDump(splatBool);
   mlirAttributeDump(splatUInt32);
   mlirAttributeDump(splatInt32);
   mlirAttributeDump(splatUInt64);
   mlirAttributeDump(splatInt64);
   mlirAttributeDump(splatFloat);
   mlirAttributeDump(splatDouble);
+  // CHECK: dense<true> : tensor<1x2xi1>
+  // CHECK: dense<1> : tensor<1x2xi32>
+  // CHECK: dense<1> : tensor<1x2xi32>
+  // CHECK: dense<1> : tensor<1x2xi64>
+  // CHECK: dense<1> : tensor<1x2xi64>
+  // CHECK: dense<1.000000e+00> : tensor<1x2xf32>
+  // CHECK: dense<1.000000e+00> : tensor<1x2xf64>
 
   mlirAttributeDump(mlirElementsAttrGetValue(floatElements, 2, uints64));
   mlirAttributeDump(mlirElementsAttrGetValue(doubleElements, 2, uints64));
+  // CHECK: 1.000000e+00 : f32
+  // CHECK: 1.000000e+00 : f64
 
   int64_t indices[] = {4, 7};
   int64_t two = 2;
   MlirAttribute indicesAttr = mlirDenseElementsAttrInt64Get(
       mlirRankedTensorTypeGet(1, &two, mlirIntegerTypeGet(ctx, 64)), 2,
       indices);
   MlirAttribute valuesAttr = mlirDenseElementsAttrFloatGet(
       mlirRankedTensorTypeGet(1, &two, mlirF32TypeGet(ctx)), 2, floats);
   MlirAttribute sparseAttr = mlirSparseElementsAttribute(
       mlirRankedTensorTypeGet(2, shape, mlirF32TypeGet(ctx)), indicesAttr,
       valuesAttr);
   mlirAttributeDump(sparseAttr);
+  // CHECK: sparse<[4, 7], [0.000000e+00, 1.000000e+00]> : tensor<1x2xf32>
 
   return 0;
 }
 
 int printAffineMap(MlirContext ctx) {
   MlirAffineMap emptyAffineMap = mlirAffineMapEmptyGet(ctx);
   MlirAffineMap affineMap = mlirAffineMapGet(ctx, 3, 2);
   MlirAffineMap constAffineMap = mlirAffineMapConstantGet(ctx, 2);
   MlirAffineMap multiDimIdentityAffineMap =
       mlirAffineMapMultiDimIdentityGet(ctx, 3);
   MlirAffineMap minorIdentityAffineMap =
       mlirAffineMapMinorIdentityGet(ctx, 3, 2);
   unsigned permutation[] = {1, 2, 0};
   MlirAffineMap permutationAffineMap = mlirAffineMapPermutationGet(
       ctx, sizeof(permutation) / sizeof(unsigned), permutation);
 
+  fprintf(stderr, "@affineMap\n");
   mlirAffineMapDump(emptyAffineMap);
   mlirAffineMapDump(affineMap);
   mlirAffineMapDump(constAffineMap);
   mlirAffineMapDump(multiDimIdentityAffineMap);
   mlirAffineMapDump(minorIdentityAffineMap);
   mlirAffineMapDump(permutationAffineMap);
+  // CHECK-LABEL: @affineMap
+  // CHECK: () -> ()
+  // CHECK: (d0, d1, d2)[s0, s1] -> ()
+  // CHECK: () -> (2)
+  // CHECK: (d0, d1, d2) -> (d0, d1, d2)
+  // CHECK: (d0, d1, d2) -> (d1, d2)
+  // CHECK: (d0, d1, d2) -> (d1, d2, d0)
 
   if (!mlirAffineMapIsIdentity(emptyAffineMap) ||
       mlirAffineMapIsIdentity(affineMap) ||
       mlirAffineMapIsIdentity(constAffineMap) ||
       !mlirAffineMapIsIdentity(multiDimIdentityAffineMap) ||
       mlirAffineMapIsIdentity(minorIdentityAffineMap) ||
       mlirAffineMapIsIdentity(permutationAffineMap))
     return 1;
int printAffineMap(MlirContext ctx) {
   MlirAffineMap majorSubMap =
       mlirAffineMapGetMajorSubMap(multiDimIdentityAffineMap, 1);
   MlirAffineMap minorSubMap =
       mlirAffineMapGetMinorSubMap(multiDimIdentityAffineMap, 1);
 
   mlirAffineMapDump(subMap);
   mlirAffineMapDump(majorSubMap);
   mlirAffineMapDump(minorSubMap);
+  // CHECK: (d0, d1, d2) -> (d1)
+  // CHECK: (d0, d1, d2) -> (d0)
+  // CHECK: (d0, d1, d2) -> (d2)
 
   return 0;
 }
 
 int printAffineExpr(MlirContext ctx) {
   MlirAffineExpr affineDimExpr = mlirAffineDimExprGet(ctx, 5);
   MlirAffineExpr affineSymbolExpr = mlirAffineSymbolExprGet(ctx, 5);
   MlirAffineExpr affineConstantExpr = mlirAffineConstantExprGet(ctx, 5);
   MlirAffineExpr affineAddExpr =
       mlirAffineAddExprGet(affineDimExpr, affineSymbolExpr);
   MlirAffineExpr affineMulExpr =
       mlirAffineMulExprGet(affineDimExpr, affineSymbolExpr);
   MlirAffineExpr affineModExpr =
       mlirAffineModExprGet(affineDimExpr, affineSymbolExpr);
   MlirAffineExpr affineFloorDivExpr =
       mlirAffineFloorDivExprGet(affineDimExpr, affineSymbolExpr);
   MlirAffineExpr affineCeilDivExpr =
       mlirAffineCeilDivExprGet(affineDimExpr, affineSymbolExpr);
 
   // Tests mlirAffineExprDump.
+  fprintf(stderr, "@affineExpr\n");
   mlirAffineExprDump(affineDimExpr);
   mlirAffineExprDump(affineSymbolExpr);
   mlirAffineExprDump(affineConstantExpr);
   mlirAffineExprDump(affineAddExpr);
   mlirAffineExprDump(affineMulExpr);
   mlirAffineExprDump(affineModExpr);
   mlirAffineExprDump(affineFloorDivExpr);
   mlirAffineExprDump(affineCeilDivExpr);
+  // CHECK-LABEL: @affineExpr
+  // CHECK: d5
+  // CHECK: s5
+  // CHECK: 5
+  // CHECK: d5 + s5
+  // CHECK: d5 * s5
+  // CHECK: d5 mod s5
+  // CHECK: d5 floordiv s5
+  // CHECK: d5 ceildiv s5
 
   // Tests methods of affine binary operation expression, takes add expression
   // as an example.
   mlirAffineExprDump(mlirAffineBinaryOpExprGetLHS(affineAddExpr));
   mlirAffineExprDump(mlirAffineBinaryOpExprGetRHS(affineAddExpr));
+  // CHECK: d5
+  // CHECK: s5
 
   // Tests methods of affine dimension expression.
   if (mlirAffineDimExprGetPosition(affineDimExpr) != 5)
     return 1;
 
   // Tests methods of affine symbol expression.
   if (mlirAffineSymbolExprGetPosition(affineSymbolExpr) != 5)
     return 2;
if (!mlirDialectEqual(std, alsoStd))
     return 7;
 
   MlirStringRef stdNs = mlirDialectGetNamespace(std);
   MlirStringRef alsoStdNs = mlirStandardDialectGetNamespace();
   if (stdNs.length != alsoStdNs.length ||
       strncmp(stdNs.data, alsoStdNs.data, stdNs.length))
     return 8;
 
+  fprintf(stderr, "@registration\n");
+  // CHECK-LABEL: @registration
+
   return 0;
 }
 
 // Wraps a diagnostic into additional text we can match against.
 MlirLogicalResult errorHandler(MlirDiagnostic diagnostic) {
   fprintf(stderr, "processing diagnostic <<\n");
   mlirDiagnosticPrint(diagnostic, printToStderr, NULL);
   fprintf(stderr, "\n");
   MlirLocation loc = mlirDiagnosticGetLocation(diagnostic);
   mlirLocationPrint(loc, printToStderr, NULL);
   assert(mlirDiagnosticGetNumNotes(diagnostic) == 0);
   fprintf(stderr, ">> end of diagnostic\n");
   return mlirLogicalResultSuccess();
 }
 
 void testDiagnostics() {
   MlirContext ctx = mlirContextCreate();
   MlirDiagnosticHandlerID id =
       mlirContextAttachDiagnosticHandler(ctx, errorHandler);
   MlirLocation loc = mlirLocationUnknownGet(ctx);
+  fprintf(stderr, "@test_diagnostics\n");
   mlirEmitError(loc, "test diagnostics");
   mlirContextDetachDiagnosticHandler(ctx, id);
   mlirEmitError(loc, "more test diagnostics");
+  // CHECK-LABEL: @test_diagnostics
+  // CHECK: processing diagnostic <<
+  // CHECK:   test diagnostics
+  // CHECK:   loc(unknown)
+  // CHECK: >> end of diagnostic
+  // CHECK-NOT: processing diagnostic
+  // CHECK:     more test diagnostics
 }
 
 int main() {
   MlirContext ctx = mlirContextCreate();
   mlirRegisterAllDialects(ctx);
-  MlirLocation location = mlirLocationUnknownGet(ctx);
-
-  MlirModule moduleOp = makeAdd(ctx, location);
-  MlirOperation module = mlirModuleGetOperation(moduleOp);
-  mlirOperationDump(module);
-  // clang-format off
-  // CHECK: module {
-  // CHECK:   func @add(%[[ARG0:.*]]: memref<?xf32>, %[[ARG1:.*]]: memref<?xf32>) {
-  // CHECK:     %[[C0:.*]] = constant 0 : index
-  // CHECK:     %[[DIM:.*]] = dim %[[ARG0]], %[[C0]] : memref<?xf32>
-  // CHECK:     %[[C1:.*]] = constant 1 : index
-  // CHECK:     scf.for %[[I:.*]] = %[[C0]] to %[[DIM]] step %[[C1]] {
-  // CHECK:       %[[LHS:.*]] = load %[[ARG0]][%[[I]]] : memref<?xf32>
-  // CHECK:       %[[RHS:.*]] = load %[[ARG1]][%[[I]]] : memref<?xf32>
-  // CHECK:       %[[SUM:.*]] = addf %[[LHS]], %[[RHS]] : f32
-  // CHECK:       store %[[SUM]], %[[ARG0]][%[[I]]] : memref<?xf32>
-  // CHECK:     }
-  // CHECK:     return
-  // CHECK:   }
-  // CHECK: }
-  // clang-format on
-
-  fprintf(stderr, "@stats\n");
-  int errcode = collectStats(module);
-  fprintf(stderr, "%d\n", errcode);
-  // clang-format off
-  // CHECK-LABEL: @stats
-  // CHECK: Number of operations: 13
-  // CHECK: Number of attributes: 4
-  // CHECK: Number of blocks: 3
-  // CHECK: Number of regions: 3
-  // CHECK: Number of values: 9
-  // CHECK: Number of block arguments: 3
-  // CHECK: Number of op results: 6
-  // CHECK: 0
-  // clang-format on
-
-  printFirstOfEach(ctx, module);
-  // clang-format off
-  // CHECK: Parent operation eq: 1
-  // CHECK: Block eq: 1
-  // CHECK:   %[[C0:.*]] = constant 0 : index
-  // CHECK:   %[[DIM:.*]] = dim %{{.*}}, %[[C0]] : memref<?xf32>
-  // CHECK:   %[[C1:.*]] = constant 1 : index
-  // CHECK:   scf.for %[[I:.*]] = %[[C0]] to %[[DIM]] step %[[C1]] {
-  // CHECK:     %[[LHS:.*]] = load %{{.*}}[%[[I]]] : memref<?xf32>
-  // CHECK:     %[[RHS:.*]] = load %{{.*}}[%[[I]]] : memref<?xf32>
-  // CHECK:     %[[SUM:.*]] = addf %[[LHS]], %[[RHS]] : f32
-  // CHECK:     store %[[SUM]], %{{.*}}[%[[I]]] : memref<?xf32>
-  // CHECK:   }
-  // CHECK: return
-  // CHECK: First operation: {{.*}} = constant 0 : index
-  // CHECK: Operation name: 'std.constant'
-  // CHECK: Identifier equal: 1
-  // CHECK: Terminator: return
-  // CHECK: Get attr 0: 0 : index
-  // CHECK: Get attr 0 by name: 0 : index
-  // CHECK: does_not_exist is null: 1
-  // CHECK: Result 0: {{.*}} = constant 0 : index
-  // CHECK: Value is null: 0
-  // CHECK: Result 0 type: index
-  // CHECK: Op with set attr: {{.*}} {custom_attr = true}
-  // CHECK: Remove attr: 1
-  // CHECK: Remove attr again: 0
-  // CHECK: Removed attr is null: 1
-  // CHECK: Op print with all flags: %{{.*}} = "std.constant"() {elts = opaque<"", "0xDEADBEEF"> : tensor<4xi32>, value = 0 : index} : () -> index loc(unknown)
-  // clang-format on
-
-  mlirModuleDestroy(moduleOp);
-
+  if (constructAndTraverseIr(ctx))
+    return 1;
   buildWithInsertionsAndPrint(ctx);
-  // clang-format off
-  // CHECK-LABEL:  "insertion.order.test"
-  // CHECK:      ^{{.*}}(%{{.*}}: i1
-  // CHECK:        "dummy.op1"
-  // CHECK-NEXT:   "dummy.op2"
-  // CHECK-NEXT:   "dummy.op3"
-  // CHECK-NEXT:   "dummy.op4"
-  // CHECK:      ^{{.*}}(%{{.*}}: i2
-  // CHECK:        "dummy.op5"
-  // CHECK:      ^{{.*}}(%{{.*}}: i3
-  // CHECK:        "dummy.op6"
-  // CHECK:      ^{{.*}}(%{{.*}}: i4
-  // CHECK:        "dummy.op7"
-  // clang-format on
 
-  // clang-format off
-  // CHECK-LABEL: @types
-  // CHECK: i32
-  // CHECK: si32
-  // CHECK: ui32
-  // CHECK: index
-  // CHECK: bf16
-  // CHECK: f16
-  // CHECK: f32
-  // CHECK: f64
-  // CHECK: none
-  // CHECK: complex<f32>
-  // CHECK: vector<2x3xf32>
-  // CHECK: tensor<2x3xf32>
-  // CHECK: tensor<*xf32>
-  // CHECK: memref<2x3xf32, 2>
-  // CHECK: memref<*xf32, 4>
-  // CHECK: tuple<memref<*xf32, 4>, f32>
-  // CHECK: (index, i1) -> (i16, i32, i64)
-  // CHECK: 0
-  // clang-format on
-  fprintf(stderr, "@types\n");
-  errcode = printStandardTypes(ctx);
-  fprintf(stderr, "%d\n", errcode);
-
-  // clang-format off
-  // CHECK-LABEL: @attrs
-  // CHECK: 2.000000e+00 : f64
-  // CHECK: f64
-  // CHECK: 42 : i32
-  // CHECK: true
-  // CHECK: #std.abc
-  // CHECK: "de"
-  // CHECK: @fgh
-  // CHECK: @ij::@fgh::@fgh
-  // CHECK: f32
-  // CHECK: unit
-  // CHECK: dense<{{\[}}[false, true]]> : tensor<1x2xi1>
-  // CHECK: dense<{{\[}}[0, 1]]> : tensor<1x2xui32>
-  // CHECK: dense<{{\[}}[0, 1]]> : tensor<1x2xi32>
-  // CHECK: dense<{{\[}}[0, 1]]> : tensor<1x2xui64>
-  // CHECK: dense<{{\[}}[0, 1]]> : tensor<1x2xi64>
-  // CHECK: dense<{{\[}}[0.000000e+00, 1.000000e+00]]> : tensor<1x2xf32>
-  // CHECK: dense<{{\[}}[0.000000e+00, 1.000000e+00]]> : tensor<1x2xf64>
-  // CHECK: dense<true> : tensor<1x2xi1>
-  // CHECK: dense<1> : tensor<1x2xi32>
-  // CHECK: dense<1> : tensor<1x2xi32>
-  // CHECK: dense<1> : tensor<1x2xi64>
-  // CHECK: dense<1> : tensor<1x2xi64>
-  // CHECK: dense<1.000000e+00> : tensor<1x2xf32>
-  // CHECK: dense<1.000000e+00> : tensor<1x2xf64>
-  // CHECK: 1.000000e+00 : f32
-  // CHECK: 1.000000e+00 : f64
-  // CHECK: sparse<[4, 7], [0.000000e+00, 1.000000e+00]> : tensor<1x2xf32>
-  // clang-format on
-  fprintf(stderr, "@attrs\n");
-  errcode = printStandardAttributes(ctx);
-  fprintf(stderr, "%d\n", errcode);
-
-  // clang-format off
-  // CHECK-LABEL: @affineMap
-  // CHECK: () -> ()
-  // CHECK: (d0, d1, d2)[s0, s1] -> ()
-  // CHECK: () -> (2)
-  // CHECK: (d0, d1, d2) -> (d0, d1, d2)
-  // CHECK: (d0, d1, d2) -> (d1, d2)
-  // CHECK: (d0, d1, d2) -> (d1, d2, d0)
-  // CHECK: (d0, d1, d2) -> (d1)
-  // CHECK: (d0, d1, d2) -> (d0)
-  // CHECK: (d0, d1, d2) -> (d2)
-  // CHECK: 0
-  // clang-format on
-  fprintf(stderr, "@affineMap\n");
-  errcode = printAffineMap(ctx);
-  fprintf(stderr, "%d\n", errcode);
-
-  // clang-format off
-  // CHECK: d5
-  // CHECK: s5
-  // CHECK: 5
-  // CHECK: d5 + s5
-  // CHECK: d5 * s5
-  // CHECK: d5 mod s5
-  // CHECK: d5 floordiv s5
-  // CHECK: d5 ceildiv s5
-  // CHECK: d5
-  // CHECK: s5
-  // CHECK: 0
-  // clang-format on
-  fprintf(stderr, "@affineExpr\n");
-  errcode = printAffineExpr(ctx);
-  fprintf(stderr, "%d\n", errcode);
-
-  fprintf(stderr, "@registration\n");
-  errcode = registerOnlyStd();
-  fprintf(stderr, "%d\n", errcode);
-  // clang-format off
-  // CHECK-LABEL: @registration
-  // CHECK: 0
-  // clang-format on
+  if (printStandardTypes(ctx))
+    return 2;
+  if (printStandardAttributes(ctx))
+    return 3;
+  if (printAffineMap(ctx))
+    return 4;
+  if (printAffineExpr(ctx))
+    return 5;
+  if (registerOnlyStd())
+    return 6;
 
   mlirContextDestroy(ctx);
 
-  fprintf(stderr, "@test_diagnostics\n");
   testDiagnostics();
-  // clang-format off
-  // CHECK-LABEL: @test_diagnostics
-  // CHECK: processing diagnostic <<
-  // CHECK:   test diagnostics
-  // CHECK:   loc(unknown)
-  // CHECK: >> end of diagnostic
-  // CHECK-NOT: processing diagnostic
-  // CHECK:     more test diagnostics
-
   return 0;
 }