diff --git a/Lib/contextlib.py b/Lib/contextlib.py
index efc02bfa9243da6..f1b958b551af15b 100644
--- a/Lib/contextlib.py
+++ b/Lib/contextlib.py
@@ -199,22 +199,20 @@ def __enter__(self):
         # do not keep args and kwds alive unnecessarily
         # they are only needed for recreation, which is not possible anymore
         del self.args, self.kwds, self.func
-        try:
-            return next(self.gen)
-        except StopIteration:
-            raise RuntimeError("generator didn't yield") from None
+        # Slightly faster way to return next(self.gen):
+        for once in self.gen:
+            return once
+        raise RuntimeError("generator didn't yield")
 
     def __exit__(self, typ, value, traceback):
         if typ is None:
-            try:
-                next(self.gen)
-            except StopIteration:
-                return False
-            else:
+            # Faster way to run next(self.gen) and check for StopIteration:
+            for _ in self.gen:
                 try:
                     raise RuntimeError("generator didn't stop")
                 finally:
                     self.gen.close()
+            return False
         else:
             if value is None:
                 # Need to force instantiation so we can reliably
diff --git a/Lib/profiling/sampling/_flamegraph_assets/flamegraph.js b/Lib/profiling/sampling/_flamegraph_assets/flamegraph.js
index 840acf2c27d1201..f1cdf5142fa3949 100644
--- a/Lib/profiling/sampling/_flamegraph_assets/flamegraph.js
+++ b/Lib/profiling/sampling/_flamegraph_assets/flamegraph.js
@@ -99,13 +99,23 @@ function getDisplayName(moduleName, filename) {
   return filename;
 }
 
-function selectFlamegraphData() {
-  const baseData = isShowingElided ? elidedFlamegraphData : normalData;
+function selectFlamegraphData(selectedThreadId = null) {
+  let baseData = isShowingElided ? elidedFlamegraphData : normalData;
+
+  if (selectedThreadId !== null) {
+    baseData = filterDataByThread(baseData, selectedThreadId);
+  }
 
   if (!isInverted) {
     return baseData;
   }
 
+  // Thread-filtered trees have different values, so invert them after filtering
+  // instead of using the cached all-thread tree.
+  if (selectedThreadId !== null) {
+    return generateInvertedFlamegraph(baseData);
+  }
+
   if (isShowingElided) {
     if (!invertedElidedData) {
       invertedElidedData = generateInvertedFlamegraph(baseData);
@@ -120,12 +130,11 @@ function selectFlamegraphData() {
 }
 
 function updateFlamegraphView() {
-  const selectedData = selectFlamegraphData();
   const selectedThreadId = currentThreadFilter !== 'all' ? parseInt(currentThreadFilter, 10) : null;
-  const filteredData = selectedThreadId !== null ? filterDataByThread(selectedData, selectedThreadId) : selectedData;
-  const tooltip = createPythonTooltip(filteredData);
-  const chart = createFlamegraph(tooltip, filteredData.value, filteredData);
-  renderFlamegraph(chart, filteredData);
+  const selectedData = selectFlamegraphData(selectedThreadId);
+  const tooltip = createPythonTooltip(selectedData);
+  const chart = createFlamegraph(tooltip, selectedData.value, selectedData);
+  renderFlamegraph(chart, selectedData);
   populateThreadStats(selectedData, selectedThreadId);
 }
 
@@ -937,7 +946,9 @@ function formatDuration(seconds) {
 
 function populateProfileSummary(data) {
   const stats = data.stats || {};
-  const totalSamples = stats.total_samples || data.value || 0;
+  const totalSamples = currentThreadFilter !== 'all'
+    ? (data.value ?? 0)
+    : (stats.total_samples ?? data.value ?? 0);
   const duration = stats.duration_sec || 0;
   const sampleRate = stats.sample_rate || (duration > 0 ? totalSamples / duration : 0);
   const errorRate = stats.error_rate || 0;
@@ -1209,7 +1220,7 @@ function initThreadFilter(data) {
   const threadFilter = document.getElementById('thread-filter');
   const threadSection = document.getElementById('thread-section');
 
-  if (!threadFilter || !data.threads) return;
+  if (!threadFilter || !data.threads || data.stats?.is_differential) return;
 
   threadFilter.innerHTML = '<option value="all">All Threads</option>';
 
@@ -1238,11 +1249,23 @@ function filterByThread() {
 
 function filterDataByThread(data, threadId) {
   function filterNode(node) {
-    if (!node.threads || !node.threads.includes(threadId)) {
+    const threadValues = node.thread_values?.[threadId];
+    if (!threadValues) {
       return null;
     }
 
-    const filteredNode = { ...node, children: [] };
+    const {
+      thread_values: _threadValues,
+      thread_opcodes: threadOpcodes,
+      ...sharedNode
+    } = node;
+    const filteredNode = {
+      ...sharedNode,
+      value: threadValues[0],
+      self: threadValues[1],
+      opcodes: threadOpcodes?.[threadId] ?? {},
+      children: []
+    };
 
     if (node.children && Array.isArray(node.children)) {
       filteredNode.children = node.children
@@ -1253,25 +1276,7 @@ function filterDataByThread(data, threadId) {
     return filteredNode;
   }
 
-  function recalculateValue(node) {
-    if (!node.children || node.children.length === 0) {
-      return node.value || 0;
-    }
-    const childrenValue = node.children.reduce((sum, child) => sum + recalculateValue(child), 0);
-    node.value = Math.max(node.value || 0, childrenValue);
-    return node.value;
-  }
-
-  const filteredRoot = { ...data, children: [] };
-
-  if (data.children && Array.isArray(data.children)) {
-    filteredRoot.children = data.children
-      .map(child => filterNode(child))
-      .filter(child => child !== null);
-  }
-
-  recalculateValue(filteredRoot);
-  return filteredRoot;
+  return filterNode(data);
 }
 
 // ============================================================================
diff --git a/Lib/profiling/sampling/stack_collector.py b/Lib/profiling/sampling/stack_collector.py
index eb1a3fba93cf33b..ace0e1a12290131 100644
--- a/Lib/profiling/sampling/stack_collector.py
+++ b/Lib/profiling/sampling/stack_collector.py
@@ -71,7 +71,13 @@ class FlamegraphCollector(StackTraceCollector):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.stats = {}
-        self._root = {"samples": 0, "children": {}, "threads": set()}
+        self._root = {
+            "samples": 0,
+            "children": {},
+            "threads": set(),
+            "thread_samples": collections.Counter(),
+            "thread_self": collections.Counter(),
+        }
         self._total_samples = 0
         self._sample_count = 0  # Track actual number of samples (not thread traces)
         self._func_intern = {}
@@ -220,7 +226,18 @@ def convert_children(children, min_samples, path_info):
             out = []
             for func, node in children.items():
                 samples = node["samples"]
-                if samples < min_samples:
+                significant_for_thread = any(
+                    thread_samples >= max(
+                        1,
+                        int(
+                            self._root["thread_samples"][thread_id]
+                            * 0.001
+                        ),
+                    )
+                    for thread_id, thread_samples
+                    in node["thread_samples"].items()
+                )
+                if samples < min_samples and not significant_for_thread:
                     continue
 
                 # Intern all string components for maximum efficiency
@@ -243,6 +260,15 @@ def convert_children(children, min_samples, path_info):
                     "lineno": func[1],
                     "funcname": funcname_idx,
                     "threads": sorted(list(node.get("threads", set()))),
+                    "thread_values": {
+                        thread_id: [
+                            samples,
+                            node["thread_self"].get(thread_id, 0),
+                        ]
+                        for thread_id, samples in sorted(
+                            node["thread_samples"].items()
+                        )
+                    },
                 }
 
                 source = self._get_source_lines(func)
@@ -255,6 +281,14 @@ def convert_children(children, min_samples, path_info):
                 opcodes = node.get("opcodes", {})
                 if opcodes:
                     child_entry["opcodes"] = dict(opcodes)
+                thread_opcodes = node.get("thread_opcodes")
+                if thread_opcodes:
+                    child_entry["thread_opcodes"] = {
+                        thread_id: dict(counts)
+                        for thread_id, counts in sorted(
+                            thread_opcodes.items()
+                        )
+                    }
 
                 # Recurse
                 child_entry["children"] = convert_children(
@@ -311,7 +345,25 @@ def convert_children(children, min_samples, path_info):
         opcode_mapping = get_opcode_mapping()
 
         # If we only have one root child, make it the root to avoid redundant level
-        if len(root_children) == 1:
+        root_thread_values = {
+            thread_id: [samples, 0]
+            for thread_id, samples in sorted(
+                self._root["thread_samples"].items()
+            )
+        }
+        sole_root_covers_profile = (
+            len(root_children) == 1
+            and root_children[0]["value"] == total_samples
+            and {
+                thread_id: values[0]
+                for thread_id, values
+                in root_children[0]["thread_values"].items()
+            } == {
+                thread_id: values[0]
+                for thread_id, values in root_thread_values.items()
+            }
+        )
+        if sole_root_covers_profile:
             main_child = root_children[0]
             # Update name and label to indicate it's the program root
             old_name = self._string_table.get_string(main_child["name"])
@@ -340,6 +392,7 @@ def convert_children(children, min_samples, path_info):
                 "per_thread_stats": per_thread_stats_with_pct
             },
             "threads": sorted(list(self._all_threads)),
+            "thread_values": root_thread_values,
             "strings": self._string_table.get_strings(),
             "opcode_mapping": opcode_mapping
         }
@@ -356,6 +409,7 @@ def process_frames(self, frames, thread_id, weight=1):
         """
         # Reverse to root->leaf order for tree building
         self._root["samples"] += weight
+        self._root["thread_samples"][thread_id] += weight
         self._total_samples += weight
         self._root["threads"].add(thread_id)
         self._all_threads.add(thread_id)
@@ -368,18 +422,32 @@ def process_frames(self, frames, thread_id, weight=1):
 
             node = current["children"].get(func)
             if node is None:
-                node = {"samples": 0, "children": {}, "threads": set(), "opcodes": collections.Counter(), "self": 0}
+                node = {
+                    "samples": 0,
+                    "children": {},
+                    "threads": set(),
+                    "thread_samples": collections.Counter(),
+                    "thread_self": collections.Counter(),
+                    "opcodes": collections.Counter(),
+                    "self": 0,
+                }
                 current["children"][func] = node
             node["samples"] += weight
+            node["thread_samples"][thread_id] += weight
             node["threads"].add(thread_id)
 
             if opcode is not None:
                 node["opcodes"][opcode] += weight
+                thread_opcodes = node.setdefault("thread_opcodes", {})
+                thread_opcodes.setdefault(
+                    thread_id, collections.Counter()
+                )[opcode] += weight
 
             current = node
 
         if current is not self._root:
             current["self"] += weight
+            current["thread_self"][thread_id] += weight
 
     def _get_source_lines(self, func):
         filename, lineno, _ = func
diff --git a/Lib/test/test_profiling/test_sampling_profiler/test_collectors.py b/Lib/test/test_profiling/test_sampling_profiler/test_collectors.py
index 7746811014a9e2f..1aba1572cc89d38 100644
--- a/Lib/test/test_profiling/test_sampling_profiler/test_collectors.py
+++ b/Lib/test/test_profiling/test_sampling_profiler/test_collectors.py
@@ -1336,6 +1336,87 @@ def test_flamegraph_collector_json_structure_includes_stats(self):
             self.assertIn("gc_pct", thread_data)
             self.assertIn("total", thread_data)
 
+    def test_flamegraph_nodes_include_per_thread_values(self):
+        collector = FlamegraphCollector(sample_interval_usec=1000)
+        root = MockFrameInfo("app.py", 1, "main")
+        collector.process_frames(
+            [MockFrameInfo("app.py", 10, "worker_a"), root],
+            thread_id=1,
+            weight=2,
+        )
+        collector.process_frames(
+            [MockFrameInfo("app.py", 20, "worker_b"), root],
+            thread_id=2,
+            weight=3,
+        )
+
+        data = collector._convert_to_flamegraph_format()
+
+        self.assertEqual(data["thread_values"], {1: [2, 0], 2: [3, 0]})
+        children_by_line = {child["lineno"]: child for child in data["children"]}
+        self.assertEqual(children_by_line[10]["thread_values"], {1: [2, 2]})
+        self.assertEqual(children_by_line[20]["thread_values"], {2: [3, 3]})
+
+    def test_flamegraph_pruning_preserves_low_volume_thread(self):
+        collector = FlamegraphCollector(sample_interval_usec=1000)
+        collector.process_frames(
+            [MockFrameInfo("app.py", 10, "busy")],
+            thread_id=1,
+            weight=1999,
+        )
+        collector.process_frames(
+            [MockFrameInfo("app.py", 20, "rare")],
+            thread_id=2,
+        )
+
+        data = collector._convert_to_flamegraph_format()
+
+        self.assertEqual(data["thread_values"], {1: [1999, 0], 2: [1, 0]})
+        children_by_line = {child["lineno"]: child for child in data["children"]}
+        self.assertEqual(children_by_line[10]["thread_values"], {1: [1999, 1999]})
+        self.assertEqual(children_by_line[20]["thread_values"], {2: [1, 1]})
+
+    def test_flamegraph_does_not_promote_incomplete_root(self):
+        collector = FlamegraphCollector(sample_interval_usec=1000)
+        collector.process_frames(
+            [MockFrameInfo("app.py", 1, "busy")],
+            thread_id=1,
+            weight=2000,
+        )
+        for line in range(2, 2002):
+            collector.process_frames(
+                [MockFrameInfo("app.py", line, f"fragment_{line}")],
+                thread_id=2,
+            )
+
+        data = collector._convert_to_flamegraph_format()
+
+        self.assertNotIn("filename", data)
+        self.assertEqual(data["thread_values"], {1: [2000, 0], 2: [2000, 0]})
+        self.assertEqual(len(data["children"]), 1)
+        self.assertEqual(data["children"][0]["thread_values"], {1: [2000, 2000]})
+
+    def test_flamegraph_nodes_include_per_thread_opcodes(self):
+        collector = FlamegraphCollector(sample_interval_usec=1000)
+        collector.process_frames(
+            [MockFrameInfo("app.py", 10, "worker", opcode=100)],
+            thread_id=1,
+            weight=2,
+        )
+        collector.process_frames(
+            [MockFrameInfo("app.py", 10, "worker", opcode=101)],
+            thread_id=2,
+            weight=3,
+        )
+
+        data = collector._convert_to_flamegraph_format()
+
+        self.assertEqual(data["opcodes"], {100: 2, 101: 3})
+        self.assertEqual(
+            data["thread_opcodes"],
+            {1: {100: 2}, 2: {101: 3}},
+        )
+
     def test_flamegraph_collector_per_thread_gc_percentage(self):
         """Test that per-thread GC percentage uses total samples as denominator."""
         collector = FlamegraphCollector(sample_interval_usec=1000)
diff --git a/Lib/test/test_wave.py b/Lib/test/test_wave.py
index d3723c04820d9d4..c482de12f7829b0 100644
--- a/Lib/test/test_wave.py
+++ b/Lib/test/test_wave.py
@@ -172,6 +172,19 @@ def test__all__(self):
         not_exported = {'KSDATAFORMAT_SUBTYPE_PCM'}
         support.check__all__(self, wave, not_exported=not_exported)
 
+    def test_getfp(self):
+        fp = io.BytesIO()
+        with wave.open(fp, 'wb') as w:
+            w.setnchannels(1)
+            w.setsampwidth(1)
+            w.setframerate(11025)
+        fp.seek(0)
+        with wave.open(fp) as r:
+            chunk = r.getfp()
+            self.assertIsNotNone(chunk)
+            self.assertIs(chunk.file, fp)
+            self.assertEqual(chunk.chunkname, b'RIFF')
+
 
 class WaveLowLevelTest(unittest.TestCase):
 
@@ -474,6 +487,184 @@ def test_open_pathlike(self):
                     with wave.open(fake_path, 'rb') as f:
                         pass
 
+    def test_open_invalid_mode(self):
+        with self.assertRaisesRegex(wave.Error, "mode must be"):
+            wave.open(io.BytesIO(), 'xb')
+
+
+class WaveReadErrorTest(unittest.TestCase):
+    """Cover error and edge paths of Wave_read, and wave.open()."""
+
+    FMT_PCM = struct.pack('<HHLLHH', wave.WAVE_FORMAT_PCM, 1, 11025, 11025, 1, 8)
+
+    @staticmethod
+    def _wave_file(*chunks):
+        """Build in-memory WAVE bytes from (name, payload) chunks.
+
+        Each chunk stores its real payload length and is padded to an even
+        number of bytes, and the RIFF size is computed to match.
+        """
+        body = b'WAVE'
+        for name, payload in chunks:
+            body += name + struct.pack('<L', len(payload)) + payload
+            if len(payload) & 1:
+                body += b'\x00'
+        return b'RIFF' + struct.pack('<L', len(body)) + body
+
+    def test_read_unknown_extensible_subformat(self):
+        # A WAVE_FORMAT_EXTENSIBLE fmt chunk whose SubFormat GUID is not
+        # KSDATAFORMAT_SUBTYPE_PCM must be rejected.
+        fmt = struct.pack('<HHLLH', wave.WAVE_FORMAT_EXTENSIBLE, 2, 11025,
+                          11025 * 2 * 3, 6)
+        fmt += struct.pack('<H', 24)            # bits per sample
+        fmt += struct.pack('<HHL', 22, 24, 3)   # cbSize, valid bits, channel mask
+        fmt += b'\xff' * 16                      # bogus SubFormat GUID
+        b = self._wave_file((b'fmt ', fmt), (b'data', b''))
+        with self.assertRaisesRegex(wave.Error, 'unknown extended format'):
+            wave.open(io.BytesIO(b))
+
+    def test_read_truncated_fmt_chunk_header(self):
+        # fmt chunk too short for the fixed 14-byte header.
+        fmt = struct.pack('<H', wave.WAVE_FORMAT_PCM) + b'\x00' * 8
+        b = self._wave_file((b'fmt ', fmt))
+        with self.assertRaises(EOFError):
+            wave.open(io.BytesIO(b))
+
+    def test_read_truncated_fmt_chunk_sampwidth(self):
+        # fmt chunk holds the 14-byte header but is missing the sample width.
+        fmt = struct.pack('<HHLLH', wave.WAVE_FORMAT_PCM, 1, 11025, 11025, 1)
+        b = self._wave_file((b'fmt ', fmt))
+        with self.assertRaises(EOFError):
+            wave.open(io.BytesIO(b))
+
+    def test_read_skips_unknown_chunk(self):
+        # An unknown, odd-sized chunk between fmt and data must be skipped
+        # (including its pad byte) so the data chunk is still found.
+        data = b'\x01\x02\x03\x04'
+        b = self._wave_file((b'fmt ', self.FMT_PCM),
+                            (b'LIST', b'abc'),   # odd size, forces alignment
+                            (b'data', data))
+        with wave.open(io.BytesIO(b)) as r:
+            self.assertEqual(r.getnframes(), 4)
+            self.assertEqual(r.readframes(4), data)
+
+
+class WaveWriteValidationTest(unittest.TestCase):
+    """Cover parameter-validation paths of Wave_write."""
+
+    @staticmethod
+    def _close(w):
+        try:
+            # Make sure that all parameters are set
+            w.setnchannels(1)
+            w.setsampwidth(2)
+            w.setframerate(44100)
+        except wave.Error:
+            # Ignore "cannot change parameters after starting to write" error
+            pass
+
+        w.close()
+
+    def open_writer(self):
+        w = wave.open(io.BytesIO(), 'wb')
+        self.addCleanup(self._close, w)
+        return w
+
+    def test_get(self):
+        w = self.open_writer()
+        self.assertEqual(w.getformat(), wave.WAVE_FORMAT_PCM)
+        self.assertEqual(w.getnframes(), 0)
+        # getcomptype() and getcompname() raise AttributeError
+        # until setcomptype() is called
+
+        with self.assertRaisesRegex(wave.Error, 'number of channels not set'):
+            w.getnchannels()
+        with self.assertRaisesRegex(wave.Error, 'sample width not set'):
+            w.getsampwidth()
+        with self.assertRaisesRegex(wave.Error, 'frame rate not set'):
+            w.getframerate()
+        with self.assertRaisesRegex(wave.Error, 'not all parameters set'):
+            w.getparams()
+
+    def test_set(self):
+        w = self.open_writer()
+
+        w.setnchannels(1)
+        self.assertEqual(w.getnchannels(), 1)
+        with self.assertRaisesRegex(wave.Error, 'bad # of channels'):
+            w.setnchannels(0)
+
+        w.setsampwidth(2)
+        self.assertEqual(w.getsampwidth(), 2)
+        for width in (0, 5):
+            with self.subTest(width=width):
+                with self.assertRaisesRegex(wave.Error, 'bad sample width'):
+                    w.setsampwidth(width)
+
+        w.setframerate(44100)
+        self.assertEqual(w.getframerate(), 44100)
+        with self.assertRaisesRegex(wave.Error, 'bad frame rate'):
+            w.setframerate(0)
+
+        w.setnframes(10)
+        self.assertEqual(w.getnframes(), 0)
+
+        w.setcomptype('NONE', 'not compressed')
+        self.assertEqual(w.getcomptype(), 'NONE')
+        self.assertEqual(w.getcompname(), 'not compressed')
+        with self.assertRaisesRegex(wave.Error, 'unsupported compression type'):
+            w.setcomptype('ADPCM', 'unsupported')
+
+        w.setformat(wave.WAVE_FORMAT_PCM)
+        self.assertEqual(w.getformat(), wave.WAVE_FORMAT_PCM)
+        with self.assertRaisesRegex(wave.Error, 'unsupported wave format'):
+            w.setformat(0x1234)
+
+        w.setparams((1, 2, 44100, 0, 'NONE', 'not compressed'))
+        self.assertEqual(w.getparams(),
+                         (1, 2, 44100, 0, 'NONE', 'not compressed'))
+        with self.assertRaisesRegex(wave.Error, 'bad # of channels'):
+            w.setparams((0, 2, 44100, 0, 'NONE', 'not compressed'))
+
+    def test_tell(self):
+        def check_nframes(nframes):
+            self.assertEqual(w.tell(), nframes)
+            self.assertEqual(w.getnframes(), nframes)
+
+        w = self.open_writer()
+        w.setnchannels(1)
+        w.setsampwidth(2)
+        w.setframerate(44100)
+        check_nframes(0)
+
+        frame = b'\x00\x00'
+        w.writeframes(frame * 5)
+        check_nframes(5)
+
+        w.writeframes(frame * 3)
+        check_nframes(8)
+
+    def test_cannot_change_params_after_write(self):
+        w = self.open_writer()
+        w.setnchannels(1)
+        w.setsampwidth(2)
+        w.setframerate(44100)
+        w.writeframes(b'\x00\x00')
+
+        setters = (
+            ('setnchannels', (1,)),
+            ('setsampwidth', (2,)),
+            ('setframerate', (44100,)),
+            ('setnframes', (10,)),
+            ('setcomptype', ('NONE', 'not compressed')),
+            ('setformat', (wave.WAVE_FORMAT_PCM,)),
+            ('setparams', ((1, 2, 44100, 0, 'NONE', 'not compressed'),)),
+        )
+        for name, args in setters:
+            with self.subTest(setter=name):
+                with self.assertRaisesRegex(wave.Error,
+                                            'cannot change parameters'):
+                    getattr(w, name)(*args)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Misc/NEWS.d/next/Build/2026-08-10-12-00-00.gh-issue-90604.Kx7pQn.rst b/Misc/NEWS.d/next/Build/2026-08-10-12-00-00.gh-issue-90604.Kx7pQn.rst
new file mode 100644
index 000000000000000..a367e2aef4ac59a
--- /dev/null
+++ b/Misc/NEWS.d/next/Build/2026-08-10-12-00-00.gh-issue-90604.Kx7pQn.rst
@@ -0,0 +1 @@
+``configure`` no longer sets ``MULTIARCH`` on OpenBSD platforms.
diff --git a/Misc/NEWS.d/next/Library/2026-07-19-13-00-00.gh-issue-154086.MJKrQV.rst b/Misc/NEWS.d/next/Library/2026-07-19-13-00-00.gh-issue-154086.MJKrQV.rst
new file mode 100644
index 000000000000000..f28037d46520f6d
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2026-07-19-13-00-00.gh-issue-154086.MJKrQV.rst
@@ -0,0 +1,2 @@
+Store per-thread sample counts in Tachyon flamegraphs so filtering a thread
+updates frame widths and totals.
diff --git a/configure b/configure
index 836eb88e4cdb6e5..e81b221faded675 100755
--- a/configure
+++ b/configure
@@ -7376,6 +7376,8 @@ case $ac_sys_system in #(
     MULTIARCH="" ;; #(
   FreeBSD*) :
     MULTIARCH="" ;; #(
+  OpenBSD*) :
+    MULTIARCH="" ;; #(
   *) :
     MULTIARCH=$($CC --print-multiarch 2>/dev/null)
  ;;
diff --git a/configure.ac b/configure.ac
index 3a9841b1e7d0747..36568288388555a 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1202,6 +1202,7 @@ AS_CASE([$ac_sys_system],
   [Darwin*], [MULTIARCH=""],
   [iOS], [MULTIARCH=""],
   [FreeBSD*], [MULTIARCH=""],
+  [OpenBSD*], [MULTIARCH=""],
   [MULTIARCH=$($CC --print-multiarch 2>/dev/null)]
 )
 AC_SUBST([MULTIARCH])