diff --git a/core/fdrm/fx_crypt_aes.cpp b/core/fdrm/fx_crypt_aes.cpp
index 104c9f1..eb644a3 100644
--- a/core/fdrm/fx_crypt_aes.cpp
+++ b/core/fdrm/fx_crypt_aes.cpp
@@ -8,18 +8,11 @@
 
 #include <string.h>
 
-#include "core/fxcrt/fx_system.h"
+#include "core/fxcrt/byteorder.h"
 #include "third_party/base/check.h"
 #include "third_party/base/check_op.h"
 
 #define mulby2(x) (((x & 0x7F) << 1) ^ (x & 0x80 ? 0x1B : 0))
-#define PUT_32BIT_MSB_FIRST(cp, value) \
-  do {                                 \
-    (cp)[3] = (value);                 \
-    (cp)[2] = (value) >> 8;            \
-    (cp)[1] = (value) >> 16;           \
-    (cp)[0] = (value) >> 24;           \
-  } while (0)
 
 namespace {
 
@@ -528,13 +521,14 @@
                      const uint8_t* key,
                      uint32_t keylen) {
   DCHECK(keylen == 16 || keylen == 24 || keylen == 32);
+  auto keyspan = pdfium::make_span(key, keylen);
   int Nk = keylen / 4;
   ctx->Nb = 4;
   ctx->Nr = 6 + (ctx->Nb > Nk ? ctx->Nb : Nk);
   int rconst = 1;
   for (int i = 0; i < (ctx->Nr + 1) * ctx->Nb; i++) {
     if (i < Nk) {
-      ctx->keysched[i] = FXSYS_UINT32_GET_MSBFIRST(key + 4 * i);
+      ctx->keysched[i] = fxcrt::GetUInt32MSBFirst(keyspan.subspan(4 * i));
     } else {
       unsigned int temp = ctx->keysched[i - 1];
       if (i % Nk == 0) {
@@ -581,7 +575,8 @@
 
 void CRYPT_AESSetIV(CRYPT_aes_context* ctx, const uint8_t* iv) {
   for (int i = 0; i < ctx->Nb; i++) {
-    ctx->iv[i] = FXSYS_UINT32_GET_MSBFIRST(iv + 4 * i);
+    // TODO(tsepez): Pass actual span.
+    ctx->iv[i] = fxcrt::GetUInt32MSBFirst(pdfium::make_span(iv + 4 * i, 4u));
   }
 }
 
@@ -597,11 +592,13 @@
   memcpy(iv, ctx->iv, sizeof(iv));
   while (size != 0) {
     for (i = 0; i < 4; i++) {
-      x[i] = ct[i] = FXSYS_UINT32_GET_MSBFIRST(src + 4 * i);
+      // TODO(tsepez): Create actual span.
+      x[i] = ct[i] = fxcrt::GetUInt32MSBFirst(pdfium::span(src + 4 * i, 4u));
     }
     aes_decrypt_nb_4(ctx, x);
     for (i = 0; i < 4; i++) {
-      PUT_32BIT_MSB_FIRST(dest + 4 * i, iv[i] ^ x[i]);
+      // TODO(tsepez): Create actual span.
+      fxcrt::PutUInt32MSBFirst(iv[i] ^ x[i], pdfium::span(dest + 4 * i, 4u));
       iv[i] = ct[i];
     }
     dest += 16;
@@ -621,11 +618,13 @@
   memcpy(iv, ctx->iv, sizeof(iv));
   while (size != 0) {
     for (i = 0; i < 4; i++) {
-      iv[i] ^= FXSYS_UINT32_GET_MSBFIRST(src + 4 * i);
+      // TODO(tsepez): use an actual span.
+      iv[i] ^= fxcrt::GetUInt32MSBFirst(pdfium::span(src + 4 * i, 4u));
     }
     aes_encrypt_nb_4(ctx, iv);
     for (i = 0; i < 4; i++) {
-      PUT_32BIT_MSB_FIRST(dest + 4 * i, iv[i]);
+      // TODO(tsepez): use an actual span.
+      fxcrt::PutUInt32MSBFirst(iv[i], pdfium::span(dest + 4 * i, 4u));
     }
     dest += 16;
     src += 16;
diff --git a/core/fpdfapi/font/cfx_cttgsubtable.cpp b/core/fpdfapi/font/cfx_cttgsubtable.cpp
index bf9566c..651faf0 100644
--- a/core/fpdfapi/font/cfx_cttgsubtable.cpp
+++ b/core/fpdfapi/font/cfx_cttgsubtable.cpp
@@ -10,8 +10,8 @@
 
 #include <utility>
 
+#include "core/fxcrt/byteorder.h"
 #include "core/fxcrt/data_vector.h"
-#include "core/fxcrt/fx_system.h"
 #include "core/fxcrt/stl_util.h"
 #include "core/fxge/cfx_fontmapper.h"
 
@@ -56,15 +56,16 @@
 CFX_CTTGSUBTable::~CFX_CTTGSUBTable() = default;
 
 bool CFX_CTTGSUBTable::LoadGSUBTable(pdfium::span<const uint8_t> gsub) {
-  if (FXSYS_UINT32_GET_MSBFIRST(gsub) != 0x00010000)
+  if (fxcrt::GetUInt32MSBFirst(gsub) != 0x00010000) {
     return false;
+  }
 
   auto scriptlist_span = gsub.subspan(4, 2);
   auto featurelist_span = gsub.subspan(6, 2);
   auto lookuplist_span = gsub.subspan(8, 2);
-  size_t scriptlist_index = FXSYS_UINT16_GET_MSBFIRST(scriptlist_span);
-  size_t featurelist_index = FXSYS_UINT16_GET_MSBFIRST(featurelist_span);
-  size_t lookuplist_index = FXSYS_UINT16_GET_MSBFIRST(lookuplist_span);
+  size_t scriptlist_index = fxcrt::GetUInt16MSBFirst(scriptlist_span);
+  size_t featurelist_index = fxcrt::GetUInt16MSBFirst(featurelist_span);
+  size_t lookuplist_index = fxcrt::GetUInt16MSBFirst(lookuplist_span);
   Parse(gsub.subspan(scriptlist_index), gsub.subspan(featurelist_index),
         gsub.subspan(lookuplist_index));
   return true;
@@ -158,25 +159,29 @@
 }
 
 int16_t CFX_CTTGSUBTable::GetInt16(const uint8_t*& p) const {
-  uint16_t ret = FXSYS_UINT16_GET_MSBFIRST(p);
+  // TODO(tsepez): pass actual span.
+  uint16_t ret = fxcrt::GetUInt16MSBFirst(pdfium::make_span(p, 2u));
   p += 2;
-  return *reinterpret_cast<int16_t*>(&ret);
+  return static_cast<int16_t>(ret);
 }
 
 uint16_t CFX_CTTGSUBTable::GetUInt16(const uint8_t*& p) const {
-  uint16_t ret = FXSYS_UINT16_GET_MSBFIRST(p);
+  // TODO(tsepez): pass actual span.
+  uint16_t ret = fxcrt::GetUInt16MSBFirst(pdfium::make_span(p, 2u));
   p += 2;
   return ret;
 }
 
 int32_t CFX_CTTGSUBTable::GetInt32(const uint8_t*& p) const {
-  uint32_t ret = FXSYS_UINT32_GET_MSBFIRST(p);
+  // TODO(tsepez): pass actual span.
+  uint32_t ret = fxcrt::GetUInt32MSBFirst(pdfium::make_span(p, 4u));
   p += 4;
-  return *reinterpret_cast<int32_t*>(&ret);
+  return static_cast<int32_t>(ret);
 }
 
 uint32_t CFX_CTTGSUBTable::GetUInt32(const uint8_t*& p) const {
-  uint32_t ret = FXSYS_UINT32_GET_MSBFIRST(p);
+  // TODO(tsepez): pass actual span.
+  uint32_t ret = fxcrt::GetUInt32MSBFirst(pdfium::make_span(p, 4u));
   p += 4;
   return ret;
 }
diff --git a/core/fpdfapi/parser/cpdf_security_handler.cpp b/core/fpdfapi/parser/cpdf_security_handler.cpp
index 96da9c4..175fd9d 100644
--- a/core/fpdfapi/parser/cpdf_security_handler.cpp
+++ b/core/fpdfapi/parser/cpdf_security_handler.cpp
@@ -18,6 +18,7 @@
 #include "core/fpdfapi/parser/cpdf_dictionary.h"
 #include "core/fpdfapi/parser/cpdf_object.h"
 #include "core/fpdfapi/parser/cpdf_string.h"
+#include "core/fxcrt/byteorder.h"
 #include "core/fxcrt/data_vector.h"
 #include "core/fxcrt/fx_memcpy_wrappers.h"
 #include "core/fxcrt/fx_random.h"
@@ -388,8 +389,9 @@
   if (buf[9] != 'a' || buf[10] != 'd' || buf[11] != 'b')
     return false;
 
-  if (FXSYS_UINT32_GET_LSBFIRST(buf) != m_Permissions)
+  if (fxcrt::GetUInt32LSBFirst(buf) != m_Permissions) {
     return false;
+  }
 
   // Relax this check as there appear to be some non-conforming documents
   // in the wild. The value in the buffer is the truth; if it requires us
diff --git a/core/fxcodec/basic/basicmodule.cpp b/core/fxcodec/basic/basicmodule.cpp
index 07fc896..aeddee9 100644
--- a/core/fxcodec/basic/basicmodule.cpp
+++ b/core/fxcodec/basic/basicmodule.cpp
@@ -10,10 +10,10 @@
 #include <utility>
 
 #include "core/fxcodec/scanlinedecoder.h"
+#include "core/fxcrt/byteorder.h"
 #include "core/fxcrt/data_vector.h"
 #include "core/fxcrt/fx_memory_wrappers.h"
 #include "core/fxcrt/fx_safe_types.h"
-#include "core/fxcrt/fx_system.h"
 #include "core/fxcrt/span_util.h"
 #include "third_party/base/check.h"
 #include "third_party/base/numerics/safe_conversions.h"
@@ -331,7 +331,7 @@
   uint32_t line_length = 0;
   while (src_span.size() >= 4 && pos < src_span.size() - 3) {
     auto val_span = src_span.subspan(pos, 4);
-    uint32_t val = FXSYS_UINT32_GET_MSBFIRST(val_span);
+    uint32_t val = fxcrt::GetUInt32MSBFirst(val_span);
     pos += 4;
     if (val == 0) {  // All zero special case
       result_span[0] = 'z';
diff --git a/core/fxcodec/bmp/cfx_bmpdecompressor.cpp b/core/fxcodec/bmp/cfx_bmpdecompressor.cpp
index 1566038..2f0a3e9 100644
--- a/core/fxcodec/bmp/cfx_bmpdecompressor.cpp
+++ b/core/fxcodec/bmp/cfx_bmpdecompressor.cpp
@@ -14,9 +14,9 @@
 
 #include "core/fxcodec/bmp/cfx_bmpcontext.h"
 #include "core/fxcodec/cfx_codec_memory.h"
+#include "core/fxcrt/byteorder.h"
 #include "core/fxcrt/data_vector.h"
 #include "core/fxcrt/fx_safe_types.h"
-#include "core/fxcrt/fx_system.h"
 #include "core/fxcrt/span_util.h"
 #include "core/fxge/calculate_pitch.h"
 #include "third_party/base/numerics/safe_math.h"
@@ -94,12 +94,9 @@
     return BmpDecoder::Status::kContinue;
   }
 
-  bmp_header.bfType =
-      FXSYS_UINT16_GET_LSBFIRST(reinterpret_cast<uint8_t*>(&bmp_header.bfType));
-  data_offset_ = FXSYS_UINT32_GET_LSBFIRST(
-      reinterpret_cast<uint8_t*>(&bmp_header.bfOffBits));
-  data_size_ =
-      FXSYS_UINT32_GET_LSBFIRST(reinterpret_cast<uint8_t*>(&bmp_header.bfSize));
+  bmp_header.bfType = fxcrt::FromLE16(bmp_header.bfType);
+  data_offset_ = fxcrt::FromLE32(bmp_header.bfOffBits);
+  data_size_ = fxcrt::FromLE32(bmp_header.bfSize);
   if (bmp_header.bfType != kBmpSignature)
     return BmpDecoder::Status::kFail;
 
@@ -111,8 +108,7 @@
   if (!input_buffer_->Seek(pos))
     return BmpDecoder::Status::kFail;
 
-  img_ifh_size_ =
-      FXSYS_UINT32_GET_LSBFIRST(reinterpret_cast<uint8_t*>(&img_ifh_size_));
+  img_ifh_size_ = fxcrt::FromLE32(img_ifh_size_);
   pal_type_ = PalType::kNew;
   BmpDecoder::Status status = ReadBmpHeaderIfh();
   if (status != BmpDecoder::Status::kSuccess)
@@ -130,12 +126,9 @@
       return BmpDecoder::Status::kContinue;
     }
 
-    width_ = FXSYS_UINT16_GET_LSBFIRST(
-        reinterpret_cast<uint8_t*>(&bmp_core_header.bcWidth));
-    height_ = FXSYS_UINT16_GET_LSBFIRST(
-        reinterpret_cast<uint8_t*>(&bmp_core_header.bcHeight));
-    bit_counts_ = FXSYS_UINT16_GET_LSBFIRST(
-        reinterpret_cast<uint8_t*>(&bmp_core_header.bcBitCount));
+    width_ = fxcrt::FromLE16(bmp_core_header.bcWidth);
+    height_ = fxcrt::FromLE16(bmp_core_header.bcHeight);
+    bit_counts_ = fxcrt::FromLE16(bmp_core_header.bcBitCount);
     compress_flag_ = kBmpRgb;
     img_tb_flag_ = false;
     return BmpDecoder::Status::kSuccess;
@@ -148,22 +141,19 @@
       return BmpDecoder::Status::kContinue;
     }
 
-    width_ = FXSYS_UINT32_GET_LSBFIRST(
-        reinterpret_cast<uint8_t*>(&bmp_info_header.biWidth));
-    int32_t signed_height = FXSYS_UINT32_GET_LSBFIRST(
-        reinterpret_cast<uint8_t*>(&bmp_info_header.biHeight));
-    bit_counts_ = FXSYS_UINT16_GET_LSBFIRST(
-        reinterpret_cast<uint8_t*>(&bmp_info_header.biBitCount));
-    compress_flag_ = FXSYS_UINT32_GET_LSBFIRST(
-        reinterpret_cast<uint8_t*>(&bmp_info_header.biCompression));
-    color_used_ = FXSYS_UINT32_GET_LSBFIRST(
-        reinterpret_cast<uint8_t*>(&bmp_info_header.biClrUsed));
-    dpi_x_ = static_cast<int32_t>(FXSYS_UINT32_GET_LSBFIRST(
-        reinterpret_cast<uint8_t*>(&bmp_info_header.biXPelsPerMeter)));
-    dpi_y_ = static_cast<int32_t>(FXSYS_UINT32_GET_LSBFIRST(
-        reinterpret_cast<uint8_t*>(&bmp_info_header.biYPelsPerMeter)));
-    if (!SetHeight(signed_height))
+    width_ = fxcrt::FromLE32(bmp_info_header.biWidth);
+    bit_counts_ = fxcrt::FromLE16(bmp_info_header.biBitCount);
+    compress_flag_ = fxcrt::FromLE32(bmp_info_header.biCompression);
+    color_used_ = fxcrt::FromLE32(bmp_info_header.biClrUsed);
+    dpi_x_ =
+        static_cast<int32_t>(fxcrt::FromLE32(bmp_info_header.biXPelsPerMeter));
+    dpi_y_ =
+        static_cast<int32_t>(fxcrt::FromLE32(bmp_info_header.biYPelsPerMeter));
+
+    int32_t signed_height = fxcrt::FromLE32(bmp_info_header.biHeight);
+    if (!SetHeight(signed_height)) {
       return BmpDecoder::Status::kFail;
+    }
     return BmpDecoder::Status::kSuccess;
   }
 
@@ -184,27 +174,21 @@
   if (!input_buffer_->Seek(new_pos.ValueOrDie()))
     return BmpDecoder::Status::kContinue;
 
-  uint16_t bi_planes;
-  width_ = FXSYS_UINT32_GET_LSBFIRST(
-      reinterpret_cast<uint8_t*>(&bmp_info_header.biWidth));
-  int32_t signed_height = FXSYS_UINT32_GET_LSBFIRST(
-      reinterpret_cast<uint8_t*>(&bmp_info_header.biHeight));
-  bit_counts_ = FXSYS_UINT16_GET_LSBFIRST(
-      reinterpret_cast<uint8_t*>(&bmp_info_header.biBitCount));
-  compress_flag_ = FXSYS_UINT32_GET_LSBFIRST(
-      reinterpret_cast<uint8_t*>(&bmp_info_header.biCompression));
-  color_used_ = FXSYS_UINT32_GET_LSBFIRST(
-      reinterpret_cast<uint8_t*>(&bmp_info_header.biClrUsed));
-  bi_planes = FXSYS_UINT16_GET_LSBFIRST(
-      reinterpret_cast<uint8_t*>(&bmp_info_header.biPlanes));
-  dpi_x_ = FXSYS_UINT32_GET_LSBFIRST(
-      reinterpret_cast<uint8_t*>(&bmp_info_header.biXPelsPerMeter));
-  dpi_y_ = FXSYS_UINT32_GET_LSBFIRST(
-      reinterpret_cast<uint8_t*>(&bmp_info_header.biYPelsPerMeter));
-  if (!SetHeight(signed_height))
+  width_ = fxcrt::FromLE32(bmp_info_header.biWidth);
+  bit_counts_ = fxcrt::FromLE16(bmp_info_header.biBitCount);
+  compress_flag_ = fxcrt::FromLE32(bmp_info_header.biCompression);
+  color_used_ = fxcrt::FromLE32(bmp_info_header.biClrUsed);
+  dpi_x_ = fxcrt::FromLE32(bmp_info_header.biXPelsPerMeter);
+  dpi_y_ = fxcrt::FromLE32(bmp_info_header.biYPelsPerMeter);
+
+  int32_t signed_height = fxcrt::FromLE32(bmp_info_header.biHeight);
+  if (!SetHeight(signed_height)) {
     return BmpDecoder::Status::kFail;
-  if (compress_flag_ != kBmpRgb || bi_planes != 1 || color_used_ != 0)
+  }
+  uint16_t bi_planes = fxcrt::FromLE16(bmp_info_header.biPlanes);
+  if (compress_flag_ != kBmpRgb || bi_planes != 1 || color_used_ != 0) {
     return BmpDecoder::Status::kFail;
+  }
   return BmpDecoder::Status::kSuccess;
 }
 
@@ -275,10 +259,9 @@
   if (!ReadAllOrNone(pdfium::as_writable_bytes(pdfium::make_span(masks))))
     return BmpDecoder::Status::kContinue;
 
-  mask_red_ = FXSYS_UINT32_GET_LSBFIRST(reinterpret_cast<uint8_t*>(&masks[0]));
-  mask_green_ =
-      FXSYS_UINT32_GET_LSBFIRST(reinterpret_cast<uint8_t*>(&masks[1]));
-  mask_blue_ = FXSYS_UINT32_GET_LSBFIRST(reinterpret_cast<uint8_t*>(&masks[2]));
+  mask_red_ = fxcrt::FromLE32(masks[0]);
+  mask_green_ = fxcrt::FromLE32(masks[1]);
+  mask_blue_ = fxcrt::FromLE32(masks[2]);
   if (mask_red_ & mask_green_ || mask_red_ & mask_blue_ ||
       mask_green_ & mask_blue_) {
     return BmpDecoder::Status::kFail;
@@ -413,7 +396,8 @@
         break;
       }
       case 16: {
-        uint16_t* buf = reinterpret_cast<uint16_t*>(dest_buf.data());
+        auto buf =
+            fxcrt::reinterpret_span<uint16_t>(pdfium::make_span(dest_buf));
         uint8_t blue_bits = 0;
         uint8_t green_bits = 0;
         uint8_t red_bits = 0;
@@ -433,13 +417,14 @@
         green_bits -= 8;
         red_bits -= 8;
         for (uint32_t col = 0; col < width_; ++col) {
-          *buf = FXSYS_UINT16_GET_LSBFIRST(reinterpret_cast<uint8_t*>(buf));
+          buf.front() = fxcrt::FromLE16(buf.front());
           out_row_buffer_[idx++] =
-              static_cast<uint8_t>((*buf & mask_blue_) << blue_bits);
+              static_cast<uint8_t>((buf.front() & mask_blue_) << blue_bits);
           out_row_buffer_[idx++] =
-              static_cast<uint8_t>((*buf & mask_green_) >> green_bits);
+              static_cast<uint8_t>((buf.front() & mask_green_) >> green_bits);
           out_row_buffer_[idx++] =
-              static_cast<uint8_t>((*buf++ & mask_red_) >> red_bits);
+              static_cast<uint8_t>((buf.front() & mask_red_) >> red_bits);
+          buf = buf.subspan(1);
         }
         break;
       }
diff --git a/core/fxcodec/gif/cfx_gifcontext.cpp b/core/fxcodec/gif/cfx_gifcontext.cpp
index c094f84..6fa2bc8 100644
--- a/core/fxcodec/gif/cfx_gifcontext.cpp
+++ b/core/fxcodec/gif/cfx_gifcontext.cpp
@@ -14,8 +14,8 @@
 #include <utility>
 
 #include "core/fxcodec/cfx_codec_memory.h"
+#include "core/fxcrt/byteorder.h"
 #include "core/fxcrt/data_vector.h"
-#include "core/fxcrt/fx_system.h"
 #include "core/fxcrt/stl_util.h"
 
 namespace fxcodec {
@@ -384,10 +384,8 @@
     std::swap(global_palette_, palette);
   }
 
-  width_ = static_cast<int>(
-      FXSYS_UINT16_GET_LSBFIRST(reinterpret_cast<uint8_t*>(&lsd.width)));
-  height_ = static_cast<int>(
-      FXSYS_UINT16_GET_LSBFIRST(reinterpret_cast<uint8_t*>(&lsd.height)));
+  width_ = fxcrt::FromLE16(lsd.width);
+  height_ = fxcrt::FromLE16(lsd.height);
 
   return GifDecoder::Status::kSuccess;
 }
@@ -429,8 +427,8 @@
             std::make_unique<CFX_GifGraphicControlExtension>();
       graphic_control_extension_->block_size = gif_gce.block_size;
       graphic_control_extension_->gce_flags = gif_gce.gce_flags;
-      graphic_control_extension_->delay_time = FXSYS_UINT16_GET_LSBFIRST(
-          reinterpret_cast<uint8_t*>(&gif_gce.delay_time));
+      graphic_control_extension_->delay_time =
+          fxcrt::FromLE16(gif_gce.delay_time);
       graphic_control_extension_->trans_index = gif_gce.trans_index;
       break;
     }
@@ -458,14 +456,10 @@
     return GifDecoder::Status::kUnfinished;
 
   auto gif_image = std::make_unique<CFX_GifImage>();
-  gif_image->image_info.left =
-      FXSYS_UINT16_GET_LSBFIRST(reinterpret_cast<uint8_t*>(&img_info.left));
-  gif_image->image_info.top =
-      FXSYS_UINT16_GET_LSBFIRST(reinterpret_cast<uint8_t*>(&img_info.top));
-  gif_image->image_info.width =
-      FXSYS_UINT16_GET_LSBFIRST(reinterpret_cast<uint8_t*>(&img_info.width));
-  gif_image->image_info.height =
-      FXSYS_UINT16_GET_LSBFIRST(reinterpret_cast<uint8_t*>(&img_info.height));
+  gif_image->image_info.left = fxcrt::FromLE16(img_info.left);
+  gif_image->image_info.top = fxcrt::FromLE16(img_info.top);
+  gif_image->image_info.width = fxcrt::FromLE16(img_info.width);
+  gif_image->image_info.height = fxcrt::FromLE16(img_info.height);
   gif_image->image_info.local_flags = img_info.local_flags;
   if (gif_image->image_info.left + gif_image->image_info.width > width_ ||
       gif_image->image_info.top + gif_image->image_info.height > height_)
diff --git a/core/fxcrt/byteorder.h b/core/fxcrt/byteorder.h
index b6c7a64..b830b56 100644
--- a/core/fxcrt/byteorder.h
+++ b/core/fxcrt/byteorder.h
@@ -6,18 +6,29 @@
 #define CORE_FXCRT_BYTEORDER_H_
 
 #include "build/build_config.h"
+#include "third_party/base/containers/span.h"
 #include "third_party/base/sys_byteorder.h"
 
 namespace fxcrt {
 
+// NOTE: Prefer *Swap*() methods when data is known to be aligned.
+
 // Converts the bytes in |x| from host order (endianness) to little endian, and
 // returns the result.
 inline uint16_t ByteSwapToLE16(uint16_t x) {
-  return pdfium::base::ByteSwapToLE16(x);
+#if defined(ARCH_CPU_LITTLE_ENDIAN)
+  return x;
+#else
+  return pdfium::base::ByteSwap(x);
+#endif
 }
 
 inline uint32_t ByteSwapToLE32(uint32_t x) {
-  return pdfium::base::ByteSwapToLE32(x);
+#if defined(ARCH_CPU_LITTLE_ENDIAN)
+  return x;
+#else
+  return pdfium::base::ByteSwap(x);
+#endif
 }
 
 // Converts the bytes in |x| from host order (endianness) to big endian, and
@@ -38,6 +49,67 @@
 #endif
 }
 
+// NOTE: These methods exist to improve readability by putting the word "From"
+// into the name, otherwise it is less clear that `x = ByteSwapToLE16(y)` gives
+// `x` in the native representation when `y` is in a LE representation.
+inline uint16_t FromLE16(uint16_t x) {
+  return ByteSwapToLE16(x);
+}
+inline uint32_t FromLE32(uint16_t x) {
+  return ByteSwapToLE32(x);
+}
+inline uint16_t FromBE16(uint16_t x) {
+  return ByteSwapToBE16(x);
+}
+inline uint32_t FromBE32(uint16_t x) {
+  return ByteSwapToBE32(x);
+}
+
+// Transfer to/from spans irrespective of alignments.
+inline uint16_t GetUInt16MSBFirst(pdfium::span<const uint8_t> span) {
+  return (static_cast<uint32_t>(span[0]) << 8) | static_cast<uint32_t>(span[1]);
+}
+
+inline uint32_t GetUInt32MSBFirst(pdfium::span<const uint8_t> span) {
+  return (static_cast<uint32_t>(span[0]) << 24) |
+         (static_cast<uint32_t>(span[1]) << 16) |
+         (static_cast<uint32_t>(span[2]) << 8) | static_cast<uint32_t>(span[3]);
+}
+
+inline uint16_t GetUInt16LSBFirst(pdfium::span<const uint8_t> span) {
+  return (static_cast<uint32_t>(span[1]) << 8) | static_cast<uint32_t>(span[0]);
+}
+
+inline uint32_t GetUInt32LSBFirst(pdfium::span<const uint8_t> span) {
+  return (static_cast<uint32_t>(span[3]) << 24) |
+         (static_cast<uint32_t>(span[2]) << 16) |
+         (static_cast<uint32_t>(span[1]) << 8) | static_cast<uint32_t>(span[0]);
+}
+
+inline void PutUInt16MSBFirst(uint16_t value, pdfium::span<uint8_t> span) {
+  span[0] = value >> 8;
+  span[1] = value & 0xff;
+}
+
+inline void PutUInt32MSBFirst(uint32_t value, pdfium::span<uint8_t> span) {
+  span[0] = value >> 24;
+  span[1] = (value >> 16) & 0xff;
+  span[2] = (value >> 8) & 0xff;
+  span[3] = value & 0xff;
+}
+
+inline void PutUInt16LSBFirst(uint16_t value, pdfium::span<uint8_t> span) {
+  span[1] = value >> 8;
+  span[0] = value & 0xff;
+}
+
+inline void PutUInt32LSBFirst(uint32_t value, pdfium::span<uint8_t> span) {
+  span[3] = value >> 24;
+  span[2] = (value >> 16) & 0xff;
+  span[1] = (value >> 8) & 0xff;
+  span[0] = value & 0xff;
+}
+
 }  // namespace fxcrt
 
 #endif  // CORE_FXCRT_BYTEORDER_H_
diff --git a/core/fxcrt/byteorder_unittest.cpp b/core/fxcrt/byteorder_unittest.cpp
index 6688934..d71ae61 100644
--- a/core/fxcrt/byteorder_unittest.cpp
+++ b/core/fxcrt/byteorder_unittest.cpp
@@ -5,6 +5,7 @@
 #include "core/fxcrt/byteorder.h"
 
 #include "core/fxcrt/fx_system.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
@@ -22,24 +23,14 @@
   // Since there are so few values, test them all.
   for (uint32_t v = 0; v < 0x10000; ++v) {
     const uint16_t v16 = v;
-    uint16_t expected =
-        FXSYS_UINT16_GET_LSBFIRST(reinterpret_cast<const uint8_t*>(&v16));
-    EXPECT_EQ(expected, ByteSwapToLE16(v16)) << v;
-
-    // Check safety against unexpectedly signed bytes.
-    expected = FXSYS_UINT16_GET_LSBFIRST(reinterpret_cast<const int8_t*>(&v16));
+    uint16_t expected = GetUInt16LSBFirst(pdfium::byte_span_from_ref(v16));
     EXPECT_EQ(expected, ByteSwapToLE16(v16)) << v;
   }
 }
 
 TEST(ByteOrder, ByteSwapToLE32) {
   for (uint32_t v : kTestValues32) {
-    uint32_t expected =
-        FXSYS_UINT32_GET_LSBFIRST(reinterpret_cast<const uint8_t*>(&v));
-    EXPECT_EQ(expected, ByteSwapToLE32(v)) << v;
-
-    // Check safety against unexpectedly signed bytes.
-    expected = FXSYS_UINT32_GET_LSBFIRST(reinterpret_cast<const int8_t*>(&v));
+    uint32_t expected = GetUInt32LSBFirst(pdfium::byte_span_from_ref(v));
     EXPECT_EQ(expected, ByteSwapToLE32(v)) << v;
   }
 }
@@ -48,26 +39,60 @@
   // Since there are so few values, test them all.
   for (uint32_t v = 0; v < 0x10000; ++v) {
     const uint16_t v16 = v;
-    uint16_t expected =
-        FXSYS_UINT16_GET_MSBFIRST(reinterpret_cast<const uint8_t*>(&v16));
-    EXPECT_EQ(expected, ByteSwapToBE16(v16)) << v;
-
-    // Check safety against unexpectedly signed bytes.
-    expected = FXSYS_UINT16_GET_MSBFIRST(reinterpret_cast<const int8_t*>(&v16));
+    uint16_t expected = GetUInt16MSBFirst(pdfium::byte_span_from_ref(v16));
     EXPECT_EQ(expected, ByteSwapToBE16(v16)) << v;
   }
 }
 
 TEST(ByteOrder, ByteSwapToBE32) {
   for (uint32_t v : kTestValues32) {
-    uint32_t expected =
-        FXSYS_UINT32_GET_MSBFIRST(reinterpret_cast<const uint8_t*>(&v));
-    EXPECT_EQ(expected, ByteSwapToBE32(v)) << v;
-
-    // Check safety against unexpectedly signed bytes.
-    expected = FXSYS_UINT32_GET_MSBFIRST(reinterpret_cast<const int8_t*>(&v));
+    uint32_t expected = GetUInt32MSBFirst(pdfium::byte_span_from_ref(v));
     EXPECT_EQ(expected, ByteSwapToBE32(v)) << v;
   }
 }
 
+TEST(ByteOrder, GetUInt16LSBFirst) {
+  const uint8_t kBuf[2] = {0xff, 0xfe};
+  EXPECT_EQ(0xfeff, GetUInt16LSBFirst(kBuf));
+}
+
+TEST(ByteOrder, GetUInt16MSBFirst) {
+  const uint8_t kBuf[2] = {0xff, 0xfe};
+  EXPECT_EQ(0xfffe, GetUInt16MSBFirst(kBuf));
+}
+
+TEST(ByteOrder, GetUInt32LSBFirst) {
+  const uint8_t kBuf[4] = {0xff, 0xfe, 0xfd, 0xfc};
+  EXPECT_EQ(0xfcfdfeff, GetUInt32LSBFirst(kBuf));
+}
+
+TEST(ByteOrder, GetUInt32MSBFirst) {
+  const uint8_t kBuf[4] = {0xff, 0xfe, 0xfd, 0xfc};
+  EXPECT_EQ(0xfffefdfc, GetUInt32MSBFirst(kBuf));
+}
+
+TEST(ByteOrder, PutUInt16LSBFirst) {
+  uint8_t buf[2];
+  PutUInt16LSBFirst(0xfffe, buf);
+  EXPECT_THAT(buf, testing::ElementsAre(0xfe, 0xff));
+}
+
+TEST(ByteOrder, PutUInt16MSBFirst) {
+  uint8_t buf[2];
+  PutUInt16MSBFirst(0xfffe, buf);
+  EXPECT_THAT(buf, testing::ElementsAre(0xff, 0xfe));
+}
+
+TEST(ByteOrder, PutUInt32LSBFirst) {
+  uint8_t buf[4];
+  PutUInt32LSBFirst(0xfffefdfc, buf);
+  EXPECT_THAT(buf, testing::ElementsAre(0xfc, 0xfd, 0xfe, 0xff));
+}
+
+TEST(ByteOrder, PutUInt32MSBFirst) {
+  uint8_t buf[4];
+  PutUInt32MSBFirst(0xfffefdfc, buf);
+  EXPECT_THAT(buf, testing::ElementsAre(0xff, 0xfe, 0xfd, 0xfc));
+}
+
 }  // namespace fxcrt
diff --git a/core/fxcrt/fx_system.h b/core/fxcrt/fx_system.h
index ca910f8..19c3449 100644
--- a/core/fxcrt/fx_system.h
+++ b/core/fxcrt/fx_system.h
@@ -88,28 +88,6 @@
 
 #ifdef __cplusplus
 }  // extern "C"
-
-// C++-only section
-
-// Could be C, but uses C++-style casting.
-#define FXSYS_UINT16_GET_LSBFIRST(p)                               \
-  (static_cast<uint16_t>(                                          \
-      (static_cast<uint32_t>(static_cast<uint8_t>((p)[1])) << 8) | \
-      (static_cast<uint32_t>(static_cast<uint8_t>((p)[0])))))
-#define FXSYS_UINT16_GET_MSBFIRST(p)                               \
-  (static_cast<uint16_t>(                                          \
-      (static_cast<uint32_t>(static_cast<uint8_t>((p)[0])) << 8) | \
-      (static_cast<uint32_t>(static_cast<uint8_t>((p)[1])))))
-#define FXSYS_UINT32_GET_LSBFIRST(p)                             \
-  ((static_cast<uint32_t>(static_cast<uint8_t>((p)[3])) << 24) | \
-   (static_cast<uint32_t>(static_cast<uint8_t>((p)[2])) << 16) | \
-   (static_cast<uint32_t>(static_cast<uint8_t>((p)[1])) << 8) |  \
-   (static_cast<uint32_t>(static_cast<uint8_t>((p)[0]))))
-#define FXSYS_UINT32_GET_MSBFIRST(p)                             \
-  ((static_cast<uint32_t>(static_cast<uint8_t>((p)[0])) << 24) | \
-   (static_cast<uint32_t>(static_cast<uint8_t>((p)[1])) << 16) | \
-   (static_cast<uint32_t>(static_cast<uint8_t>((p)[2])) << 8) |  \
-   (static_cast<uint32_t>(static_cast<uint8_t>((p)[3]))))
 #endif  // __cplusplus
 
 #endif  // CORE_FXCRT_FX_SYSTEM_H_
diff --git a/core/fxge/cfx_folderfontinfo.cpp b/core/fxge/cfx_folderfontinfo.cpp
index 3a4f41b..324f6e5 100644
--- a/core/fxge/cfx_folderfontinfo.cpp
+++ b/core/fxge/cfx_folderfontinfo.cpp
@@ -11,6 +11,7 @@
 #include <utility>
 
 #include "build/build_config.h"
+#include "core/fxcrt/byteorder.h"
 #include "core/fxcrt/fx_codepage.h"
 #include "core/fxcrt/fx_extension.h"
 #include "core/fxcrt/fx_folder.h"
@@ -86,10 +87,11 @@
                            uint32_t tag,
                            FX_FILESIZE fileSize) {
   for (uint32_t i = 0; i < nTables; i++) {
-    const uint8_t* p = pTables + i * 16;
-    if (FXSYS_UINT32_GET_MSBFIRST(p) == tag) {
-      uint32_t offset = FXSYS_UINT32_GET_MSBFIRST(p + 8);
-      uint32_t size = FXSYS_UINT32_GET_MSBFIRST(p + 12);
+    // TODO(tsepez): use actual span.
+    auto p = pdfium::make_span(pTables + i * 16, 16u);
+    if (fxcrt::GetUInt32MSBFirst(p) == tag) {
+      uint32_t offset = fxcrt::GetUInt32MSBFirst(p.subspan(8));
+      uint32_t size = fxcrt::GetUInt32MSBFirst(p.subspan(12));
       if (offset > std::numeric_limits<uint32_t>::max() - size ||
           static_cast<FX_FILESIZE>(offset + size) > fileSize ||
           fseek(pFile, offset, SEEK_SET) < 0) {
@@ -206,12 +208,13 @@
   if (readCnt != 1)
     return;
 
-  if (FXSYS_UINT32_GET_MSBFIRST(buffer) != kTableTTCF) {
+  if (fxcrt::GetUInt32MSBFirst(buffer) != kTableTTCF) {
     ReportFace(path, pFile.get(), filesize, 0);
     return;
   }
 
-  uint32_t nFaces = FXSYS_UINT32_GET_MSBFIRST(buffer + 8);
+  uint32_t nFaces =
+      fxcrt::GetUInt32MSBFirst(pdfium::make_span(buffer).subspan(8));
   FX_SAFE_SIZE_T safe_face_bytes = nFaces;
   safe_face_bytes *= 4;
   if (!safe_face_bytes.IsValid())
@@ -227,7 +230,7 @@
   auto offsets_span = pdfium::make_span(offsets.get(), face_bytes);
   for (uint32_t i = 0; i < nFaces; i++) {
     ReportFace(path, pFile.get(), filesize,
-               FXSYS_UINT32_GET_MSBFIRST(&offsets_span[i * 4]));
+               fxcrt::GetUInt32MSBFirst(offsets_span.subspan(i * 4)));
   }
 }
 
@@ -239,7 +242,8 @@
   if (fseek(pFile, offset, SEEK_SET) < 0 || !fread(buffer, 12, 1, pFile))
     return;
 
-  uint32_t nTables = FXSYS_UINT16_GET_MSBFIRST(buffer + 4);
+  uint32_t nTables =
+      fxcrt::GetUInt16MSBFirst(pdfium::as_byte_span(buffer).subspan(4));
   ByteString tables = ReadStringFromFile(pFile, nTables * 16);
   if (tables.IsEmpty())
     return;
@@ -269,8 +273,8 @@
   ByteString os2 =
       LoadTableFromTT(pFile, tables.raw_str(), nTables, kOs2Tag, filesize);
   if (os2.GetLength() >= 86) {
-    const uint8_t* p = os2.raw_str() + 78;
-    uint32_t codepages = FXSYS_UINT32_GET_MSBFIRST(p);
+    pdfium::span<const uint8_t> p = os2.raw_span().subspan(78);
+    uint32_t codepages = fxcrt::GetUInt32MSBFirst(p);
     if (codepages & (1U << 17)) {
       m_pMapper->AddInstalledFont(facename, FX_Charset::kShiftJIS);
       pInfo->m_Charsets |= CHARSET_FLAG_SHIFTJIS;
@@ -384,10 +388,12 @@
   } else {
     size_t nTables = pFont->m_FontTables.GetLength() / 16;
     for (size_t i = 0; i < nTables; i++) {
-      const uint8_t* p = pFont->m_FontTables.raw_str() + i * 16;
-      if (FXSYS_UINT32_GET_MSBFIRST(p) == table) {
-        offset = FXSYS_UINT32_GET_MSBFIRST(p + 8);
-        datasize = FXSYS_UINT32_GET_MSBFIRST(p + 12);
+      // TODO(tsepez): iterate over span.
+      pdfium::span<const uint8_t> p =
+          pFont->m_FontTables.raw_span().subspan(i * 16);
+      if (fxcrt::GetUInt32MSBFirst(p) == table) {
+        offset = fxcrt::GetUInt32MSBFirst(p.subspan(8));
+        datasize = fxcrt::GetUInt32MSBFirst(p.subspan(12));
       }
     }
   }
diff --git a/core/fxge/fx_font.cpp b/core/fxge/fx_font.cpp
index c5d7076..52010d0 100644
--- a/core/fxge/fx_font.cpp
+++ b/core/fxge/fx_font.cpp
@@ -8,8 +8,8 @@
 
 #include <algorithm>
 
+#include "core/fxcrt/byteorder.h"
 #include "core/fxcrt/fx_safe_types.h"
-#include "core/fxcrt/fx_system.h"
 #include "core/fxcrt/widestring.h"
 #include "core/fxge/cfx_glyphbitmap.h"
 #include "core/fxge/dib/cfx_dibitmap.h"
@@ -84,8 +84,8 @@
   if (name_table.size() < 6)
     return ByteString();
 
-  uint32_t name_count = FXSYS_UINT16_GET_MSBFIRST(&name_table[2]);
-  uint32_t string_offset = FXSYS_UINT16_GET_MSBFIRST(&name_table[4]);
+  uint32_t name_count = fxcrt::GetUInt16MSBFirst(name_table.subspan(2));
+  uint32_t string_offset = fxcrt::GetUInt16MSBFirst(name_table.subspan(4));
   // We will ignore the possibility of overlap of structures and
   // string table as if it's all corrupt there's not a lot we can do.
   if (name_table.size() < string_offset)
@@ -98,24 +98,23 @@
 
   for (uint32_t i = 0; i < name_count;
        i++, name_table = name_table.subspan(12)) {
-    if (FXSYS_UINT16_GET_MSBFIRST(&name_table[6]) == name_id) {
-      const uint16_t platform_identifier =
-          FXSYS_UINT16_GET_MSBFIRST(name_table);
+    if (fxcrt::GetUInt16MSBFirst(name_table.subspan(6)) == name_id) {
+      const uint16_t platform_identifier = fxcrt::GetUInt16MSBFirst(name_table);
       const uint16_t platform_encoding =
-          FXSYS_UINT16_GET_MSBFIRST(&name_table[2]);
+          fxcrt::GetUInt16MSBFirst(name_table.subspan(2));
 
       if (platform_identifier == kNamePlatformMac &&
           platform_encoding == kNameMacEncodingRoman) {
-        return GetStringFromTable(string_span,
-                                  FXSYS_UINT16_GET_MSBFIRST(&name_table[10]),
-                                  FXSYS_UINT16_GET_MSBFIRST(&name_table[8]));
+        return GetStringFromTable(
+            string_span, fxcrt::GetUInt16MSBFirst(name_table.subspan(10)),
+            fxcrt::GetUInt16MSBFirst(name_table.subspan(8)));
       }
       if (platform_identifier == kNamePlatformWindows &&
           platform_encoding == kNameWindowsEncodingUnicode) {
         // This name is always UTF16-BE and we have to convert it to UTF8.
         ByteString utf16_be = GetStringFromTable(
-            string_span, FXSYS_UINT16_GET_MSBFIRST(&name_table[10]),
-            FXSYS_UINT16_GET_MSBFIRST(&name_table[8]));
+            string_span, fxcrt::GetUInt16MSBFirst(name_table.subspan(10)),
+            fxcrt::GetUInt16MSBFirst(name_table.subspan(8)));
         if (utf16_be.IsEmpty() || utf16_be.GetLength() % 2 != 0) {
           return ByteString();
         }
@@ -129,11 +128,12 @@
 
 size_t GetTTCIndex(pdfium::span<const uint8_t> pFontData, size_t font_offset) {
   pdfium::span<const uint8_t> p = pFontData.subspan(8);
-  size_t nfont = FXSYS_UINT32_GET_MSBFIRST(p.data());
+  size_t nfont = fxcrt::GetUInt32MSBFirst(p);
   for (size_t index = 0; index < nfont; index++) {
     p = pFontData.subspan(12 + index * 4);
-    if (FXSYS_UINT32_GET_MSBFIRST(p.data()) == font_offset)
+    if (fxcrt::GetUInt32MSBFirst(p) == font_offset) {
       return index;
+    }
   }
   return 0;
 }
diff --git a/core/fxge/win32/cwin32_platform.cpp b/core/fxge/win32/cwin32_platform.cpp
index 50aae40..885cac4 100644
--- a/core/fxge/win32/cwin32_platform.cpp
+++ b/core/fxge/win32/cwin32_platform.cpp
@@ -10,7 +10,9 @@
 #include <memory>
 #include <utility>
 
+#include "core/fxcrt/byteorder.h"
 #include "core/fxcrt/fx_codepage.h"
+#include "core/fxcrt/fx_system.h"
 #include "core/fxge/cfx_folderfontinfo.h"
 #include "core/fxge/cfx_gemodule.h"
 #include "third_party/base/check.h"
@@ -161,7 +163,7 @@
     uint32_t header;
     auto span = pdfium::as_writable_bytes(pdfium::span_from_ref(header));
     GetFontData(hFont, 0, span);
-    header = FXSYS_UINT32_GET_MSBFIRST(span);
+    header = fxcrt::GetUInt32MSBFirst(span);
     ret = header == FXBSTR_ID('O', 'T', 'T', 'O') ||
           header == FXBSTR_ID('t', 't', 'c', 'f') ||
           header == FXBSTR_ID('t', 'r', 'u', 'e') || header == 0x00010000 ||
@@ -419,7 +421,7 @@
                                       uint32_t table,
                                       pdfium::span<uint8_t> buffer) {
   ScopedSelectObject select_object(m_hDC, static_cast<HFONT>(hFont));
-  table = FXSYS_UINT32_GET_MSBFIRST(reinterpret_cast<uint8_t*>(&table));
+  table = fxcrt::FromBE32(table);
   size_t size = ::GetFontData(m_hDC, table, 0, buffer.data(),
                               pdfium::base::checked_cast<DWORD>(buffer.size()));
   return size != GDI_ERROR ? size : 0;
diff --git a/xfa/fgas/font/cfgas_fontmgr.cpp b/xfa/fgas/font/cfgas_fontmgr.cpp
index c1f516d..cdf8d0d 100644
--- a/xfa/fgas/font/cfgas_fontmgr.cpp
+++ b/xfa/fgas/font/cfgas_fontmgr.cpp
@@ -14,6 +14,7 @@
 #include <utility>
 
 #include "build/build_config.h"
+#include "core/fxcrt/byteorder.h"
 #include "core/fxcrt/cfx_read_only_vector_stream.h"
 #include "core/fxcrt/data_vector.h"
 #include "core/fxcrt/fixed_size_data_vector.h"
@@ -370,8 +371,7 @@
 
 uint16_t ReadUInt16FromSpanAtOffset(pdfium::span<const uint8_t> data,
                                     size_t offset) {
-  const uint8_t* p = &data[offset];
-  return FXSYS_UINT16_GET_MSBFIRST(p);
+  return fxcrt::GetUInt16MSBFirst(data.subspan(offset));
 }
 
 extern "C" {