diff --git a/bindings/python/iree/runtime/hal.h b/bindings/python/iree/runtime/hal.h
index e0d93b6..4230260 100644
--- a/bindings/python/iree/runtime/hal.h
+++ b/bindings/python/iree/runtime/hal.h
@@ -110,8 +110,9 @@
 
   void FillZero(iree_device_size_t byte_offset,
                 iree_device_size_t byte_length) {
-    CheckApiStatus(iree_hal_buffer_zero(raw_ptr(), byte_offset, byte_length),
-                   "Error zero filling buffer");
+    CheckApiStatus(
+        iree_hal_buffer_map_zero(raw_ptr(), byte_offset, byte_length),
+        "Error zero filling buffer");
   }
 
   // TODO(laurenzo): make this take element_type instead.
diff --git a/bindings/tflite/tensor.c b/bindings/tflite/tensor.c
index 1d65159..3f52322 100644
--- a/bindings/tflite/tensor.c
+++ b/bindings/tflite/tensor.c
@@ -246,10 +246,10 @@
   IREE_TRACE_ZONE_BEGIN(z0);
   IREE_TRACE_ZONE_APPEND_VALUE(z0, tensor->buffer_mapping.contents.data_length);
 
-  // NOTE: we could use a iree_hal_buffer_write_data here but we already have
-  // the buffer mapped. If we knew the user would never use TfLiteTensorData and
-  // could avoid mapping the buffer it would be more efficient and portable to
-  // do the iree_hal_buffer_copy_data.
+  // NOTE: we could use a iree_hal_buffer_map_write here but we already
+  // have the buffer mapped. If we knew the user would never use
+  // TfLiteTensorData and could avoid mapping the buffer it would be more
+  // efficient and portable to do the iree_hal_buffer_map_copy.
   memcpy(tensor->buffer_mapping.contents.data, input_data, input_data_size);
 
   IREE_TRACE_ZONE_END(z0);
@@ -266,7 +266,7 @@
   IREE_TRACE_ZONE_APPEND_VALUE(
       z0, output_tensor->buffer_mapping.contents.data_length);
 
-  // NOTE: as with above we should use an iree_hal_buffer_read_data here.
+  // NOTE: as with above we should use an iree_hal_buffer_map_read here.
   memcpy(output_data, output_tensor->buffer_mapping.contents.data,
          output_data_size);
 
diff --git a/iree/hal/allocator.h b/iree/hal/allocator.h
index 2c99da4..71a1583 100644
--- a/iree/hal/allocator.h
+++ b/iree/hal/allocator.h
@@ -139,7 +139,7 @@
   // Indicates that the buffer can be used as a transfer source or target on the
   // a device queue (such as being the source or target of a DMA operation,
   // etc). If not set then the buffer may still be usable for
-  // iree_hal_buffer_copy_data but not with queued operations.
+  // iree_hal_buffer_map_copy but not with queued operations.
   IREE_HAL_BUFFER_COMPATIBILITY_QUEUE_TRANSFER = 1u << 10,
 
   // Indicates that the buffer can be used as an input/output to a dispatch.
diff --git a/iree/hal/buffer.c b/iree/hal/buffer.c
index cb2b4ab..77b64f6 100644
--- a/iree/hal/buffer.c
+++ b/iree/hal/buffer.c
@@ -503,17 +503,17 @@
 // Transfer
 //===----------------------------------------------------------------------===//
 
-IREE_API_EXPORT iree_status_t
-iree_hal_buffer_zero(iree_hal_buffer_t* buffer, iree_device_size_t byte_offset,
-                     iree_device_size_t byte_length) {
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_zero(
+    iree_hal_buffer_t* buffer, iree_device_size_t byte_offset,
+    iree_device_size_t byte_length) {
   const uint8_t zero = 0;
-  return iree_hal_buffer_fill(buffer, byte_offset, byte_length, &zero, 1);
+  return iree_hal_buffer_map_fill(buffer, byte_offset, byte_length, &zero, 1);
 }
 
-IREE_API_EXPORT iree_status_t
-iree_hal_buffer_fill(iree_hal_buffer_t* buffer, iree_device_size_t byte_offset,
-                     iree_device_size_t byte_length, const void* pattern,
-                     iree_host_size_t pattern_length) {
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_fill(
+    iree_hal_buffer_t* buffer, iree_device_size_t byte_offset,
+    iree_device_size_t byte_length, const void* pattern,
+    iree_host_size_t pattern_length) {
   IREE_ASSERT_ARGUMENT(buffer);
   IREE_ASSERT_ARGUMENT(pattern);
 
@@ -600,7 +600,7 @@
   return status;
 }
 
-IREE_API_EXPORT iree_status_t iree_hal_buffer_read_data(
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_read(
     iree_hal_buffer_t* source_buffer, iree_device_size_t source_offset,
     void* target_buffer, iree_device_size_t data_length) {
   if (data_length == 0) {
@@ -624,7 +624,7 @@
   return iree_ok_status();
 }
 
-IREE_API_EXPORT iree_status_t iree_hal_buffer_write_data(
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_write(
     iree_hal_buffer_t* target_buffer, iree_device_size_t target_offset,
     const void* source_buffer, iree_device_size_t data_length) {
   if (data_length == 0) {
@@ -655,7 +655,7 @@
   return status;
 }
 
-IREE_API_EXPORT iree_status_t iree_hal_buffer_copy_data(
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_copy(
     iree_hal_buffer_t* source_buffer, iree_device_size_t source_offset,
     iree_hal_buffer_t* target_buffer, iree_device_size_t target_offset,
     iree_device_size_t data_length) {
diff --git a/iree/hal/buffer.h b/iree/hal/buffer.h
index 6af80fa..9ff8bdc 100644
--- a/iree/hal/buffer.h
+++ b/iree/hal/buffer.h
@@ -386,9 +386,9 @@
 // queues; using this synchronous function may incur additional cache flushes
 // and synchronous blocking behavior and is not supported on all buffer types.
 // See iree_hal_command_buffer_fill_buffer.
-IREE_API_EXPORT iree_status_t
-iree_hal_buffer_zero(iree_hal_buffer_t* buffer, iree_device_size_t byte_offset,
-                     iree_device_size_t byte_length);
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_zero(
+    iree_hal_buffer_t* buffer, iree_device_size_t byte_offset,
+    iree_device_size_t byte_length);
 
 // Sets a range of the buffer to the given value.
 // Only |pattern_length| values with 1, 2, or 4 bytes are supported.
@@ -400,10 +400,10 @@
 // queues; using this synchronous function may incur additional cache flushes
 // and synchronous blocking behavior and is not supported on all buffer types.
 // See iree_hal_command_buffer_fill_buffer.
-IREE_API_EXPORT iree_status_t
-iree_hal_buffer_fill(iree_hal_buffer_t* buffer, iree_device_size_t byte_offset,
-                     iree_device_size_t byte_length, const void* pattern,
-                     iree_host_size_t pattern_length);
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_fill(
+    iree_hal_buffer_t* buffer, iree_device_size_t byte_offset,
+    iree_device_size_t byte_length, const void* pattern,
+    iree_host_size_t pattern_length);
 
 // Reads a block of data from the buffer at the given offset.
 //
@@ -413,7 +413,7 @@
 // queues; using this synchronous function may incur additional cache flushes
 // and synchronous blocking behavior and is not supported on all buffer types.
 // See iree_hal_command_buffer_copy_buffer.
-IREE_API_EXPORT iree_status_t iree_hal_buffer_read_data(
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_read(
     iree_hal_buffer_t* source_buffer, iree_device_size_t source_offset,
     void* target_buffer, iree_device_size_t data_length);
 
@@ -427,7 +427,7 @@
 // and synchronous blocking behavior and is not supported on all buffer types.
 // See iree_hal_command_buffer_update_buffer and
 // iree_hal_command_buffer_copy_buffer.
-IREE_API_EXPORT iree_status_t iree_hal_buffer_write_data(
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_write(
     iree_hal_buffer_t* target_buffer, iree_device_size_t target_offset,
     const void* source_buffer, iree_device_size_t data_length);
 
@@ -441,7 +441,7 @@
 // queues; using this synchronous function may incur additional cache flushes
 // and synchronous blocking behavior and is not supported on all buffer types.
 // See iree_hal_command_buffer_copy_buffer.
-IREE_API_EXPORT iree_status_t iree_hal_buffer_copy_data(
+IREE_API_EXPORT iree_status_t iree_hal_buffer_map_copy(
     iree_hal_buffer_t* source_buffer, iree_device_size_t source_offset,
     iree_hal_buffer_t* target_buffer, iree_device_size_t target_offset,
     iree_device_size_t data_length);
diff --git a/iree/hal/cts/buffer_mapping_test.h b/iree/hal/cts/buffer_mapping_test.h
index d1d8cde..2810efa 100644
--- a/iree/hal/cts/buffer_mapping_test.h
+++ b/iree/hal/cts/buffer_mapping_test.h
@@ -31,9 +31,9 @@
 //
 // Note that most of these tests first write into a buffer using one or more
 // functions then read the (possibly partial) contents of that buffer using
-// `iree_hal_buffer_read_data`. As the buffer read implementation is nontrivial,
-// particularly on implementations with complex host/device splits, test
-// failures may indicate issues in either the code doing the writing or the
+// `iree_hal_buffer_map_read`. As the buffer read implementation is
+// nontrivial, particularly on implementations with complex host/device splits,
+// test failures may indicate issues in either the code doing the writing or the
 // code doing the reading.
 //
 // Where applicable, tests for each function are organized in increasing order
@@ -87,11 +87,11 @@
 
   // Zero the entire buffer.
   IREE_ASSERT_OK(
-      iree_hal_buffer_zero(buffer, /*byte_offset=*/0, IREE_WHOLE_BUFFER));
+      iree_hal_buffer_map_zero(buffer, /*byte_offset=*/0, IREE_WHOLE_BUFFER));
 
   // Check that the contents match what we expect.
   std::vector<uint8_t> actual_data(kDefaultAllocationSize);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(
       buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
   std::vector<uint8_t> reference_buffer(kDefaultAllocationSize);
   std::memset(reference_buffer.data(), 0, kDefaultAllocationSize);
@@ -107,15 +107,15 @@
 
   // Fill the entire buffer then zero only a segment of it.
   uint8_t fill_value = 0xFF;
-  IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, /*byte_offset=*/0,
-                                      IREE_WHOLE_BUFFER, &fill_value,
-                                      sizeof(fill_value)));
+  IREE_ASSERT_OK(iree_hal_buffer_map_fill(buffer, /*byte_offset=*/0,
+                                          IREE_WHOLE_BUFFER, &fill_value,
+                                          sizeof(fill_value)));
   IREE_ASSERT_OK(
-      iree_hal_buffer_zero(buffer, /*byte_offset=*/4, /*byte_length=*/8));
+      iree_hal_buffer_map_zero(buffer, /*byte_offset=*/4, /*byte_length=*/8));
 
   // Check that the contents match what we expect.
   std::vector<uint8_t> actual_data(buffer_size);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(
       buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
   std::vector<uint8_t> reference_buffer{0xFF, 0xFF, 0xFF, 0xFF,  //
                                         0x00, 0x00, 0x00, 0x00,  //
@@ -133,9 +133,9 @@
 
   // Fill the entire buffer.
   uint8_t fill_value = 0xFF;
-  IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, /*byte_offset=*/0,
-                                      IREE_WHOLE_BUFFER, &fill_value,
-                                      sizeof(fill_value)));
+  IREE_ASSERT_OK(iree_hal_buffer_map_fill(buffer, /*byte_offset=*/0,
+                                          IREE_WHOLE_BUFFER, &fill_value,
+                                          sizeof(fill_value)));
 
   // Create a subspan.
   iree_device_size_t subspan_length = 8;
@@ -144,12 +144,12 @@
                                          subspan_length, &buffer_subspan));
 
   // Zero part of the subspan.
-  IREE_ASSERT_OK(iree_hal_buffer_zero(buffer_subspan, /*byte_offset=*/4,
-                                      /*byte_length=*/4));
+  IREE_ASSERT_OK(iree_hal_buffer_map_zero(buffer_subspan, /*byte_offset=*/4,
+                                          /*byte_length=*/4));
 
   // Check that the contents match what we expect.
   std::vector<uint8_t> actual_data(buffer_size);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(
       buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
   std::vector<uint8_t> reference_buffer{0xFF, 0xFF, 0xFF, 0xFF,  //
                                         0xFF, 0xFF, 0xFF, 0xFF,  //
@@ -158,9 +158,9 @@
   EXPECT_THAT(actual_data, ContainerEq(reference_buffer));
   // Also check the subspan.
   std::vector<uint8_t> actual_data_subspan(subspan_length);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(buffer_subspan, /*source_offset=*/0,
-                                           actual_data_subspan.data(),
-                                           actual_data_subspan.size()));
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(buffer_subspan, /*source_offset=*/0,
+                                          actual_data_subspan.data(),
+                                          actual_data_subspan.size()));
   std::vector<uint8_t> reference_buffer_subspan{0xFF, 0xFF, 0xFF, 0xFF,  //
                                                 0x00, 0x00, 0x00, 0x00};
   EXPECT_THAT(actual_data_subspan, ContainerEq(reference_buffer_subspan));
@@ -174,16 +174,17 @@
   AllocateUninitializedBuffer(kDefaultAllocationSize, &buffer);
 
   // Zero the whole buffer then "fill" 0 bytes with a different pattern.
-  IREE_ASSERT_OK(iree_hal_buffer_zero(buffer, 0, IREE_WHOLE_BUFFER));
+  IREE_ASSERT_OK(iree_hal_buffer_map_zero(buffer, 0, IREE_WHOLE_BUFFER));
   uint8_t fill_value = 0xFF;
-  IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, /*byte_offset=*/0,
-                                      /*byte_length=*/0,  // <---- empty!
-                                      /*pattern=*/&fill_value,
-                                      /*pattern_length=*/sizeof(fill_value)));
+  IREE_ASSERT_OK(
+      iree_hal_buffer_map_fill(buffer, /*byte_offset=*/0,
+                               /*byte_length=*/0,  // <---- empty!
+                               /*pattern=*/&fill_value,
+                               /*pattern_length=*/sizeof(fill_value)));
 
   // Check that the buffer is still all zeroes.
   std::vector<uint8_t> actual_data(kDefaultAllocationSize);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(
       buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
   std::vector<uint8_t> reference_buffer(kDefaultAllocationSize);
   std::memset(reference_buffer.data(), 0, kDefaultAllocationSize);
@@ -197,14 +198,15 @@
   AllocateUninitializedBuffer(kDefaultAllocationSize, &buffer);
 
   uint8_t fill_value = 0xFF;
-  IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, /*byte_offset=*/0,
-                                      /*byte_length=*/IREE_WHOLE_BUFFER,
-                                      /*pattern=*/&fill_value,
-                                      /*pattern_length=*/sizeof(fill_value)));
+  IREE_ASSERT_OK(
+      iree_hal_buffer_map_fill(buffer, /*byte_offset=*/0,
+                               /*byte_length=*/IREE_WHOLE_BUFFER,
+                               /*pattern=*/&fill_value,
+                               /*pattern_length=*/sizeof(fill_value)));
 
   // Check that the buffer is filled with the pattern.
   std::vector<uint8_t> actual_data(kDefaultAllocationSize);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(
       buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
   std::vector<uint8_t> reference_buffer(kDefaultAllocationSize);
   std::memset(reference_buffer.data(), fill_value, kDefaultAllocationSize);
@@ -219,16 +221,17 @@
   AllocateUninitializedBuffer(buffer_size, &buffer);
 
   // Zero the entire buffer then fill only a segment of it.
-  IREE_ASSERT_OK(iree_hal_buffer_zero(buffer, 0, IREE_WHOLE_BUFFER));
+  IREE_ASSERT_OK(iree_hal_buffer_map_zero(buffer, 0, IREE_WHOLE_BUFFER));
   uint8_t fill_value = 0xFF;
-  IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, /*byte_offset=*/4,
-                                      /*byte_length=*/8,
-                                      /*pattern=*/&fill_value,
-                                      /*pattern_length=*/sizeof(fill_value)));
+  IREE_ASSERT_OK(
+      iree_hal_buffer_map_fill(buffer, /*byte_offset=*/4,
+                               /*byte_length=*/8,
+                               /*pattern=*/&fill_value,
+                               /*pattern_length=*/sizeof(fill_value)));
 
   // Check that only the segment of the buffer is filled with the pattern.
   std::vector<uint8_t> actual_data(buffer_size);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(
       buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
   std::vector<uint8_t> reference_offset_buffer{0x00, 0x00, 0x00, 0x00,  //
                                                0xFF, 0xFF, 0xFF, 0xFF,  //
@@ -245,7 +248,7 @@
   AllocateUninitializedBuffer(buffer_size, &buffer);
 
   // Zero the entire buffer.
-  IREE_ASSERT_OK(iree_hal_buffer_zero(buffer, 0, IREE_WHOLE_BUFFER));
+  IREE_ASSERT_OK(iree_hal_buffer_map_zero(buffer, 0, IREE_WHOLE_BUFFER));
 
   // Create a subspan.
   iree_device_size_t subspan_length = 8;
@@ -255,14 +258,15 @@
 
   // Fill part of the subspan.
   uint8_t fill_value = 0xFF;
-  IREE_ASSERT_OK(iree_hal_buffer_fill(buffer_subspan, /*byte_offset=*/4,
-                                      /*byte_length=*/4,
-                                      /*pattern=*/&fill_value,
-                                      /*pattern_length=*/sizeof(fill_value)));
+  IREE_ASSERT_OK(
+      iree_hal_buffer_map_fill(buffer_subspan, /*byte_offset=*/4,
+                               /*byte_length=*/4,
+                               /*pattern=*/&fill_value,
+                               /*pattern_length=*/sizeof(fill_value)));
 
   // Check that the contents match what we expect.
   std::vector<uint8_t> actual_data(buffer_size);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(
       buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
   std::vector<uint8_t> reference_buffer{0x00, 0x00, 0x00, 0x00,  //
                                         0x00, 0x00, 0x00, 0x00,  //
@@ -271,9 +275,9 @@
   EXPECT_THAT(actual_data, ContainerEq(reference_buffer));
   // Also check the subspan.
   std::vector<uint8_t> actual_data_subspan(subspan_length);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(buffer_subspan, /*source_offset=*/0,
-                                           actual_data_subspan.data(),
-                                           actual_data_subspan.size()));
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(buffer_subspan, /*source_offset=*/0,
+                                          actual_data_subspan.data(),
+                                          actual_data_subspan.size()));
   std::vector<uint8_t> reference_buffer_subspan{0x00, 0x00, 0x00, 0x00,  //
                                                 0xFF, 0xFF, 0xFF, 0xFF};
   EXPECT_THAT(actual_data_subspan, ContainerEq(reference_buffer_subspan));
@@ -289,16 +293,17 @@
 
   // Zero the first half, fill the second half.
   IREE_ASSERT_OK(
-      iree_hal_buffer_zero(buffer, /*byte_offset=*/0, /*byte_length=*/8));
+      iree_hal_buffer_map_zero(buffer, /*byte_offset=*/0, /*byte_length=*/8));
   uint8_t fill_value = 0xFF;
-  IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, /*byte_offset=*/8,
-                                      /*byte_length=*/8,
-                                      /*pattern=*/&fill_value,
-                                      /*pattern_length=*/sizeof(fill_value)));
+  IREE_ASSERT_OK(
+      iree_hal_buffer_map_fill(buffer, /*byte_offset=*/8,
+                               /*byte_length=*/8,
+                               /*pattern=*/&fill_value,
+                               /*pattern_length=*/sizeof(fill_value)));
 
   // Read the entire buffer.
   std::vector<uint8_t> actual_data(buffer_size);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(
       buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
   std::vector<uint8_t> reference_buffer{0x00, 0x00, 0x00, 0x00,  //
                                         0x00, 0x00, 0x00, 0x00,  //
@@ -308,9 +313,9 @@
 
   // Read only a segment of the buffer.
   std::vector<uint8_t> actual_data_offset(8);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(buffer, /*source_offset=*/4,
-                                           actual_data_offset.data(),
-                                           actual_data_offset.size()));
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(buffer, /*source_offset=*/4,
+                                          actual_data_offset.data(),
+                                          actual_data_offset.size()));
   std::vector<uint8_t> reference_buffer_offset{0x00, 0x00, 0x00, 0x00,  //
                                                0xFF, 0xFF, 0xFF, 0xFF};
   EXPECT_THAT(actual_data_offset, ContainerEq(reference_buffer_offset));
@@ -325,13 +330,14 @@
 
   // Fill a few segments with distinct values.
   uint8_t value = 0xAA;
-  IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, 0, 4, &value, sizeof(value)));
+  IREE_ASSERT_OK(iree_hal_buffer_map_fill(buffer, 0, 4, &value, sizeof(value)));
   value = 0xBB;
-  IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, 4, 4, &value, sizeof(value)));
+  IREE_ASSERT_OK(iree_hal_buffer_map_fill(buffer, 4, 4, &value, sizeof(value)));
   value = 0xCC;
-  IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, 8, 4, &value, sizeof(value)));
+  IREE_ASSERT_OK(iree_hal_buffer_map_fill(buffer, 8, 4, &value, sizeof(value)));
   value = 0xDD;
-  IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, 12, 4, &value, sizeof(value)));
+  IREE_ASSERT_OK(
+      iree_hal_buffer_map_fill(buffer, 12, 4, &value, sizeof(value)));
 
   // Create a subspan.
   iree_device_size_t subspan_length = 8;
@@ -341,18 +347,18 @@
 
   // Read the entire buffer subspan.
   std::vector<uint8_t> actual_data(subspan_length);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(buffer_subspan, /*source_offset=*/0,
-                                           actual_data.data(),
-                                           actual_data.size()));
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(buffer_subspan, /*source_offset=*/0,
+                                          actual_data.data(),
+                                          actual_data.size()));
   std::vector<uint8_t> reference_buffer{0xBB, 0xBB, 0xBB, 0xBB,  //
                                         0xCC, 0xCC, 0xCC, 0xCC};
   EXPECT_THAT(actual_data, ContainerEq(reference_buffer));
 
   // Read only a segment of the buffer.
   std::vector<uint8_t> actual_data_offset(4);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(buffer_subspan, /*source_offset=*/4,
-                                           actual_data_offset.data(),
-                                           actual_data_offset.size()));
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(buffer_subspan, /*source_offset=*/4,
+                                          actual_data_offset.data(),
+                                          actual_data_offset.size()));
   std::vector<uint8_t> reference_buffer_offset{0xCC, 0xCC, 0xCC, 0xCC};
   EXPECT_THAT(actual_data_offset, ContainerEq(reference_buffer_offset));
 
@@ -369,13 +375,13 @@
   uint8_t fill_value = 0xFF;
   std::vector<uint8_t> reference_buffer(buffer_size);
   std::memset(reference_buffer.data(), fill_value, buffer_size);
-  IREE_ASSERT_OK(iree_hal_buffer_write_data(buffer, /*target_offset=*/0,
-                                            reference_buffer.data(),
-                                            reference_buffer.size()));
+  IREE_ASSERT_OK(iree_hal_buffer_map_write(buffer, /*target_offset=*/0,
+                                           reference_buffer.data(),
+                                           reference_buffer.size()));
 
   // Check that entire buffer was written to.
   std::vector<uint8_t> actual_data(buffer_size);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(
       buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
   EXPECT_THAT(actual_data, ContainerEq(reference_buffer));
 
@@ -388,17 +394,17 @@
   AllocateUninitializedBuffer(buffer_size, &buffer);
 
   // Zero the entire buffer.
-  IREE_ASSERT_OK(iree_hal_buffer_zero(buffer, 0, IREE_WHOLE_BUFFER));
+  IREE_ASSERT_OK(iree_hal_buffer_map_zero(buffer, 0, IREE_WHOLE_BUFFER));
 
   // Write over part of the buffer.
   std::vector<uint8_t> fill_buffer{0x11, 0x22, 0x33, 0x44,  //
                                    0x55, 0x66, 0x77, 0x88};
-  IREE_ASSERT_OK(iree_hal_buffer_write_data(
+  IREE_ASSERT_OK(iree_hal_buffer_map_write(
       buffer, /*target_offset=*/4, fill_buffer.data(), fill_buffer.size()));
 
   // Check that the contents match what we expect.
   std::vector<uint8_t> actual_data(buffer_size);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(
       buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
   std::vector<uint8_t> reference_buffer{0x00, 0x00, 0x00, 0x00,  //
                                         0x11, 0x22, 0x33, 0x44,  //
@@ -415,7 +421,7 @@
   AllocateUninitializedBuffer(buffer_size, &buffer);
 
   // Zero the entire buffer.
-  IREE_ASSERT_OK(iree_hal_buffer_zero(buffer, 0, IREE_WHOLE_BUFFER));
+  IREE_ASSERT_OK(iree_hal_buffer_map_zero(buffer, 0, IREE_WHOLE_BUFFER));
 
   // Create a subspan.
   iree_device_size_t subspan_length = 8;
@@ -425,13 +431,13 @@
 
   // Write over part of the subspan.
   std::vector<uint8_t> fill_buffer{0x11, 0x22, 0x33, 0x44};
-  IREE_ASSERT_OK(iree_hal_buffer_write_data(buffer_subspan, /*target_offset=*/4,
-                                            fill_buffer.data(),
-                                            fill_buffer.size()));
+  IREE_ASSERT_OK(iree_hal_buffer_map_write(buffer_subspan, /*target_offset=*/4,
+                                           fill_buffer.data(),
+                                           fill_buffer.size()));
 
   // Check that the contents match what we expect.
   std::vector<uint8_t> actual_data(buffer_size);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(
       buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
   std::vector<uint8_t> reference_buffer{0x00, 0x00, 0x00, 0x00,  //
                                         0x00, 0x00, 0x00, 0x00,  //
@@ -440,9 +446,9 @@
   EXPECT_THAT(actual_data, ContainerEq(reference_buffer));
   // Also check the subspan.
   std::vector<uint8_t> actual_data_subspan(subspan_length);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(buffer_subspan, /*source_offset=*/0,
-                                           actual_data_subspan.data(),
-                                           actual_data_subspan.size()));
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(buffer_subspan, /*source_offset=*/0,
+                                          actual_data_subspan.data(),
+                                          actual_data_subspan.size()));
   std::vector<uint8_t> reference_buffer_subspan{0x00, 0x00, 0x00, 0x00,  //
                                                 0x11, 0x22, 0x33, 0x44};
   EXPECT_THAT(actual_data_subspan, ContainerEq(reference_buffer_subspan));
@@ -458,11 +464,12 @@
   AllocateUninitializedBuffer(kDefaultAllocationSize, &buffer_b);
 
   uint8_t fill_value = 0x07;
-  IREE_ASSERT_OK(iree_hal_buffer_fill(buffer_a, /*byte_offset=*/0,
-                                      /*byte_length=*/kDefaultAllocationSize,
-                                      /*pattern=*/&fill_value,
-                                      /*pattern_length=*/sizeof(fill_value)));
-  IREE_ASSERT_OK(iree_hal_buffer_copy_data(
+  IREE_ASSERT_OK(
+      iree_hal_buffer_map_fill(buffer_a, /*byte_offset=*/0,
+                               /*byte_length=*/kDefaultAllocationSize,
+                               /*pattern=*/&fill_value,
+                               /*pattern_length=*/sizeof(fill_value)));
+  IREE_ASSERT_OK(iree_hal_buffer_map_copy(
       /*source_buffer=*/buffer_a,
       /*source_offset=*/0, /*target_buffer=*/buffer_b, /*target_offset=*/0,
       /*data_length=*/kDefaultAllocationSize));
@@ -471,7 +478,7 @@
   std::memset(reference_buffer.data(), fill_value, kDefaultAllocationSize);
 
   std::vector<uint8_t> actual_data(kDefaultAllocationSize);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(
       buffer_b, /*source_offset=*/0, actual_data.data(), actual_data.size()));
   EXPECT_THAT(actual_data, ContainerEq(reference_buffer));
 
@@ -480,16 +487,16 @@
 }
 
 // Maps a buffer range for reading from device -> host.
-// This is roughly what iree_hal_buffer_read_data does internally.
+// This is roughly what iree_hal_buffer_map_read does internally.
 TEST_P(buffer_mapping_test, MapRangeRead) {
   iree_device_size_t buffer_size = 16;
   iree_hal_buffer_t* buffer = NULL;
   AllocateUninitializedBuffer(buffer_size, &buffer);
 
   uint8_t fill_value = 0xEF;
-  IREE_ASSERT_OK(iree_hal_buffer_fill(buffer, /*byte_offset=*/0,
-                                      IREE_WHOLE_BUFFER, &fill_value,
-                                      sizeof(fill_value)));
+  IREE_ASSERT_OK(iree_hal_buffer_map_fill(buffer, /*byte_offset=*/0,
+                                          IREE_WHOLE_BUFFER, &fill_value,
+                                          sizeof(fill_value)));
 
   iree_hal_buffer_mapping_t mapping;
   IREE_ASSERT_OK(iree_hal_buffer_map_range(
@@ -510,7 +517,7 @@
 }
 
 // Maps a buffer range for writing from host -> device.
-// This is roughly what iree_hal_buffer_write_data does internally.
+// This is roughly what iree_hal_buffer_map_write does internally.
 TEST_P(buffer_mapping_test, MapRangeWrite) {
   iree_device_size_t buffer_size = 16;
   iree_hal_buffer_t* buffer = NULL;
@@ -530,7 +537,7 @@
   IREE_ASSERT_OK(iree_hal_buffer_flush_range(&mapping, /*byte_offset=*/0,
                                              /*byte_length=*/buffer_size));
   std::vector<uint8_t> actual_data(buffer_size);
-  IREE_ASSERT_OK(iree_hal_buffer_read_data(
+  IREE_ASSERT_OK(iree_hal_buffer_map_read(
       buffer, /*source_offset=*/0, actual_data.data(), actual_data.size()));
   std::vector<uint8_t> reference_buffer(buffer_size);
   std::memset(reference_buffer.data(), fill_value, buffer_size);
diff --git a/iree/hal/cts/command_buffer_test.h b/iree/hal/cts/command_buffer_test.h
index 6dcb621..3c31e03 100644
--- a/iree/hal/cts/command_buffer_test.h
+++ b/iree/hal/cts/command_buffer_test.h
@@ -38,7 +38,8 @@
     IREE_CHECK_OK(iree_hal_allocator_allocate_buffer(
         iree_hal_device_allocator(device_), params, buffer_size,
         iree_const_byte_span_empty(), &device_buffer));
-    IREE_ASSERT_OK(iree_hal_buffer_zero(device_buffer, 0, IREE_WHOLE_BUFFER));
+    IREE_ASSERT_OK(
+        iree_hal_buffer_map_zero(device_buffer, 0, IREE_WHOLE_BUFFER));
     *out_buffer = device_buffer;
   }
 
diff --git a/iree/hal/local/inline_command_buffer.c b/iree/hal/local/inline_command_buffer.c
index adc426e..e9aca83 100644
--- a/iree/hal/local/inline_command_buffer.c
+++ b/iree/hal/local/inline_command_buffer.c
@@ -278,8 +278,8 @@
     iree_hal_buffer_t* target_buffer, iree_device_size_t target_offset,
     iree_device_size_t length, const void* pattern,
     iree_host_size_t pattern_length) {
-  return iree_hal_buffer_fill(target_buffer, target_offset, length, pattern,
-                              pattern_length);
+  return iree_hal_buffer_map_fill(target_buffer, target_offset, length, pattern,
+                                  pattern_length);
 }
 
 //===----------------------------------------------------------------------===//
@@ -290,7 +290,7 @@
     iree_hal_command_buffer_t* base_command_buffer, const void* source_buffer,
     iree_host_size_t source_offset, iree_hal_buffer_t* target_buffer,
     iree_device_size_t target_offset, iree_device_size_t length) {
-  return iree_hal_buffer_write_data(
+  return iree_hal_buffer_map_write(
       target_buffer, target_offset,
       (const uint8_t*)source_buffer + source_offset, length);
 }
@@ -304,8 +304,8 @@
     iree_hal_buffer_t* source_buffer, iree_device_size_t source_offset,
     iree_hal_buffer_t* target_buffer, iree_device_size_t target_offset,
     iree_device_size_t length) {
-  return iree_hal_buffer_copy_data(source_buffer, source_offset, target_buffer,
-                                   target_offset, length);
+  return iree_hal_buffer_map_copy(source_buffer, source_offset, target_buffer,
+                                  target_offset, length);
 }
 
 //===----------------------------------------------------------------------===//
diff --git a/iree/hal/local/task_command_buffer.c b/iree/hal/local/task_command_buffer.c
index 9412063..10313a7 100644
--- a/iree/hal/local/task_command_buffer.c
+++ b/iree/hal/local/task_command_buffer.c
@@ -516,7 +516,7 @@
       iree_min(length_per_slice, remaining_length);
   IREE_TRACE_ZONE_APPEND_VALUE(z0, (uint64_t)slice_length);
 
-  iree_status_t status = iree_hal_buffer_fill(
+  iree_status_t status = iree_hal_buffer_map_fill(
       cmd->target_buffer, cmd->target_offset + slice_offset, slice_length,
       cmd->pattern, cmd->pattern_length);
 
@@ -581,7 +581,7 @@
   const iree_hal_cmd_update_buffer_t* cmd =
       (const iree_hal_cmd_update_buffer_t*)user_context;
   IREE_TRACE_ZONE_BEGIN(z0);
-  iree_status_t status = iree_hal_buffer_write_data(
+  iree_status_t status = iree_hal_buffer_map_write(
       cmd->target_buffer, cmd->target_offset, cmd->source_buffer, cmd->length);
   IREE_TRACE_ZONE_END(z0);
   return status;
@@ -655,7 +655,7 @@
       iree_min(length_per_slice, remaining_length);
   IREE_TRACE_ZONE_APPEND_VALUE(z0, (uint64_t)slice_length);
 
-  iree_status_t status = iree_hal_buffer_copy_data(
+  iree_status_t status = iree_hal_buffer_map_copy(
       cmd->source_buffer, cmd->source_offset + slice_offset, cmd->target_buffer,
       cmd->target_offset + slice_offset, slice_length);
 
diff --git a/iree/hal/string_util_test.cc b/iree/hal/string_util_test.cc
index 22e9063..453f99c 100644
--- a/iree/hal/string_util_test.cc
+++ b/iree/hal/string_util_test.cc
@@ -411,7 +411,7 @@
     iree_device_size_t total_byte_length = byte_length();
     std::vector<T> result(total_byte_length / sizeof(T));
     iree_status_t status =
-        iree_hal_buffer_read_data(get(), 0, result.data(), total_byte_length);
+        iree_hal_buffer_map_read(get(), 0, result.data(), total_byte_length);
     IREE_RETURN_IF_ERROR(std::move(status));
     return std::move(result);
   }
diff --git a/iree/hal/utils/buffer_transfer.c b/iree/hal/utils/buffer_transfer.c
index ce619b1..553d049 100644
--- a/iree/hal/utils/buffer_transfer.c
+++ b/iree/hal/utils/buffer_transfer.c
@@ -123,8 +123,8 @@
 
   // Read back the staging buffer into memory, if needed.
   if (iree_status_is_ok(status) && !target.device_buffer) {
-    status = iree_hal_buffer_read_data(target_buffer, 0,
-                                       target.host_buffer.data, data_length);
+    status = iree_hal_buffer_map_read(target_buffer, 0, target.host_buffer.data,
+                                      data_length);
   }
 
   // Discard staging buffers, if they were required.
diff --git a/iree/tools/iree-e2e-matmul-test.c b/iree/tools/iree-e2e-matmul-test.c
index fb27add..ac3c027 100644
--- a/iree/tools/iree-e2e-matmul-test.c
+++ b/iree/tools/iree-e2e-matmul-test.c
@@ -492,8 +492,8 @@
 static iree_status_t copy_buffer(iree_hal_allocator_t* hal_allocator,
                                  iree_hal_buffer_view_t* src,
                                  iree_hal_buffer_view_t** dst) {
-  // TODO(benvanik): change this to use iree_hal_buffer_copy_data. Or something.
-  // I can't understand what all this code is doing.
+  // TODO(benvanik): change this to use iree_hal_buffer_map_copy. Or
+  // something. I can't understand what all this code is doing.
   iree_hal_buffer_mapping_t src_mapping = {{0}};
   IREE_RETURN_IF_ERROR(iree_hal_buffer_map_range(
       iree_hal_buffer_view_buffer(src), IREE_HAL_MAPPING_MODE_PERSISTENT,