Rename lvalue_load to load

Simon Camphausen · Simon Camphausen · commit 6931515b1b8b · 2024-08-20T07:45:16.000Z
diff --git a/mlir/include/mlir/Dialect/EmitC/IR/EmitC.td b/mlir/include/mlir/Dialect/EmitC/IR/EmitC.td
@@ -836,7 +836,7 @@ def EmitC_LogicalOrOp : EmitC_BinaryOp<"logical_or", [CExpression]> {
   let assemblyFormat = "operands attr-dict `:` type(operands)";
 }
 
-def EmitC_LValueLoadOp : EmitC_Op<"lvalue_load", [
+def EmitC_LoadOp : EmitC_Op<"load", [
   TypesMatchWith<"result type matches value type of 'operand'",
                   "operand", "result",
                   "::llvm::cast<LValueType>($_self).getValueType()">
diff --git a/mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td b/mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td
@@ -180,7 +180,7 @@ class EmitC_LValueOf<list<Type> allowedTypes> :
   ContainerType<
     AnyTypeOf<allowedTypes>,
     CPred<"::llvm::isa<::mlir::emitc::LValueType>($_self)">,
-    "::llvm::cast<::mlir::emitc::LValueType>($_self).getValue()",
+    "::llvm::cast<::mlir::emitc::LValueType>($_self).getValueType()",
     "emitc.lvalue",
     "::mlir::emitc::LValueType"
   >;
diff --git a/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp b/mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp
@@ -137,7 +137,7 @@ struct ConvertLoad final : public OpConversionPattern<memref::LoadOp> {
     auto subscript = rewriter.create<emitc::SubscriptOp>(
         op.getLoc(), arrayValue, operands.getIndices());
 
-    rewriter.replaceOpWithNewOp<emitc::LValueLoadOp>(op, resultTy, subscript);
+    rewriter.replaceOpWithNewOp<emitc::LoadOp>(op, resultTy, subscript);
     return success();
   }
 };
diff --git a/mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp b/mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp
@@ -85,7 +85,7 @@ SmallVector<Value> loadValues(const SmallVector<Value> &variables,
                               PatternRewriter &rewriter, Location loc) {
   return llvm::map_to_vector<>(variables, [&](Value var) {
     Type type = cast<emitc::LValueType>(var.getType()).getValueType();
-    return rewriter.create<emitc::LValueLoadOp>(loc, type, var).getResult();
+    return rewriter.create<emitc::LoadOp>(loc, type, var).getResult();
   });
 }
 
diff --git a/mlir/lib/Target/Cpp/TranslateToCpp.cpp b/mlir/lib/Target/Cpp/TranslateToCpp.cpp
@@ -384,12 +384,11 @@ static LogicalResult printOperation(CppEmitter &emitter,
   return emitter.emitOperand(assignOp.getValue());
 }
 
-static LogicalResult printOperation(CppEmitter &emitter,
-                                    emitc::LValueLoadOp lValueLoadOp) {
-  if (failed(emitter.emitAssignPrefix(*lValueLoadOp)))
+static LogicalResult printOperation(CppEmitter &emitter, emitc::LoadOp loadOp) {
+  if (failed(emitter.emitAssignPrefix(*loadOp)))
     return failure();
 
-  return emitter.emitOperand(lValueLoadOp.getOperand());
+  return emitter.emitOperand(loadOp.getOperand());
 }
 
 static LogicalResult printBinaryOperation(CppEmitter &emitter,
@@ -1551,11 +1550,11 @@ LogicalResult CppEmitter::emitOperation(Operation &op, bool trailingSemicolon) {
                 emitc::CallOpaqueOp, emitc::CastOp, emitc::CmpOp,
                 emitc::ConditionalOp, emitc::ConstantOp, emitc::DeclareFuncOp,
                 emitc::DivOp, emitc::ExpressionOp, emitc::ForOp, emitc::FuncOp,
-                emitc::GlobalOp, emitc::IfOp, emitc::IncludeOp,
-                emitc::LValueLoadOp, emitc::LogicalAndOp, emitc::LogicalNotOp,
-                emitc::LogicalOrOp, emitc::MulOp, emitc::RemOp, emitc::ReturnOp,
-                emitc::SubOp, emitc::SwitchOp, emitc::UnaryMinusOp,
-                emitc::UnaryPlusOp, emitc::VariableOp, emitc::VerbatimOp>(
+                emitc::GlobalOp, emitc::IfOp, emitc::IncludeOp, emitc::LoadOp,
+                emitc::LogicalAndOp, emitc::LogicalNotOp, emitc::LogicalOrOp,
+                emitc::MulOp, emitc::RemOp, emitc::ReturnOp, emitc::SubOp,
+                emitc::SwitchOp, emitc::UnaryMinusOp, emitc::UnaryPlusOp,
+                emitc::VariableOp, emitc::VerbatimOp>(
               [&](auto op) { return printOperation(*this, op); })
           // Func ops.
           .Case<func::CallOp, func::FuncOp, func::ReturnOp>(
diff --git a/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc.mlir b/mlir/test/Conversion/MemRefToEmitC/memref-to-emitc.mlir
@@ -21,7 +21,7 @@ func.func @memref_load(%i: index, %j: index) -> f32 {
   %0 = memref.alloca() : memref<4x8xf32>
 
   // CHECK-NEXT: %[[SUBSCRIPT:.*]] = emitc.subscript %[[ALLOCA]][%[[i]], %[[j]]] : (!emitc.array<4x8xf32>, index, index) -> !emitc.lvalue<f32>
-  // CHECK-NEXT: %[[LOAD:.*]] = emitc.lvalue_load %[[SUBSCRIPT]] : <f32>
+  // CHECK-NEXT: %[[LOAD:.*]] = emitc.load %[[SUBSCRIPT]] : <f32>
   %1 = memref.load %0[%i, %j] : memref<4x8xf32>
   // CHECK-NEXT: return %[[LOAD]] : f32
   return %1 : f32
diff --git a/mlir/test/Conversion/SCFToEmitC/for.mlir b/mlir/test/Conversion/SCFToEmitC/for.mlir
@@ -52,14 +52,14 @@ func.func @for_yield(%arg0 : index, %arg1 : index, %arg2 : index) -> (f32, f32)
 // CHECK-NEXT:    emitc.assign %[[VAL_3]] : f32 to %[[VAL_5]] : <f32>
 // CHECK-NEXT:    emitc.assign %[[VAL_4]] : f32 to %[[VAL_6]] : <f32>
 // CHECK-NEXT:    emitc.for %[[VAL_7:.*]] = %[[VAL_0]] to %[[VAL_1]] step %[[VAL_2]] {
-// CHECK-NEXT:      %[[VAL_8:.*]] = emitc.lvalue_load %[[VAL_5]] : <f32>
-// CHECK-NEXT:      %[[VAL_9:.*]] = emitc.lvalue_load %[[VAL_6]] : <f32>
+// CHECK-NEXT:      %[[VAL_8:.*]] = emitc.load %[[VAL_5]] : <f32>
+// CHECK-NEXT:      %[[VAL_9:.*]] = emitc.load %[[VAL_6]] : <f32>
 // CHECK-NEXT:      %[[VAL_10:.*]] = arith.addf %[[VAL_8]], %[[VAL_9]] : f32
 // CHECK-NEXT:      emitc.assign %[[VAL_10]] : f32 to %[[VAL_5]] : <f32>
 // CHECK-NEXT:      emitc.assign %[[VAL_10]] : f32 to %[[VAL_6]] : <f32>
 // CHECK-NEXT:    }
-// CHECK-NEXT:    %[[VAL_11:.*]] = emitc.lvalue_load %[[VAL_5]] : <f32>
-// CHECK-NEXT:    %[[VAL_12:.*]] = emitc.lvalue_load %[[VAL_6]] : <f32>
+// CHECK-NEXT:    %[[VAL_11:.*]] = emitc.load %[[VAL_5]] : <f32>
+// CHECK-NEXT:    %[[VAL_12:.*]] = emitc.load %[[VAL_6]] : <f32>
 // CHECK-NEXT:    return %[[VAL_11]], %[[VAL_12]] : f32, f32
 // CHECK-NEXT:  }
 
@@ -80,17 +80,17 @@ func.func @nested_for_yield(%arg0 : index, %arg1 : index, %arg2 : index) -> f32
 // CHECK-NEXT:    %[[VAL_4:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<f32>
 // CHECK-NEXT:    emitc.assign %[[VAL_3]] : f32 to %[[VAL_4]] : <f32>
 // CHECK-NEXT:    emitc.for %[[VAL_5:.*]] = %[[VAL_0]] to %[[VAL_1]] step %[[VAL_2]] {
-// CHECK-NEXT:      %[[VAL_6:.*]] = emitc.lvalue_load %[[VAL_4]] : <f32>
+// CHECK-NEXT:      %[[VAL_6:.*]] = emitc.load %[[VAL_4]] : <f32>
 // CHECK-NEXT:      %[[VAL_7:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<f32>
 // CHECK-NEXT:      emitc.assign %[[VAL_6]] : f32 to %[[VAL_7]] : <f32>
 // CHECK-NEXT:      emitc.for %[[VAL_8:.*]] = %[[VAL_0]] to %[[VAL_1]] step %[[VAL_2]] {
-// CHECK-NEXT:        %[[VAL_9:.*]] = emitc.lvalue_load %[[VAL_7]] : <f32>  
+// CHECK-NEXT:        %[[VAL_9:.*]] = emitc.load %[[VAL_7]] : <f32>  
 // CHECK-NEXT:        %[[VAL_10:.*]] = arith.addf %[[VAL_9]], %[[VAL_9]] : f32
 // CHECK-NEXT:        emitc.assign %[[VAL_10]] : f32 to %[[VAL_7]] : <f32>
 // CHECK-NEXT:      }
-// CHECK-NEXT:      %[[VAL_11:.*]] = emitc.lvalue_load %[[VAL_7]] : <f32>  
+// CHECK-NEXT:      %[[VAL_11:.*]] = emitc.load %[[VAL_7]] : <f32>  
 // CHECK-NEXT:      emitc.assign %[[VAL_11]] : f32 to %[[VAL_4]] : <f32>
 // CHECK-NEXT:    }
-// CHECK-NEXT:    %[[VAL_12:.*]] = emitc.lvalue_load %[[VAL_4]] : <f32>  
+// CHECK-NEXT:    %[[VAL_12:.*]] = emitc.load %[[VAL_4]] : <f32>  
 // CHECK-NEXT:    return %[[VAL_12]] : f32
 // CHECK-NEXT:  }
diff --git a/mlir/test/Conversion/SCFToEmitC/if.mlir b/mlir/test/Conversion/SCFToEmitC/if.mlir
@@ -66,7 +66,7 @@ func.func @test_if_yield(%arg0: i1, %arg1: f32) -> (i32, f64) {
 // CHECK-NEXT:      emitc.assign %[[VAL_7]] : i32 to %[[VAL_3]] : <i32>
 // CHECK-NEXT:      emitc.assign %[[VAL_8]] : f64 to %[[VAL_4]] : <f64>
 // CHECK-NEXT:    }
-// CHECK-NEXT:    %[[VAL_9:.*]] = emitc.lvalue_load %[[VAL_3]] : <i32>
-// CHECK-NEXT:    %[[VAL_10:.*]] = emitc.lvalue_load %[[VAL_4]] : <f64>
+// CHECK-NEXT:    %[[VAL_9:.*]] = emitc.load %[[VAL_3]] : <i32>
+// CHECK-NEXT:    %[[VAL_10:.*]] = emitc.load %[[VAL_4]] : <f64>
 // CHECK-NEXT:    return %[[VAL_9]], %[[VAL_10]] : i32, f64
 // CHECK-NEXT:  }
diff --git a/mlir/test/Conversion/SCFToEmitC/switch.mlir b/mlir/test/Conversion/SCFToEmitC/switch.mlir
@@ -94,8 +94,8 @@ func.func @switch_one_result(%arg0 : index) {
 // CHECK:             emitc.assign %[[VAL_7]] : i32 to %[[VAL_1]] : <i32>
 // CHECK:             emitc.assign %[[VAL_8]] : f32 to %[[VAL_2]] : <f32>
 // CHECK:           }
-// CHECK:           %[[RES_1:.*]] = emitc.lvalue_load %[[VAL_1]] : <i32>
-// CHECK:           %[[RES_2:.*]] = emitc.lvalue_load %[[VAL_2]] : <f32>
+// CHECK:           %[[RES_1:.*]] = emitc.load %[[VAL_1]] : <i32>
+// CHECK:           %[[RES_2:.*]] = emitc.load %[[VAL_2]] : <f32>
 // CHECK:           return %[[RES_1]], %[[RES_2]] : i32, f32
 // CHECK:         }
 func.func @switch_two_results(%arg0 : index) -> (i32, f32) {
diff --git a/mlir/test/Dialect/EmitC/invalid_ops.mlir b/mlir/test/Dialect/EmitC/invalid_ops.mlir
@@ -265,7 +265,7 @@ func.func @test_expression_illegal_op(%arg0 : i1) -> i32 {
   // expected-error @+1 {{'emitc.expression' op contains an unsupported operation}}
   %r = emitc.expression : i32 {
     %x = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i32>
-    %y = emitc.lvalue_load %x : <i32>
+    %y = emitc.load %x : <i32>
     emitc.yield %y : i32
   }
   return %r : i32
diff --git a/mlir/test/Dialect/EmitC/ops.mlir b/mlir/test/Dialect/EmitC/ops.mlir
@@ -246,7 +246,7 @@ emitc.global const @myconstant : !emitc.array<2xi16> = dense<2>
 func.func @use_global(%i: index) -> f32 {
   %0 = emitc.get_global @myglobal : !emitc.array<2xf32>
   %1 = emitc.subscript %0[%i] : (!emitc.array<2xf32>, index) -> !emitc.lvalue<f32>
-  %2 = emitc.lvalue_load %1 : <f32>
+  %2 = emitc.load %1 : <f32>
   return %2 : f32
 }
 
diff --git a/mlir/test/Target/Cpp/expressions.mlir b/mlir/test/Target/Cpp/expressions.mlir
@@ -45,7 +45,7 @@ func.func @single_use(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32) -> i32 {
     emitc.assign %arg0 : i32 to %v : !emitc.lvalue<i32>
     emitc.yield
   }
-  %v_load = emitc.lvalue_load %v : !emitc.lvalue<i32>
+  %v_load = emitc.load %v : !emitc.lvalue<i32>
   return %v_load : i32
 }
 
@@ -234,7 +234,7 @@ func.func @multiple_uses(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32) -> i32
   }
   %q = "emitc.variable"(){value = #emitc.opaque<"">} : () -> !emitc.lvalue<i1>
   emitc.assign %e : i1 to %q : !emitc.lvalue<i1>
-  %v_load = emitc.lvalue_load %v : !emitc.lvalue<i32>
+  %v_load = emitc.load %v : !emitc.lvalue<i32>
   return %v_load : i32
 }
 
@@ -291,7 +291,7 @@ func.func @different_expressions(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32)
     emitc.assign %arg0 : i32 to %v : !emitc.lvalue<i32>
     emitc.yield
   }
-  %v_load = emitc.lvalue_load %v : !emitc.lvalue<i32>
+  %v_load = emitc.load %v : !emitc.lvalue<i32>
   return %v_load : i32
 }
 
@@ -339,6 +339,6 @@ func.func @expression_with_subscript_user(%arg0: !emitc.ptr<!emitc.opaque<"void"
     emitc.yield %0 : !emitc.ptr<i32>
   }
   %res = emitc.subscript %0[%c0] : (!emitc.ptr<i32>, i64) -> !emitc.lvalue<i32>
-  %res_load = emitc.lvalue_load %res : !emitc.lvalue<i32>
+  %res_load = emitc.load %res : !emitc.lvalue<i32>
   return %res_load : i32
 }
diff --git a/mlir/test/Target/Cpp/for.mlir b/mlir/test/Target/Cpp/for.mlir
@@ -47,17 +47,17 @@ func.func @test_for_yield() {
   emitc.assign %s0 : i32 to %2 : !emitc.lvalue<i32>
   emitc.assign %p0 : f32 to %3 : !emitc.lvalue<f32>
   emitc.for %iter = %start to %stop step %step {
-    %4 = emitc.lvalue_load %2 : !emitc.lvalue<i32>
+    %4 = emitc.load %2 : !emitc.lvalue<i32>
     %sn = emitc.call_opaque "add"(%4, %iter) : (i32, index) -> i32
-    %5 = emitc.lvalue_load %3 : !emitc.lvalue<f32>
+    %5 = emitc.load %3 : !emitc.lvalue<f32>
     %pn = emitc.call_opaque "mul"(%5, %iter) : (f32, index) -> f32
     emitc.assign %sn : i32 to %2 : !emitc.lvalue<i32>
     emitc.assign %pn : f32 to %3 : !emitc.lvalue<f32>
     emitc.yield
   }
-  %6 = emitc.lvalue_load %2 : !emitc.lvalue<i32>
+  %6 = emitc.load %2 : !emitc.lvalue<i32>
   emitc.assign %6 : i32 to %0 : !emitc.lvalue<i32>
-  %7 = emitc.lvalue_load %3 : !emitc.lvalue<f32>
+  %7 = emitc.load %3 : !emitc.lvalue<f32>
   emitc.assign %7 : f32 to %1 : !emitc.lvalue<f32>
 
   return
@@ -144,17 +144,17 @@ func.func @test_for_yield_2() {
   emitc.assign %s0 : i32 to %2 : !emitc.lvalue<i32>
   emitc.assign %p0 : f32 to %3 : !emitc.lvalue<f32>
   emitc.for %iter = %start to %stop step %step {
-    %4 = emitc.lvalue_load %2 : !emitc.lvalue<i32>
+    %4 = emitc.load %2 : !emitc.lvalue<i32>
     %sn = emitc.call_opaque "add"(%4, %iter) : (i32, index) -> i32
-    %5 = emitc.lvalue_load %3 : !emitc.lvalue<f32>
+    %5 = emitc.load %3 : !emitc.lvalue<f32>
     %pn = emitc.call_opaque "mul"(%5, %iter) : (f32, index) -> f32
     emitc.assign %sn : i32 to %2 : !emitc.lvalue<i32>
     emitc.assign %pn : f32 to %3 : !emitc.lvalue<f32>
     emitc.yield
   }
-  %6 = emitc.lvalue_load %2 : !emitc.lvalue<i32>
+  %6 = emitc.load %2 : !emitc.lvalue<i32>
   emitc.assign %6 : i32 to %0 : !emitc.lvalue<i32>
-  %7 = emitc.lvalue_load %3 : !emitc.lvalue<f32>
+  %7 = emitc.load %3 : !emitc.lvalue<f32>
   emitc.assign %7 : f32 to %1 : !emitc.lvalue<f32>
 
   return
diff --git a/mlir/test/Target/Cpp/global.mlir b/mlir/test/Target/Cpp/global.mlir
@@ -39,7 +39,7 @@ emitc.global @opaque_init : !emitc.opaque<"char"> = #emitc.opaque<"CHAR_MIN">
 
 func.func @use_global_scalar_read() -> i32 {
   %0 = emitc.get_global @myglobal_int : !emitc.lvalue<i32>
-  %1 = emitc.lvalue_load %0 : !emitc.lvalue<i32>
+  %1 = emitc.load %0 : !emitc.lvalue<i32>
   return %1 : i32
 }
 // CPP-DEFAULT-LABEL: int32_t use_global_scalar_read()
@@ -69,7 +69,7 @@ func.func @use_global_scalar_write(%arg0 : i32) {
 func.func @use_global_array_read(%i: index) -> f32 {
   %0 = emitc.get_global @myglobal : !emitc.array<2xf32>
   %1 = emitc.subscript %0[%i] : (!emitc.array<2xf32>, index) -> !emitc.lvalue<f32>
-  %2 = emitc.lvalue_load %1 : !emitc.lvalue<f32>
+  %2 = emitc.load %1 : <f32>
   return %2 : f32
 }
 // CPP-DEFAULT-LABEL: float use_global_array_read
diff --git a/mlir/test/Target/Cpp/lvalue.mlir b/mlir/test/Target/Cpp/lvalue.mlir
@@ -6,7 +6,7 @@ emitc.func @lvalue_variables(%v1: i32, %v2: i32) -> i32 {
   emitc.assign %val : i32 to %variable : !emitc.lvalue<i32>
   %addr = emitc.apply "&"(%variable) : (!emitc.lvalue<i32>) -> !emitc.ptr<i32>
   emitc.call @zero (%addr) : (!emitc.ptr<i32>) -> ()
-  %updated_val = emitc.lvalue_load %variable : !emitc.lvalue<i32>
+  %updated_val = emitc.load %variable : !emitc.lvalue<i32>
   %neg_one = "emitc.constant"() {value = -1 : i32} : () -> i32
   emitc.assign %neg_one : i32 to %variable : !emitc.lvalue<i32>
   emitc.return %updated_val : i32
diff --git a/mlir/test/Target/Cpp/member.mlir b/mlir/test/Target/Cpp/member.mlir
@@ -5,7 +5,7 @@ func.func @member(%arg0: !emitc.lvalue<!emitc.opaque<"mystruct">>, %arg1: i32) {
   emitc.assign %arg1 : i32 to %0 : !emitc.lvalue<i32> 
 
   %1 = "emitc.member" (%arg0) {member = "b"} : (!emitc.lvalue<!emitc.opaque<"mystruct">>) -> !emitc.lvalue<i32>
-  %2 = emitc.lvalue_load %1 : !emitc.lvalue<i32>
+  %2 = emitc.load %1 : !emitc.lvalue<i32>
   %3 = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i32>
   emitc.assign %2 : i32 to %3 : !emitc.lvalue<i32>
 
@@ -24,7 +24,7 @@ func.func @member_of_pointer(%arg0: !emitc.lvalue<!emitc.ptr<!emitc.opaque<"myst
   emitc.assign %arg1 : i32 to %0 : !emitc.lvalue<i32>
 
   %1 = "emitc.member_of_ptr" (%arg0) {member = "b"} : (!emitc.lvalue<!emitc.ptr<!emitc.opaque<"mystruct">>>) -> !emitc.lvalue<i32>
-  %2 = emitc.lvalue_load %1 : !emitc.lvalue<i32>
+  %2 = emitc.load %1 : !emitc.lvalue<i32>
   %3 = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i32>
   emitc.assign %2 : i32 to %3 : !emitc.lvalue<i32>
 
diff --git a/mlir/test/Target/Cpp/subscript.mlir b/mlir/test/Target/Cpp/subscript.mlir
@@ -4,7 +4,7 @@
 func.func @load_store_array(%arg0: !emitc.array<4x8xf32>, %arg1: !emitc.array<3x5xf32>, %arg2: index, %arg3: index) {
   %0 = emitc.subscript %arg0[%arg2, %arg3] : (!emitc.array<4x8xf32>, index, index) -> !emitc.lvalue<f32>
   %1 = emitc.subscript %arg1[%arg2, %arg3] : (!emitc.array<3x5xf32>, index, index) -> !emitc.lvalue<f32>
-  %2 = emitc.lvalue_load %0 : <f32>
+  %2 = emitc.load %0 : <f32>
   emitc.assign %2 : f32 to %1 : !emitc.lvalue<f32>
   return
 }
@@ -22,7 +22,7 @@ func.func @load_store_array(%arg0: !emitc.array<4x8xf32>, %arg1: !emitc.array<3x
 func.func @load_store_pointer(%arg0: !emitc.ptr<f32>, %arg1: !emitc.ptr<f32>, %arg2: index, %arg3: index) {
   %0 = emitc.subscript %arg0[%arg2] : (!emitc.ptr<f32>, index) -> !emitc.lvalue<f32>
   %1 = emitc.subscript %arg1[%arg3] : (!emitc.ptr<f32>, index) -> !emitc.lvalue<f32>
-  %2 = emitc.lvalue_load %0 : <f32>
+  %2 = emitc.load %0 : <f32>
   emitc.assign %2 : f32 to %1 : <f32>
   return
 }
@@ -40,7 +40,7 @@ func.func @load_store_pointer(%arg0: !emitc.ptr<f32>, %arg1: !emitc.ptr<f32>, %a
 func.func @load_store_opaque(%arg0: !emitc.opaque<"std::map<char, int>">, %arg1: !emitc.opaque<"std::map<char, int>">, %arg2: !emitc.opaque<"char">, %arg3: !emitc.opaque<"char">) {
   %0 = emitc.subscript %arg0[%arg2] : (!emitc.opaque<"std::map<char, int>">, !emitc.opaque<"char">) -> !emitc.lvalue<!emitc.opaque<"int">>
   %1 = emitc.subscript %arg1[%arg3] : (!emitc.opaque<"std::map<char, int>">, !emitc.opaque<"char">) -> !emitc.lvalue<!emitc.opaque<"int">>
-  %2 = emitc.lvalue_load %0 : <!emitc.opaque<"int">>
+  %2 = emitc.load %0 : <!emitc.opaque<"int">>
   emitc.assign %2 : !emitc.opaque<"int"> to %1 : <!emitc.opaque<"int">>
   return
 }
@@ -64,12 +64,12 @@ emitc.func @call_arg(%arg0: !emitc.array<4x8xf32>, %i: i32, %j: i16,
   %0 = emitc.subscript %arg0[%i, %j] : (!emitc.array<4x8xf32>, i32, i16) -> !emitc.lvalue<f32>
   %1 = emitc.subscript %arg0[%j, %k] : (!emitc.array<4x8xf32>, i16, i8) -> !emitc.lvalue<f32>
 
-  %2 = emitc.lvalue_load %0 : <f32>
+  %2 = emitc.load %0 : <f32>
   emitc.call @func1 (%2) : (f32) -> ()
-  %3 = emitc.lvalue_load %1 : <f32>
+  %3 = emitc.load %1 : <f32>
   emitc.call_opaque "func2" (%3) : (f32) -> ()
-  %4 = emitc.lvalue_load %0 : <f32>
-  %5 = emitc.lvalue_load %1 : <f32>
+  %4 = emitc.load %0 : <f32>
+  %5 = emitc.load %1 : <f32>
   emitc.call_opaque "func3" (%4, %5) { args = [1 : index, 0 : index] } : (f32, f32) -> ()
   emitc.return
 }

Original file line number	Diff line number	Diff line change
`@@ -836,7 +836,7 @@ def EmitC_LogicalOrOp : EmitC_BinaryOp<"logical_or", [CExpression]> {`
`836`	`836`	let assemblyFormat = "operands attr-dict `:` type(operands)";
`837`	`837`	`}`
`838`	`838`
`839`		`-def EmitC_LValueLoadOp : EmitC_Op<"lvalue_load", [`
	`839`	`+def EmitC_LoadOp : EmitC_Op<"load", [`
`840`	`840`	`TypesMatchWith<"result type matches value type of 'operand'",`
`841`	`841`	`"operand", "result",`
`842`	`842`	`"::llvm::cast<LValueType>($_self).getValueType()">`
Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ struct ConvertLoad final : public OpConversionPattern<memref::LoadOp> {`
`137`	`137`	`auto subscript = rewriter.create<emitc::SubscriptOp>(`
`138`	`138`	`op.getLoc(), arrayValue, operands.getIndices());`
`139`	`139`
`140`		`- rewriter.replaceOpWithNewOp<emitc::LValueLoadOp>(op, resultTy, subscript);`
	`140`	`+ rewriter.replaceOpWithNewOp<emitc::LoadOp>(op, resultTy, subscript);`
`141`	`141`	`return success();`
`142`	`142`	`}`
`143`	`143`	`};`
Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,7 @@ SmallVector<Value> loadValues(const SmallVector<Value> &variables,`
`85`	`85`	`PatternRewriter &rewriter, Location loc) {`
`86`	`86`	`return llvm::map_to_vector<>(variables, [&](Value var) {`
`87`	`87`	`Type type = cast<emitc::LValueType>(var.getType()).getValueType();`
`88`		`- return rewriter.create<emitc::LValueLoadOp>(loc, type, var).getResult();`
	`88`	`+ return rewriter.create<emitc::LoadOp>(loc, type, var).getResult();`
`89`	`89`	`});`
`90`	`90`	`}`
`91`	`91`
Original file line number	Diff line number	Diff line change
`@@ -265,7 +265,7 @@ func.func @test_expression_illegal_op(%arg0 : i1) -> i32 {`
`265`	`265`	`// expected-error @+1 {{'emitc.expression' op contains an unsupported operation}}`
`266`	`266`	`%r = emitc.expression : i32 {`
`267`	`267`	`%x = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i32>`
`268`		`- %y = emitc.lvalue_load %x : <i32>`
	`268`	`+ %y = emitc.load %x : <i32>`
`269`	`269`	`emitc.yield %y : i32`
`270`	`270`	`}`
`271`	`271`	`return %r : i32`