TinTin++ is a command line MUD client which features support for
TELNET, PCRE, UTF-8, SSL, VT100, IPv6, the dynamic TINTIN scripting
language, a comprensive trigger system, and several other features
geared towards mudding, scripting, shell-scripting, text processing,
automation, interprocess communication, redirection, xterm terminal
emulation, and multiplexing / demultiplexing.
[libc++][Android] Clean up pre-API-23 carveouts and document LIBCXX-ANDROID-FIXMEs
Due to updating the Android sysroot and compiler in previous upgrades, certain test configurations can be updated by switching them from `UNSUPPORTED` to `XFAIL` and dropping obsolete API carveouts. In addition, document root cause and resolutions for other `LIBCXX-ANDROID-FIXME`.
Assisted-by: Gemini
[libc++][Android] Update compiler to r614150 for Android libc++ builders
Libc++ is dropping Clang 21 in https://github.com/llvm/llvm-project/pull/231580 so upgrade Android's compiler from r596125 to r614150. Android's r614150 compiler was cut before `__builtin_clear_padding` landed, causing the atomic padding tests to fail so we also mark those tests as `UNSUPPORTED: LIBCXX-ANDROID-FIXME` until the next compiler update.
Assisted-by: Gemini
[llvm-objdump] Require the ARM target in armnt-exports.yaml (#243683)
The test from #242496 disassembles Thumb code, so it fails on builds
without the ARM target, like the NVPTX and AMDGPU bots. Mark it
REQUIRES: arm-registered-target, as arm64ec.yaml next to it does for
AArch64.
Assisted-by: Claude Opus 5.5 (Anthropic)
[ProcessImplicitDefs] Split the analysis from the transformation (NFC)
Add ImplicitDefInfo, it computes which uses become undef and which
instructions become IMPLICIT_DEFs. It also computes which of these
IMPLICIT_DEFs are erased, without modifying the function.
ProcessImplicitDefs now applies its results, then erases or moves the
IMPLICIT_DEFs bottom-up in each block. Physical registers handling is
unchanged.
This lets passes that run earlier, such as the MachinePipeliner's
register pressure check, see what ProcessImplicitDefs will do without
duplicating its rules.
Assisted-By: Opus 5.5
Add Time2Retain and per-nexus UA tests
Add tests for the LIO fixes that close a session left in Time2Retain
and that stop holding a unit attention for an initiator with no
session.
test_270_iscsi_time2retain.py: a session is put into Time2Retain with
a connection-level logout, then the TPG is disabled, the node ACL is
removed, the target is deleted, or the initiator logs in again with
the same name and ISID. Each must return and leave no session behind.
Also covered: disabling the TPG as the retain timer expires, the same
operations with a live session, and 300 same-ISID relogins that each
race a TCP drop of the old connection. Every step that can hang runs
under a time limit, and each test fails on a new oops, KASAN or lockdep
line in dmesg.
test_267_iscsi_ua_pr_per_nexus.py: after a registered initiator has
gone and another preempts its registration, the initiator must not get
REGISTRATIONS PREEMPTED when it logs in again, either with no session
[10 lines not shown]
krb5: Import MIT 1.22.3
Major changes in 1.22.3 (2026-11-09)
====================================
This is a bug fix release, with a focus on security issues discovered
with the aid of large language models. See
https://web.mit.edu/kerberos/advisories/MITKRB5-SA-2026-001.txt for
information on the risks of continuing to use unpatched releases.
* Fix a logic error when checking PAC server checksums
[CVE-2026-111423].
* Check for unkeyed checksums when validating CAMMAC verifiers
[CVE-2026-71199].
* Fix a loophole in the KDC's client authdata filtering which could
allow clients to include fake PAC and CAMMAC authdata values when
requesting service tickets. These fake values would be rejected by
[52 lines not shown]
[MachinePipeliner] Don't count implicit-def values as register pressure
The register pressure detector runs before ProcessImplicitDefs, so it
counts values that only come from IMPLICIT_DEF as registers, although
they never get one. Later in the pipeline, ProcessImplicitDefs marks
their reads undef and deletes their definitions. MachineLICM hoists
these IMPLICIT_DEFs and the copies of them out of loops, so the
detector counts each one as a register live in the whole loop and
overestimates the pressure. On AMDGPU, which enables the detector by
default, it can then reject every II and leave the loop unpipelined.
Use ImplicitDefInfo to leave out the reads that ProcessImplicitDefs
marks undef and the definitions it deletes. On targets where InitUndef
runs first, keep counting the untied undef reads of instructions with
an early-clobber def, since InitUndef may give them a register.
Fixes #238634
[flang] Use standard dummy argument names for IEEE_FMA and IEEE_GET_STATUS/IEEE_SET_STATUS (#239448)
Fixes #239056
`IEEE_FMA` and the `IEEE_EXCEPTIONS` procedures
`IEEE_GET_STATUS`/`IEEE_SET_STATUS` declared dummy arguments that do not
match the standard (`F1, F2, F3` instead of `A, B, C` per F2023 17.11.4,
and `STATUS` instead of `STATUS_VALUE`), so standard-conforming keyword
references were rejected while non-standard ones were accepted:
a = ieee_fma(a=1.0, b=2.0, c=3.0) ! was: unknown keyword argument to
intrinsic '__builtin_fma'
call ieee_get_status(status_value=s) ! was: no specific subroutine
matches
This renames the dummy arguments to the standard names and adds
`flang/test/Semantics/ieee_keywords_fma_status.f90` covering positional,
valid-keyword, and invalid-keyword references.
[3 lines not shown]
[libc++][Android] Clean up pre-API-23 carveouts and document LIBCXX-ANDROID-FIXMEs
Due to updating the Android sysroot and compiler in previous upgrades, certain test configurations can be updated by switching them from `UNSUPPORTED` to `XFAIL` and dropping obsolete API carveouts. In addition, document root cause and resolutions for other `LIBCXX-ANDROID-FIXME`.
Assisted-by: Gemini
[libc++][Android] Update compiler to r614150 for Android libc++ builders
Libc++ is dropping Clang 21 in https://github.com/llvm/llvm-project/pull/231580 so upgrade Android's compiler from r596125 to r614150. Android's r614150 compiler was cut before `__builtin_clear_padding` landed, causing the atomic padding tests to fail so we also mark those tests as `UNSUPPORTED: LIBCXX-ANDROID-FIXME` until the next compiler update.
Assisted-by: Gemini
[SampleProfile] Preserve orphaned local profiles across ThinLTO
The sample pre-inliner can keep a local function R's profile separate
from its only caller G. If the regular pre-link inliner then inlines R
into G and deletes R, it also loses R's import hints. In the backend,
G's profile has no nested R context, so R's remaining calls miss their
profile's inlining decisions.
Carry a sole local callee's import hints up to its caller. In post-link,
allow a missing inline context to use the deleted local function's
top-level profile, subject to the call-count and probe-checksum checks.
Load missing extbinary roots on demand instead of decoding all profiles.
Control this behavior independently of in-module indirect-target importing
with -sample-profile-preserve-orphaned-inlines, enabled by default.
Cover hint propagation, profile lookup, rejection cases, and selective
extbinary loading in the local orphaned-root test.
Assisted-by: GPT-6 Astra
[SampleProfile] Recover orphaned profiles inside imported code
An imported function can contain an orphaned inline frame without having
its own top-level profile. Scan available callee bodies using their nested
call-site profiles so on-demand loading also finds roots inside them.
Cache each function/profile scan and each inline-frame lookup.
Import does not copy pseudo-probe descriptors. Allow a missing descriptor
when recovering a root, while still rejecting a known checksum mismatch.
Also propagate import GUIDs through callers with unknown entry count -1,
preserving that count rather than stopping at getEntryCount().
Add a pre-link/post-link regression covering an imported H without a root,
a non-local R already inlined into H, missing imported descriptors, and
forwarding hints through a caller without samples. Retain the call-count
rejection case. The SampleProfile suite passes in Debug and Release.
Adapted from be98486efe13fc (imported orphan-root prototype).
Assisted-by: GPT-6 Astra
[SampleProfile] Recover orphaned roots of non-local functions
A function need not have local linkage to disappear after pre-link
inlining. Templates and other linkonce_odr functions can leave an inline
frame behind while their separate profile remains a top-level root.
Add -sample-profile-orphaned-nonlocal-roots to allow the existing root
lookup for non-local frames, retaining the call-count and checksum checks.
Also forward import GUIDs from sole callees that are discardable when
unused. Keep the additional option disabled by default.
Adapt the original prototype to the independent orphaned-profile flag
and the compact tests. The local/non-local controls, count/checksum
rejections, and linkonce_odr import-hint case pass in Debug and Release.
Adapted from 90b4a6c59c7860 (non-local orphan-root prototype).
Assisted-by: GPT-6 Astra
[SampleProfile] Hint imports for in-module indirect call targets (#243573)
ThinLTO can import a function without bringing along the indirect target
that its profile expects to inline. The imported code can then retain an
indirect call even though the profile identifies the hot target.
Consider a [Godbolt example](https://godbolt.org/z/fYzv9cTeb) that shows
the missing import. The `worker` in `driver.cpp` calling `run_batch` in
`core.cpp` . `run_batch` indirectly calls `hot_target`, also defined in
`core.cpp` . In all three cases below, the profile says to inline
`hot_target` into `run_batch`:
| Case | Behavior before this patch |
|---|---|
| The profile also says to inline `run_batch` into `worker`. | While
processing `worker`, the sample loader records import hints for both
functions, since both are external to `driver.cpp`. Both bodies can be
imported. |
| The profile keeps `run_batch` separate, and ThinLTO does not otherwise
[38 lines not shown]