<!DOCTYPE html>
<html lang="en"><head>
  <meta content="text/html; charset=UTF-8" http-equiv="Content-Type">
  <meta content="width=device-width, initial-scale=1, shrink-to-fit=no" name="viewport">
  <title>P2268R0: Freestanding Roadmap</title>
<style data-fill-with="stylesheet">/******************************************************************************
 *                   Style sheet for the W3C specifications                   *
 *
 * Special classes handled by this style sheet include:
 *
 * Indices
 *   - .toc for the Table of Contents (<ol class="toc">)
 *     + <span class="secno"> for the section numbers
 *   - #toc for the Table of Contents (<nav id="toc">)
 *   - ul.index for Indices (<a href="#ref">term</a><span>, in §N.M</span>)
 *   - table.index for Index Tables (e.g. for properties or elements)
 *
 * Structural Markup
 *   - table.data for general data tables
 *     -> use 'scope' attribute, <colgroup>, <thead>, and <tbody> for best results !
 *     -> use <table class='complex data'> for extra-complex tables
 *     -> use <td class='long'> for paragraph-length cell content
 *     -> use <td class='pre'> when manual line breaks/indentation would help readability
 *   - dl.switch for switch statements
 *   - ol.algorithm for algorithms (helps to visualize nesting)
 *   - .figure and .caption (HTML4) and figure and figcaption (HTML5)
 *     -> .sidefigure for right-floated figures
 *   - ins/del
 *     -> ins/del.c### for candidate and proposed changes (amendments)
 *
 * Code
 *   - pre and code
 *
 * Special Sections
 *   - .note       for informative notes             (div, p, span, aside, details)
 *   - .example    for informative examples          (div, p, pre, span)
 *   - .issue      for issues                        (div, p, span)
 *   - .advisement for loud normative statements     (div, p, strong)
 *   - .annoying-warning for spec obsoletion notices (div, aside, details)
 *   - .correction for "candidate corrections"       (div, aside, details, section)
 *   - .addition   for "candidate additions"         (div, aside, details, section)
 *   - .correction.proposed for "proposed corrections" (div, aside, details, section)
 *   - .addition.proposed   for "proposed additions"   (div, aside, details, section)
 *
 * Definition Boxes
 *   - pre.def   for WebIDL definitions
 *   - table.def for tables that define other entities (e.g. CSS properties)
 *   - dl.def    for definition lists that define other entitles (e.g. HTML elements)
 *
 * Numbering
 *   - .secno for section numbers in .toc and headings (<span class='secno'>3.2</span>)
 *   - .marker for source-inserted example/figure/issue numbers (<span class='marker'>Issue 4</span>)
 *   - ::before styled for CSS-generated issue/example/figure numbers:
 *     -> Documents wishing to use this only need to add
 *        figcaption::before,
 *        .caption::before { content: "Figure "  counter(figure) " ";  }
 *        .example::before { content: "Example " counter(example) " "; }
 *        .issue::before   { content: "Issue "   counter(issue) " ";   }
 *
 * Header Stuff (ignore, just don't conflict with these classes)
 *   - .head for the header
 *   - .copyright for the copyright
 *
 * Outdated warning for old specs
 *
 * Miscellaneous
 *   - .overlarge for things that should be as wide as possible, even if
 *     that overflows the body text area. This can be used on an item or
 *     on its container, depending on the effect desired.
 *     Note that this styling basically doesn't help at all when printing,
 *     since A4 paper isn't much wider than the max-width here.
 *     It's better to design things to fit into a narrower measure if possible.
 *
 *   - js-added ToC jump links (see fixup.js)
 *
 ******************************************************************************/

/* color variables included separately for reliability */

/******************************************************************************/
/*                                    Body                                    */
/******************************************************************************/

	html {
	}

	body {
		counter-reset: example figure issue;

		/* Layout */
		max-width: 50em;			  /* limit line length to 50em for readability   */
		margin: 0 auto;				/* center text within page                    */
		padding: 1.6em 1.5em 2em 50px; /* assume 16px font size for downlevel clients */
		padding: 1.6em 1.5em 2em calc(26px + 1.5em); /* leave space for status flag    */

		/* Typography */
		line-height: 1.5;
		font-family: sans-serif;
		widows: 2;
		orphans: 2;
		word-wrap: break-word;
		overflow-wrap: break-word;
		hyphens: auto;

		color: black;
		color: var(--text);
		background: white top left fixed no-repeat;
		background: var(--bg) top left fixed no-repeat;
		background-size: 25px auto;
	}


/******************************************************************************/
/*                         Front Matter & Navigation                          */
/******************************************************************************/

/** Header ********************************************************************/

	div.head { margin-bottom: 1em; }
	div.head hr { border-style: solid; }

	div.head h1 {
		font-weight: bold;
		margin: 0 0 .1em;
		font-size: 220%;
	}

	div.head h2 { margin-bottom: 1.5em;}

/** W3C Logo ******************************************************************/

	.head .logo {
		float: right;
		margin: 0.4rem 0 0.2rem .4rem;
	}

	.head img[src*="logos/W3C"] {
		display: block;
		border: solid #1a5e9a;
		border: solid var(--logo-bg);
		border-width: .65rem .7rem .6rem;
		border-radius: .4rem;
		background: #1a5e9a;
		background: var(--logo-bg);
		color: white;
		color: var(--logo-text);
		font-weight: bold;
	}

	.head a:hover > img[src*="logos/W3C"],
	.head a:focus > img[src*="logos/W3C"] {
		opacity: .8;
	}

	.head a:active > img[src*="logos/W3C"] {
		background: #c00;
		background: var(--logo-active-bg);
		border-color: #c00;
		border-color: var(--logo-active-bg);
	}

	/* see also additional rules in Link Styling section */

/** Copyright *****************************************************************/

	p.copyright,
	p.copyright small { font-size: small; }

/** Back to Top / ToC Toggle **************************************************/

	@media print {
		#toc-nav {
			display: none;
		}
	}
	@media not print {
		#toc-nav {
			position: fixed;
			z-index: 3;
			bottom: 0; left: 0;
			margin: 0;
			min-width: 1.33em;
			border-top-right-radius: 2rem;
			box-shadow: 0 0 2px;
			font-size: 1.5em;
		}
		#toc-nav > a {
			display: block;
			white-space: nowrap;

			height: 1.33em;
			padding: .1em 0.3em;
			margin: 0;

			box-shadow: 0 0 2px;
			border: none;
			border-top-right-radius: 1.33em;

			color: #707070;
			color: var(--tocnav-normal-text);
			background: white;
			background: var(--tocnav-normal-bg);
		}
		#toc-nav > a:hover,
		#toc-nav > a:focus {
			color: black;
			color: var(--tocnav-hover-text);
			background: #f8f8f8;
			background: var(--tocnav-hover-bg);
		}
		#toc-nav > a:active {
			color: #c00;
			color: var(--tocnav-active-text);
			background: white;
			background: var(--tocnav-active-bg);
		}

		#toc-nav > #toc-jump {
			padding-bottom: 2em;
			margin-bottom: -1.9em;
		}

		/* statusbar gets in the way on keyboard focus; remove once browsers fix */
		#toc-nav > a[href="#toc"]:not(:hover):focus:last-child {
			padding-bottom: 1.5rem;
		}

		#toc-nav:not(:hover) > a:not(:focus) > span + span {
			/* Ideally this uses :focus-within on #toc-nav */
			display: none;
		}
		#toc-nav > a > span + span {
			padding-right: 0.2em;
		}
	}

/** ToC Sidebar ***************************************************************/

	/* Floating sidebar */
	@media screen {
		body.toc-sidebar #toc {
			position: fixed;
			top: 0; bottom: 0;
			left: 0;
			width: 23.5em;
			max-width: 80%;
			max-width: calc(100% - 2em - 26px);
			overflow: auto;
			padding: 0 1em;
			padding-left: 42px;
			padding-left: calc(1em + 26px);
			color: black;
			color: var(--tocsidebar-text);
			background: inherit;
			background-color: #f7f8f9;
			background-color: var(--tocsidebar-bg);
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
			box-shadow: -.1em 0 .25em var(--tocsidebar-shadow) inset;
		}
		body.toc-sidebar #toc h2 {
			margin-top: .8rem;
			font-variant: small-caps;
			font-variant: all-small-caps;
			text-transform: lowercase;
			font-weight: bold;
			color: gray;
			color: hsla(203,20%,40%,.7);
			color: var(--tocsidebar-heading-text);
		}
		body.toc-sidebar #toc-jump:not(:focus) {
			width: 0;
			height: 0;
			padding: 0;
			position: absolute;
			overflow: hidden;
		}
	}
	/* Hide main scroller when only the ToC is visible anyway */
	@media screen and (max-width: 28em) {
		body.toc-sidebar {
			overflow: hidden;
		}
	}

	/* Sidebar with its own space */
	@media screen and (min-width: 78em) {
		body:not(.toc-inline) #toc {
			position: fixed;
			top: 0; bottom: 0;
			left: 0;
			width: 23.5em;
			overflow: auto;
			padding: 0 1em;
			padding-left: 42px;
			padding-left: calc(1em + 26px);
			color: black;
			color: var(--tocsidebar-text);
			background: inherit;
			background-color: #f7f8f9;
			background-color: var(--tocsidebar-bg);
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
			box-shadow: -.1em 0 .25em var(--tocsidebar-shadow) inset;
		}
		body:not(.toc-inline) #toc h2 {
			margin-top: .8rem;
			font-variant: small-caps;
			font-variant: all-small-caps;
			text-transform: lowercase;
			font-weight: bold;
			color: gray;
			color: hsla(203,20%,40%,.7);
			color: var(--tocsidebar-heading-text);
		}

		body:not(.toc-inline) {
			padding-left: 29em;
		}
		/* See also Overflow section at the bottom */

		body:not(.toc-inline) #toc-jump:not(:focus) {
			width: 0;
			height: 0;
			padding: 0;
			position: absolute;
			overflow: hidden;
		}
	}
	@media screen and (min-width: 90em) {
		body:not(.toc-inline) {
			margin: 0 4em;
		}
	}

/******************************************************************************/
/*                                Sectioning                                  */
/******************************************************************************/

/** Headings ******************************************************************/

	h1, h2, h3, h4, h5, h6, dt {
		page-break-after: avoid;
		page-break-inside: avoid;
		font: 100% sans-serif;   /* Reset all font styling to clear out UA styles */
		font-family: inherit;	/* Inherit the font family. */
		line-height: 1.2;		/* Keep wrapped headings compact */
		hyphens: manual;		/* Hyphenated headings look weird */
	}

	h2, h3, h4, h5, h6 {
		margin-top: 3rem;
	}

	h1, h2, h3 {
		color: #005A9C;
		color: var(--heading-text);
	}

	h1 { font-size: 170%; }
	h2 { font-size: 140%; }
	h3 { font-size: 120%; }
	h4 { font-weight: bold; }
	h5 { font-style: italic; }
	h6 { font-variant: small-caps; }
	dt { font-weight: bold; }

/** Subheadings ***************************************************************/

	h1 + h2,
	#subtitle {
		/* #subtitle is a subtitle in an H2 under the H1 */
		margin-top: 0;
	}
	h2 + h3,
	h3 + h4,
	h4 + h5,
	h5 + h6 {
		margin-top: 1.2em; /* = 1 x line-height */
	}

/** Section divider ***********************************************************/

	:not(.head) > :not(.head) + hr {
		font-size: 1.5em;
		text-align: center;
		margin: 1em auto;
		height: auto;
		color: black;
		color: var(--hr-text);
		border: transparent solid 0;
		background: transparent;
	}
	:not(.head) > hr::before {
		content: "\2727\2003\2003\2727\2003\2003\2727";
	}

/******************************************************************************/
/*                            Paragraphs and Lists                            */
/******************************************************************************/

	p {
		margin: 1em 0;
	}

	dd > p:first-child,
	li > p:first-child {
		margin-top: 0;
	}

	ul, ol {
		margin-left: 0;
		padding-left: 2em;
	}

	li {
		margin: 0.25em 0 0.5em;
		padding: 0;
	}

	dl dd {
		margin: 0 0 .5em 2em;
	}

	.head dd + dd { /* compact for header */
		margin-top: -.5em;
	}

	/* Style for algorithms */
	ol.algorithm ol:not(.algorithm),
	.algorithm > ol ol:not(.algorithm) {
	border-left: 0.5em solid #DEF;
	border-left: 0.5em solid var(--algo-border);
	}

	/* Put nice boxes around each algorithm. */
	[data-algorithm]:not(.heading) {
	 padding: .5em;
	 border: thin solid #ddd;
	 border: thin solid var(--algo-border);
	 border-radius: .5em;
	 margin: .5em calc(-0.5em - 1px);
	}
	[data-algorithm]:not(.heading) > :first-child {
	 margin-top: 0;
	}
	[data-algorithm]:not(.heading) > :last-child {
	 margin-bottom: 0;
	}

	/* Style for switch/case <dl>s */
	dl.switch > dd > ol.only,
	dl.switch > dd > .only > ol {
	margin-left: 0;
	}
	dl.switch > dd > ol.algorithm,
	dl.switch > dd > .algorithm > ol {
	margin-left: -2em;
	}
	dl.switch {
	padding-left: 2em;
	}
	dl.switch > dt {
	text-indent: -1.5em;
	margin-top: 1em;
	}
	dl.switch > dt + dt {
	margin-top: 0;
	}
	dl.switch > dt::before {
	content: '\21AA';
	padding: 0 0.5em 0 0;
	display: inline-block;
	width: 1em;
	text-align: right;
	line-height: 0.5em;
	}

/** Terminology Markup ********************************************************/


/******************************************************************************/
/*                                 Inline Markup                              */
/******************************************************************************/

/** Terminology Markup ********************************************************/
	dfn   { /* Defining instance */
		font-weight: bolder;
	}
	a > i { /* Instance of term */
		font-style: normal;
	}
	dt dfn code, code.idl {
		font-size: inherit;
	}
	dfn var {
		font-style: normal;
	}

/** Change Marking ************************************************************/

	del {
		color: #aa0000;
		color: var(--del-text);
		background: transparent;
		background: var(--del-bg);
		text-decoration: line-through;
	}
	ins {
		color: #006100;
		color: var(--ins-text);
		background: transparent;
		background: var(--ins-bg);
		text-decoration: underline;
	}

	/* for amendments (candidate/proposed changes) */

	.amendment ins, .correction ins, .addition ins,
	ins[class^=c] {
		text-decoration-style: dotted;
	}
	.amendment del, .correction del, .addition del,
	del[class^=c] {
		text-decoration-style: dotted;
	}
	.amendment.proposed ins, .correction.proposed ins, .addition.proposed ins,
	ins[class^=c].proposed {
		text-decoration-style: double;
	}
	.amendment.proposed del, .correction.proposed del, .addition.proposed del,
	del[class^=c].proposed {
		text-decoration-style: double;
	}

/** Miscellaneous improvements to inline formatting ***************************/

	sup {
		vertical-align: super;
		font-size: 80%
	}

/******************************************************************************/
/*                                    Code                                    */
/******************************************************************************/

/** General monospace/pre rules ***********************************************/

	pre, code, samp {
		font-family: Menlo, Consolas, "DejaVu Sans Mono", Monaco, monospace;
		font-size: .9em;
		hyphens: none;
		text-transform: none;
		text-align: left;
		text-align: start;
		font-variant: normal;
		orphans: 3;
		widows: 3;
		page-break-before: avoid;
	}
	pre code,
	code code {
		font-size: 100%;
	}

	pre {
		margin-top: 1em;
		margin-bottom: 1em;
		overflow: auto;
	}

/** Inline Code fragments *****************************************************/

	/* Do something nice. */

/******************************************************************************/
/*                                    Links                                   */
/******************************************************************************/

/** General Hyperlinks ********************************************************/

	/* We hyperlink a lot, so make it less intrusive */
	a[href] {
		color: #034575;
		color: var(--a-normal-text);
		text-decoration: none;
		border-bottom: 1px solid #707070;
		border-bottom: 1px solid var(--a-normal-underline);
		/* Need a bit of extending for it to look okay */
		padding: 0 1px 0;
		margin: 0 -1px 0;
	}
	a:visited {
		color: #034575;
		color: var(--a-visited-text);
		border-bottom-color: #bbb;
		border-bottom-color: var(--a-visited-underline);
	}

	/* Use distinguishing colors when user is interacting with the link */
	a[href]:focus,
	a[href]:hover {
		background: #f8f8f8;
		background: rgba(75%, 75%, 75%, .25);
		background: var(--a-hover-bg);
		border-bottom-width: 3px;
		margin-bottom: -2px;
	}
	a[href]:active {
		color: #c00;
		color: var(--a-active-text);
		border-color: #c00;
		border-color: var(--a-active-underline);
	}

	/* Backout above styling for W3C logo */
	.head .logo,
	.head .logo a {
		border: none;
		text-decoration: none;
		background: transparent;
	}

/******************************************************************************/
/*                                    Images                                  */
/******************************************************************************/

	img {
		border-style: none;
	}

	img, svg {
		/* Intentionally not color-scheme aware. */
		background: white;
	}

	/* For autogen numbers, add
	  .caption::before, figcaption::before { content: "Figure " counter(figure) ". "; }
	*/

	figure, .figure, .sidefigure {
		page-break-inside: avoid;
		text-align: center;
		margin: 2.5em 0;
	}
	.figure img,	.sidefigure img,	figure img,
	.figure object, .sidefigure object, figure object {
		max-width: 100%;
		margin: auto;
		height: auto;
	}
	.figure pre, .sidefigure pre, figure pre {
		text-align: left;
		display: table;
		margin: 1em auto;
	}
	.figure table, figure table {
		margin: auto;
	}
	@media screen and (min-width: 20em) {
		.sidefigure {
			float: right;
			width: 50%;
			margin: 0 0 0.5em 0.5em;
		}
	}
	.caption, figcaption, caption {
		font-style: italic;
		font-size: 90%;
	}
	.caption::before, figcaption::before, figcaption > .marker {
		font-weight: bold;
	}
	.caption, figcaption {
		counter-increment: figure;
	}

	/* DL list is indented 2em, but figure inside it is not */
	dd > .figure, dd > figure { margin-left: -2em; }

/******************************************************************************/
/*                             Colored Boxes                                  */
/******************************************************************************/

	.issue, .note, .example, .assertion, .advisement, blockquote,
	.amendment, .correction, .addition {
		margin: 1em auto;
		padding: .5em;
		border: .5em;
		border-left-style: solid;
		page-break-inside: avoid;
	}
	span.issue, span.note {
		padding: .1em .5em .15em;
		border-right-style: solid;
	}

	blockquote > :first-child,
	.note  > p:first-child,
	.issue > p:first-child,
	.amendment > p:first-child,
	.correction > p:first-child,
	.addition > p:first-child {
		margin-top: 0;
	}
	blockquote > :last-child,
	.note  > p:last-child,
	.issue > p:last-child,
	.amendment > p:last-child,
	.correction > p:last-child,
	.addition > p:last-child {
		margin-bottom: 0;
	}


	.issue::before, .issue > .marker,
	.example::before, .example > .marker,
	.note::before, .note > .marker,
	details.note > summary > .marker,
	.amendment::before, .amendment > .marker,
	details.amendment > summary > .marker,
	.addition::before, .addition > .marker,
	addition.amendment > summary > .marker,
	.correction::before, .correction > .marker,
	correction.amendment > summary > .marker
	{
		text-transform: uppercase;
		padding-right: 1em;
	}

	.example::before, .example > .marker {
		display: block;
		padding-right: 0em;
	}

/** Blockquotes ***************************************************************/

	blockquote {
		border-color: silver;
		border-color: var(--blockquote-border);
		background: transparent;
		background: var(--blockquote-bg);
		color: currentcolor;
		color: var(--blockquote-text);
	}

/** Open issue ****************************************************************/

	.issue {
		border-color: #e05252;
		border-color: var(--issue-border);
		background: #fbe9e9;
		background: var(--issue-bg);
		color: black;
		color: var(--issue-text);
		counter-increment: issue;
		overflow: auto;
	}
	.issue::before, .issue > .marker {
		color: #831616;
		color: var(--issueheading-text);
	}
	/* Add .issue::before { content: "Issue " counter(issue) " "; } for autogen numbers,
	  or use class="marker" to mark up the issue number in source. */

/** Example *******************************************************************/

	.example {
		border-color: #e0cb52;
		border-color: var(--example-border);
		background: #fcfaee;
		background: var(--example-bg);
		color: black;
		color: var(--example-text);
		counter-increment: example;
		overflow: auto;
		clear: both;
	}
	.example::before, .example > .marker {
		color: #574b0f;
		color: var(--exampleheading-text);
	}
	/* Add .example::before { content: "Example " counter(example) " "; } for autogen numbers,
	  or use class="marker" to mark up the example number in source. */

/** Non-normative Note ********************************************************/

	.note {
		border-color: #52e052;
		border-color: var(--note-border);
		background: #e9fbe9;
		background: var(--note-bg);
		color: black;
		color: var(--note-text);
		overflow: auto;
	}

	.note::before, .note > .marker,
	details.note > summary {
		color: hsl(120, 70%, 30%);
		color: var(--noteheading-text);
	}
	/* Add .note::before { content: "Note "; } for autogen label,
	  or use class="marker" to mark up the label in source. */

	details.note[open] > summary {
		border-bottom: 1px silver solid;
		border-bottom: 1px var(--notesummary-underline) solid;
	}

/** Assertion Box *************************************************************/
	/*  for assertions in algorithms */

	.assertion {
		border-color: #AAA;
		border-color: var(--assertion-border);
		background: #EEE;
		background: var(--assertion-bg);
		color: black;
		color: var(--assertion-text);
	}

/** Advisement Box ************************************************************/
	/*  for attention-grabbing normative statements */

	.advisement {
		border-color: orange;
		border-color: var(--advisement-border);
		border-style: none solid;
		background: #fec;
		background: var(--advisement-bg);
		color: black;
		color: var(--advisement-text);
	}
	strong.advisement {
		display: block;
		text-align: center;
	}
	.advisement::before, .advisement > .marker {
		color: #b35f00;
		color: var(--advisementheading-text);
	}

/** Amendment Box *************************************************************/

	.amendment, .correction, .addition {
		border-color: #330099;
		border-color: var(--amendment-border);
		background: #F5F0FF;
		background: var(--amendment-bg);
		color: black;
		color: var(--amendment-text);
	}
	.amendment.proposed, .correction.proposed, .addition.proposed {
		border-style: solid;
		border-block-width: 0.25em;
	}
	.amendment::before, .amendment > .marker,
	details.amendment > summary::before, details.amendment > summary > .marker,
	.correction::before, .correction > .marker,
	details.correction > summary::before, details.correction > summary > .marker,
	.addition::before, .addition > .marker,
	details.addition > summary::before, details.addition > summary > .marker {
		color: #220066;
		color: var(--amendmentheading-text);
	}
	.amendment.proposed::before, .amendment.proposed > .marker,
	details.amendment.proposed > summary::before, details.amendment.proposed > summary > .marker,
	.correction.proposed::before, .correction.proposed > .marker,
	details.correction.proposed > summary::before, details.correction.proposed > summary > .marker,
	.addition.proposed::before, .addition.proposed > .marker,
	details.addition.proposed > summary::before, details.addition.proposed > summary > .marker {
		font-weight: bold;
	}

/** Spec Obsoletion Notice ****************************************************/
	/* obnoxious obsoletion notice for older/abandoned specs. */

	details {
		display: block;
	}
	summary {
		font-weight: bolder;
	}

	.annoying-warning:not(details),
	details.annoying-warning:not([open]) > summary,
	details.annoying-warning[open] {
		background: hsla(40,100%,50%,0.95);
		background: var(--warning-bg);
		color: black;
		color: var(--warning-text);
		padding: .75em 1em;
		border: red;
		border: var(--warning-border);
		border-style: solid none;
		box-shadow: 0 2px 8px black;
		text-align: center;
	}
	.annoying-warning :last-child {
		margin-bottom: 0;
	}

@media not print {
	details.annoying-warning[open] {
		position: fixed;
		left: 0;
		right: 0;
		bottom: 2em;
		z-index: 1000;
	}
}

	details.annoying-warning:not([open]) > summary {
		text-align: center;
	}

/** Entity Definition Boxes ***************************************************/

	.def {
		padding: .5em 1em;
		background: #def;
		background: var(--def-bg);
		margin: 1.2em 0;
		border-left: 0.5em solid #8ccbf2;
		border-left: 0.5em solid var(--def-border);
		color: black;
		color: var(--def-text);
	}

/******************************************************************************/
/*                                    Tables                                  */
/******************************************************************************/

	th, td {
		text-align: left;
		text-align: start;
	}

/** Property/Descriptor Definition Tables *************************************/

	table.def {
		/* inherits .def box styling, see above */
		width: 100%;
		border-spacing: 0;
	}

	table.def td,
	table.def th {
		padding: 0.5em;
		vertical-align: baseline;
		border-bottom: 1px solid #bbd7e9;
		border-bottom: 1px solid var(--defrow-border);
	}

	table.def > tbody > tr:last-child th,
	table.def > tbody > tr:last-child td {
		border-bottom: 0;
	}

	table.def th {
		font-style: italic;
		font-weight: normal;
		padding-left: 1em;
		width: 3em;
	}

	/* For when values are extra-complex and need formatting for readability */
	table td.pre {
		white-space: pre-wrap;
	}

	/* A footnote at the bottom of a def table */
	table.def td.footnote {
		padding-top: 0.6em;
	}
	table.def td.footnote::before {
		content: " ";
		display: block;
		height: 0.6em;
		width: 4em;
		border-top: thin solid;
	}

/** Data tables (and properly marked-up index tables) *************************/
	/*
		<table class="data"> highlights structural relationships in a table
		when correct markup is used (e.g. thead/tbody, th vs. td, scope attribute)

		Use class="complex data" for particularly complicated tables --
		(This will draw more lines: busier, but clearer.)

		Use class="long" on table cells with paragraph-like contents
		(This will adjust text alignment accordingly.)
		Alternately use class="longlastcol" on tables, to have the last column assume "long".
	*/

	table {
		word-wrap: normal;
		overflow-wrap: normal;
		hyphens: manual;
	}

	table.data,
	table.index {
		margin: 1em auto;
		border-collapse: collapse;
		border: hidden;
		width: 100%;
	}
	table.data caption,
	table.index caption {
		max-width: 50em;
		margin: 0 auto 1em;
	}

	table.data td,  table.data th,
	table.index td, table.index th {
		padding: 0.5em 1em;
		border-width: 1px;
		border-color: silver;
		border-color: var(--datacell-border);
		border-top-style: solid;
	}

	table.data thead td:empty {
		padding: 0;
		border: 0;
	}

	table.data  thead,
	table.index thead,
	table.data  tbody,
	table.index tbody {
		border-bottom: 2px solid;
	}

	table.data colgroup,
	table.index colgroup {
		border-left: 2px solid;
	}

	table.data  tbody th:first-child,
	table.index tbody th:first-child  {
		border-right: 2px solid;
		border-top: 1px solid silver;
		border-top: 1px solid var(--datacell-border);
		padding-right: 1em;
	}

	table.data th[colspan],
	table.data td[colspan] {
		text-align: center;
	}

	table.complex.data th,
	table.complex.data td {
		border: 1px solid silver;
		border: 1px solid var(--datacell-border);
		text-align: center;
	}

	table.data.longlastcol td:last-child,
	table.data td.long {
		vertical-align: baseline;
		text-align: left;
	}

	table.data img {
		vertical-align: middle;
	}


/*
Alternate table alignment rules

	table.data,
	table.index {
		text-align: center;
	}

	table.data  thead th[scope="row"],
	table.index thead th[scope="row"] {
		text-align: right;
	}

	table.data  tbody th:first-child,
	table.index tbody th:first-child  {
		text-align: right;
	}

Possible extra rowspan handling

	table.data  tbody th[rowspan]:not([rowspan='1']),
	table.index tbody th[rowspan]:not([rowspan='1']),
	table.data  tbody td[rowspan]:not([rowspan='1']),
	table.index tbody td[rowspan]:not([rowspan='1']) {
		border-left: 1px solid silver;
	}

	table.data  tbody th[rowspan]:first-child,
	table.index tbody th[rowspan]:first-child,
	table.data  tbody td[rowspan]:first-child,
	table.index tbody td[rowspan]:first-child{
		border-left: 0;
		border-right: 1px solid silver;
	}
*/

/******************************************************************************/
/*                                  Indices                                   */
/******************************************************************************/


/** Table of Contents *********************************************************/

	.toc a {
		/* More spacing; use padding to make it part of the click target. */
		padding-top: 0.1rem;
		/* Larger, more consistently-sized click target */
		display: block;
		/* Reverse color scheme */
		color: black;
		color: var(--toclink-text);
		border-color: #3980b5;
		border-color: var(--toclink-underline);
	}
	.toc a:visited {
		color: black;
		color: var(--toclink-visited-text);
		border-color: #054572;
		border-color: var(--toclink-visited-underline);
	}
	.toc a:not(:focus):not(:hover) {
		/* Allow colors to cascade through from link styling */
		border-bottom-color: transparent;
	}

	.toc, .toc ol, .toc ul, .toc li {
		list-style: none; /* Numbers must be inlined into source */
		/* because generated content isn't search/selectable and markers can't do multilevel yet */
		margin:  0;
		padding: 0;
	}
	.toc {
		line-height: 1.1em;
	}

	/* ToC not indented until third level, but font style & margins show hierarchy */
	.toc > li			{ font-weight: bold;   }
	.toc > li li		 { font-weight: normal; }
	.toc > li li li	  { font-size:   95%;	}
	.toc > li li li li	{ font-size:   90%;	}
	.toc > li li li li li { font-size:   85%;	}

	/* @supports not (display:grid) { */
		.toc > li			{ margin: 1.5rem 0;	}
		.toc > li li		 { margin: 0.3rem 0;	}
		.toc > li li li	  { margin-left: 2rem;   }

		/* Section numbers in a column of their own */
		.toc .secno {
			float: left;
			width: 4rem;
			white-space: nowrap;
		}
		.toc > li li li li .secno { font-size: 85%; }
		.toc > li li li li li .secno { font-size: 100%; }

		.toc li {
			clear: both;
		}

		:not(li) > .toc			 { margin-left:  5rem; }
		.toc .secno				 { margin-left: -5rem; }
		.toc > li li li .secno	  { margin-left: -7rem; }
		.toc > li li li li .secno	{ margin-left: -9rem; }
		.toc > li li li li li .secno { margin-left: -11rem; }

		/* Tighten up indentation in narrow ToCs */
		@media (max-width: 30em) {
			:not(li) > .toc			 { margin-left:  4rem; }
			.toc .secno				 { margin-left: -4rem; }
			.toc > li li li			 { margin-left:  1rem; }
			.toc > li li li .secno	  { margin-left: -5rem; }
			.toc > li li li li .secno	{ margin-left: -6rem; }
			.toc > li li li li li .secno { margin-left: -7rem; }
		}
		/* Loosen it on wide screens */
		@media screen and (min-width: 78em) {
			body:not(.toc-inline) :not(li) > .toc			 { margin-left:  4rem; }
			body:not(.toc-inline) .toc .secno				 { margin-left: -4rem; }
			body:not(.toc-inline) .toc > li li li			 { margin-left:  1rem; }
			body:not(.toc-inline) .toc > li li li .secno	  { margin-left: -5rem; }
			body:not(.toc-inline) .toc > li li li li .secno	{ margin-left: -6rem; }
			body:not(.toc-inline) .toc > li li li li li .secno { margin-left: -7rem; }
	}
	/* } */

	@supports (display:grid) and (display:contents) {
		/* Use #toc over .toc to override non-@supports rules. */
		#toc {
			display: grid;
			align-content: start;
			grid-template-columns: auto 1fr;
			grid-column-gap: 1rem;
			column-gap: 1rem;
			grid-row-gap: .6rem;
			row-gap: .6rem;
		}
		#toc h2 {
			grid-column: 1 / -1;
			margin-bottom: 0;
		}
		#toc ol,
		#toc li,
		#toc a {
			display: contents;
			/* Switch <a> to subgrid when supported */
		}
		#toc span {
			margin: 0;
		}
		#toc > .toc > li > a > span {
			/* The spans of the top-level list,
			  comprising the first items of each top-level section. */
			margin-top: 1.1rem;
		}
		#toc#toc .secno { /* Ugh, need more specificity to override base.css */
			grid-column: 1;
			width: auto;
			margin-left: 0;
		}
		#toc .content {
			grid-column: 2;
			width: auto;
			margin-right: 1rem;
		}
		#toc .content:hover,
		#toc .content:focus {
			background: rgba(75%, 75%, 75%, .25);
			background: var(--a-hover-bg);
			border-bottom: 3px solid #054572;
			border-bottom: 3px solid var(--toclink-underline);
			margin-bottom: -3px;
		}
		#toc li li li .content {
			margin-left: 1rem;
		}
		#toc li li li li .content {
			margin-left: 2rem;
		}
	}


/** Index *********************************************************************/

	/* Index Lists: Layout */
	ul.index	  { margin-left: 0; columns: 15em; text-indent: 1em hanging; }
	ul.index li	{ margin-left: 0; list-style: none; break-inside: avoid; }
	ul.index li li { margin-left: 1em; }
	ul.index dl	{ margin-top: 0; }
	ul.index dt	{ margin: .2em 0 .2em 20px;}
	ul.index dd	{ margin: .2em 0 .2em 40px;}
	/* Index Lists: Typography */
	ul.index ul,
	ul.index dl { font-size: smaller; }
	@media not print {
		ul.index li span:not(.dfn-paneled) {
			white-space: nowrap;
			color: transparent; }
		ul.index li a:hover + span,
		ul.index li a:focus + span {
			color: #707070;
			color: var(--indexinfo-text);
		}
	}

/** Index Tables *****************************************************/
	/* See also the data table styling section, which this effectively subclasses */

	table.index {
		font-size: small;
		border-collapse: collapse;
		border-spacing: 0;
		text-align: left;
		margin: 1em 0;
	}

	table.index td,
	table.index th {
		padding: 0.4em;
	}

	table.index tr:hover td:not([rowspan]),
	table.index tr:hover th:not([rowspan]) {
		color: black;
		color: var(--indextable-hover-text);
		background: #f7f8f9;
		background: var(--indextable-hover-bg);
	}

	/* The link in the first column in the property table (formerly a TD) */
	table.index th:first-child a {
		font-weight: bold;
	}

/** Outdated warning **********************************************************/

.outdated-spec {
	color: black;
	color: var(--outdatedspec-text);
	background-color: rgba(0,0,0,0.5);
	background-color: var(--outdatedspec-bg);
}

.outdated-warning {
	position: fixed;
	bottom: 50%;
	left: 0;
	right: 0;
	margin: 0 auto;
	width: 50%;
	background: maroon;
	background: var(--outdated-bg);
	color: white;
	color: var(--outdated-text);
	border-radius: 1em;
	box-shadow: 0 0 1em red;
	box-shadow: 0 0 1em var(--outdated-shadow);
	padding: 2em;
	text-align: center;
	z-index: 2;
}

.outdated-warning a {
	color: currentcolor;
	background: transparent;
}

.edited-rec-warning {
	background: darkorange;
	background: var(--editedrec-bg);
	box-shadow: 0 0 1em;
}

.outdated-warning button {
	color: var(--outdated-text);
	border-radius: 1em;
	box-shadow: 0 0 1em red;
	box-shadow: 0 0 1em var(--outdated-shadow);
	padding: 2em;
	text-align: center;
	z-index: 2;
}

.outdated-warning a {
	color: currentcolor;
	background: transparent;
}

.edited-rec-warning {
	background: darkorange;
	background: var(--editedrec-bg);
	box-shadow: 0 0 1em;
}

.outdated-warning button {
	position: absolute;
	top: 0;
	right:0;
	margin: 0;
	border: 0;
	padding: 0.25em 0.5em;
	background: transparent;
	color: white;
	color: var(--outdated-text);
	font:1em sans-serif;
	text-align:center;
}

.outdated-warning span {
	display: block;
}

.outdated-collapsed {
	bottom: 0;
	border-radius: 0;
	width: 100%;
	padding: 0;
}

/******************************************************************************/
/*                                    Print                                   */
/******************************************************************************/

	@media print {
		/* Pages have their own margins. */
		html {
			margin: 0;
		}
		/* Serif for print. */
		body {
			font-family: serif;
		}

		.outdated-warning {
			position: absolute;
			border-style: solid;
			border-color: red;
		}

		.outdated-warning input {
			display: none;
		}
	}
	@page {
		margin: 1.5cm 1.1cm;
	}



/******************************************************************************/
/*                             Overflow Control                               */
/******************************************************************************/

	.figure .caption, .sidefigure .caption, figcaption {
		/* in case figure is overlarge, limit caption to 50em */
		max-width: 50rem;
		margin-left: auto;
		margin-right: auto;
	}
	.overlarge {
		/* Magic to create good item positioning:
		  "content column" is 50ems wide at max; less on smaller screens.
		  Extra space (after ToC + content) is empty on the right.

		  1. When item < content column, centers item in column.
		  2. When content < item < available, left-aligns.
		  3. When item > available, fills available + scroll bar.
		*/
		display: grid;
		grid-template-columns: minmax(0, 50em);
	}
	.overlarge > table {
		/* limit preferred width of table */
		max-width: 50em;
		margin-left: auto;
		margin-right: auto;
	}

	@media (min-width: 55em) {
		.overlarge {
			margin-right: calc(13px + 26.5rem - 50vw);
			max-width: none;
		}
	}
	@media screen and (min-width: 78em) {
		body:not(.toc-inline) .overlarge {
			/* 30.5em body padding 50em content area */
			margin-right: calc(40em - 50vw) !important;
		}
	}
	@media screen and (min-width: 90em) {
		body:not(.toc-inline) .overlarge {
			/* 4em html margin 30.5em body padding 50em content area */
			margin-right: calc(84.5em - 100vw) !important;
		}
	}

	@media not print {
		.overlarge {
			overflow-x: auto;
			/* See Lea Verou's explanation background-attachment:
			* http://lea.verou.me/2012/04/background-attachment-local/
			*
			background: top left  / 4em 100% linear-gradient(to right,  #ffffff, rgba(255, 255, 255, 0)) local,
						top right / 4em 100% linear-gradient(to left, #ffffff, rgba(255, 255, 255, 0)) local,
						top left  / 1em 100% linear-gradient(to right,  #c3c3c5, rgba(195, 195, 197, 0)) scroll,
						top right / 1em 100% linear-gradient(to left, #c3c3c5, rgba(195, 195, 197, 0)) scroll,
						white;
			background-repeat: no-repeat;
			*/
		}
	}
</style>
<style type="text/css">
    table, th, td {
      border: 1px solid black;
      border-collapse: collapse;
      vertical-align: top;
    }
    th, td {
      border-left: none;
      border-right: none;
      padding: 0px 10px;
    }
    th {
      text-align: center;
    }

    del { background: #fcc; color: #000; text-decoration: line-through; }
    ins { background: #cfc; color: #000; }
    blockquote .highlight:not(.idl) { background: initial; margin: initial; padding: 0.5em }
    blockquote ul { background: inherit; }
    blockquote code.highlight:not(.idl) { padding: initial; }
    blockquote c-[a] { color: inherit; } /* Keyword.Declaration */
    blockquote c-[b] { color: inherit; } /* Keyword.Type */
    blockquote c-[c] { color: inherit; } /* Comment */
    blockquote c-[d] { color: inherit; } /* Comment.Multiline */
    blockquote c-[e] { color: inherit; } /* Name.Attribute */
    blockquote c-[f] { color: inherit; } /* Name.Tag */
    blockquote c-[g] { color: inherit; } /* Name.Variable */
    blockquote c-[k] { color: inherit; } /* Keyword */
    blockquote c-[l] { color: inherit; } /* Literal */
    blockquote c-[m] { color: inherit; } /* Literal.Number */
    blockquote c-[n] { color: inherit; } /* Name */
    blockquote c-[o] { color: inherit; } /* Operator */
    blockquote c-[p] { color: inherit; } /* Punctuation */
    blockquote c-[s] { color: inherit; } /* Literal.String */
    blockquote c-[t] { color: inherit; } /* Literal.String.Single */
    blockquote c-[u] { color: inherit; } /* Literal.String.Double */
    blockquote c-[cp] { color: inherit; } /* Comment.Preproc */
    blockquote c-[c1] { color: inherit; } /* Comment.Single */
    blockquote c-[cs] { color: inherit; } /* Comment.Special */
    blockquote c-[kc] { color: inherit; } /* Keyword.Constant */
    blockquote c-[kn] { color: inherit; } /* Keyword.Namespace */
    blockquote c-[kp] { color: inherit; } /* Keyword.Pseudo */
    blockquote c-[kr] { color: inherit; } /* Keyword.Reserved */
    blockquote c-[ld] { color: inherit; } /* Literal.Date */
    blockquote c-[nc] { color: inherit; } /* Name.Class */
    blockquote c-[no] { color: inherit; } /* Name.Constant */
    blockquote c-[nd] { color: inherit; } /* Name.Decorator */
    blockquote c-[ni] { color: inherit; } /* Name.Entity */
    blockquote c-[ne] { color: inherit; } /* Name.Exception */
    blockquote c-[nf] { color: inherit; } /* Name.Function */
    blockquote c-[nl] { color: inherit; } /* Name.Label */
    blockquote c-[nn] { color: inherit; } /* Name.Namespace */
    blockquote c-[py] { color: inherit; } /* Name.Property */
    blockquote c-[ow] { color: inherit; } /* Operator.Word */
    blockquote c-[mb] { color: inherit; } /* Literal.Number.Bin */
    blockquote c-[mf] { color: inherit; } /* Literal.Number.Float */
    blockquote c-[mh] { color: inherit; } /* Literal.Number.Hex */
    blockquote c-[mi] { color: inherit; } /* Literal.Number.Integer */
    blockquote c-[mo] { color: inherit; } /* Literal.Number.Oct */
    blockquote c-[sb] { color: inherit; } /* Literal.String.Backtick */
    blockquote c-[sc] { color: inherit; } /* Literal.String.Char */
    blockquote c-[sd] { color: inherit; } /* Literal.String.Doc */
    blockquote c-[se] { color: inherit; } /* Literal.String.Escape */
    blockquote c-[sh] { color: inherit; } /* Literal.String.Heredoc */
    blockquote c-[si] { color: inherit; } /* Literal.String.Interpol */
    blockquote c-[sx] { color: inherit; } /* Literal.String.Other */
    blockquote c-[sr] { color: inherit; } /* Literal.String.Regex */
    blockquote c-[ss] { color: inherit; } /* Literal.String.Symbol */
    blockquote c-[vc] { color: inherit; } /* Name.Variable.Class */
    blockquote c-[vg] { color: inherit; } /* Name.Variable.Global */
    blockquote c-[vi] { color: inherit; } /* Name.Variable.Instance */
    blockquote c-[il] { color: inherit; } /* Literal.Number.Integer.Long */
  </style>
  <meta content="Bikeshed version 4e8dd937, updated Fri Nov 13 16:49:31 2020 -0800" name="generator">
  <link href="https://wg21.link/P2268R0" rel="canonical">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
<style>/* style-autolinks */

.css.css, .property.property, .descriptor.descriptor {
    color: var(--a-normal-text);
    font-size: inherit;
    font-family: inherit;
}
.css::before, .property::before, .descriptor::before {
    content: "‘";
}
.css::after, .property::after, .descriptor::after {
    content: "’";
}
.property, .descriptor {
    /* Don't wrap property and descriptor names */
    white-space: nowrap;
}
.type { /* CSS value <type> */
    font-style: italic;
}
pre .property::before, pre .property::after {
    content: "";
}
[data-link-type="property"]::before,
[data-link-type="propdesc"]::before,
[data-link-type="descriptor"]::before,
[data-link-type="value"]::before,
[data-link-type="function"]::before,
[data-link-type="at-rule"]::before,
[data-link-type="selector"]::before,
[data-link-type="maybe"]::before {
    content: "‘";
}
[data-link-type="property"]::after,
[data-link-type="propdesc"]::after,
[data-link-type="descriptor"]::after,
[data-link-type="value"]::after,
[data-link-type="function"]::after,
[data-link-type="at-rule"]::after,
[data-link-type="selector"]::after,
[data-link-type="maybe"]::after {
    content: "’";
}

[data-link-type].production::before,
[data-link-type].production::after,
.prod [data-link-type]::before,
.prod [data-link-type]::after {
    content: "";
}

[data-link-type=element],
[data-link-type=element-attr] {
    font-family: Menlo, Consolas, "DejaVu Sans Mono", monospace;
    font-size: .9em;
}
[data-link-type=element]::before { content: "<" }
[data-link-type=element]::after  { content: ">" }

[data-link-type=biblio] {
    white-space: pre;
}</style>
<style>/* style-colors */

/* Any --*-text not paired with a --*-bg is assumed to have a transparent bg */
:root {
    color-scheme: light dark;

    --text: black;
    --bg: white;

    --unofficial-watermark: url(https://www.w3.org/StyleSheets/TR/2016/logos/UD-watermark);

    --logo-bg: #1a5e9a;
    --logo-active-bg: #c00;
    --logo-text: white;

    --tocnav-normal-text: #707070;
    --tocnav-normal-bg: var(--bg);
    --tocnav-hover-text: var(--tocnav-normal-text);
    --tocnav-hover-bg: #f8f8f8;
    --tocnav-active-text: #c00;
    --tocnav-active-bg: var(--tocnav-normal-bg);

    --tocsidebar-text: var(--text);
    --tocsidebar-bg: #f7f8f9;
    --tocsidebar-shadow: rgba(0,0,0,.1);
    --tocsidebar-heading-text: hsla(203,20%,40%,.7);

    --toclink-text: var(--text);
    --toclink-underline: #3980b5;
    --toclink-visited-text: var(--toclink-text);
    --toclink-visited-underline: #054572;

    --heading-text: #005a9c;

    --hr-text: var(--text);

    --algo-border: #def;

    --del-text: red;
    --del-bg: transparent;
    --ins-text: #080;
    --ins-bg: transparent;

    --a-normal-text: #034575;
    --a-normal-underline: #707070;
    --a-visited-text: var(--a-normal-text);
    --a-visited-underline: #bbb;
    --a-hover-bg: rgba(75%, 75%, 75%, .25);
    --a-active-text: #c00;
    --a-active-underline: #c00;

    --blockquote-border: silver;
    --blockquote-bg: transparent;
    --blockquote-text: currentcolor;

    --issue-border: #e05252;
    --issue-bg: #fbe9e9;
    --issue-text: var(--text);
    --issueheading-text: #831616;

    --example-border: #e0cb52;
    --example-bg: #fcfaee;
    --example-text: var(--text);
    --exampleheading-text: #574b0f;

    --note-border: #52e052;
    --note-bg: #e9fbe9;
    --note-text: var(--text);
    --noteheading-text: hsl(120, 70%, 30%);
    --notesummary-underline: silver;

    --assertion-border: #aaa;
    --assertion-bg: #eee;
    --assertion-text: black;

    --advisement-border: orange;
    --advisement-bg: #fec;
    --advisement-text: var(--text);
    --advisementheading-text: #b35f00;

    --warning-border: red;
    --warning-bg: hsla(40,100%,50%,0.95);
    --warning-text: var(--text);

    --amendment-border: #330099;
    --amendment-bg: #F5F0FF;
    --amendment-text: var(--text);
    --amendmentheading-text: #220066;

    --def-border: #8ccbf2;
    --def-bg: #def;
    --def-text: var(--text);
    --defrow-border: #bbd7e9;

    --datacell-border: silver;

    --indexinfo-text: #707070;

    --indextable-hover-text: black;
    --indextable-hover-bg: #f7f8f9;

    --outdatedspec-bg: rgba(0, 0, 0, .5);
    --outdatedspec-text: black;
    --outdated-bg: maroon;
    --outdated-text: white;
    --outdated-shadow: red;

    --editedrec-bg: darkorange;
}</style>
<style>/* style-counters */

body {
    counter-reset: example figure issue;
}
.issue {
    counter-increment: issue;
}
.issue:not(.no-marker)::before {
    content: "Issue " counter(issue);
}

.example {
    counter-increment: example;
}
.example:not(.no-marker)::before {
    content: "Example " counter(example);
}
.invalid.example:not(.no-marker)::before,
.illegal.example:not(.no-marker)::before {
    content: "Invalid Example" counter(example);
}

figcaption {
    counter-increment: figure;
}
figcaption:not(.no-marker)::before {
    content: "Figure " counter(figure) " ";
}</style>
<style>/* style-md-lists */

/* This is a weird hack for me not yet following the commonmark spec
   regarding paragraph and lists. */
[data-md] > :first-child {
    margin-top: 0;
}
[data-md] > :last-child {
    margin-bottom: 0;
}</style>
<style>/* style-selflinks */

:root {
    --selflink-text: white;
    --selflink-bg: gray;
    --selflink-hover-text: black;
}
.heading, .issue, .note, .example, li, dt {
    position: relative;
}
a.self-link {
    position: absolute;
    top: 0;
    left: calc(-1 * (3.5rem - 26px));
    width: calc(3.5rem - 26px);
    height: 2em;
    text-align: center;
    border: none;
    transition: opacity .2s;
    opacity: .5;
}
a.self-link:hover {
    opacity: 1;
}
.heading > a.self-link {
    font-size: 83%;
}
li > a.self-link {
    left: calc(-1 * (3.5rem - 26px) - 2em);
}
dfn > a.self-link {
    top: auto;
    left: auto;
    opacity: 0;
    width: 1.5em;
    height: 1.5em;
    background: var(--selflink-bg);
    color: var(--selflink-text);
    font-style: normal;
    transition: opacity .2s, background-color .2s, color .2s;
}
dfn:hover > a.self-link {
    opacity: 1;
}
dfn > a.self-link:hover {
    color: var(--selflink-hover-text);
}

a.self-link::before            { content: "¶"; }
.heading > a.self-link::before { content: "§"; }
dfn > a.self-link::before      { content: "#"; }
</style>
<style>/* style-syntax-highlighting */

code.highlight { padding: .1em; border-radius: .3em; }
pre.highlight, pre > code.highlight { display: block; padding: 1em; margin: .5em 0; overflow: auto; border-radius: 0; }

.highlight:not(.idl) { background: rgba(0, 0, 0, .03); }
c-[a] { color: #990055 } /* Keyword.Declaration */
c-[b] { color: #990055 } /* Keyword.Type */
c-[c] { color: #708090 } /* Comment */
c-[d] { color: #708090 } /* Comment.Multiline */
c-[e] { color: #0077aa } /* Name.Attribute */
c-[f] { color: #669900 } /* Name.Tag */
c-[g] { color: #222222 } /* Name.Variable */
c-[k] { color: #990055 } /* Keyword */
c-[l] { color: #000000 } /* Literal */
c-[m] { color: #000000 } /* Literal.Number */
c-[n] { color: #0077aa } /* Name */
c-[o] { color: #999999 } /* Operator */
c-[p] { color: #999999 } /* Punctuation */
c-[s] { color: #a67f59 } /* Literal.String */
c-[t] { color: #a67f59 } /* Literal.String.Single */
c-[u] { color: #a67f59 } /* Literal.String.Double */
c-[cp] { color: #708090 } /* Comment.Preproc */
c-[c1] { color: #708090 } /* Comment.Single */
c-[cs] { color: #708090 } /* Comment.Special */
c-[kc] { color: #990055 } /* Keyword.Constant */
c-[kn] { color: #990055 } /* Keyword.Namespace */
c-[kp] { color: #990055 } /* Keyword.Pseudo */
c-[kr] { color: #990055 } /* Keyword.Reserved */
c-[ld] { color: #000000 } /* Literal.Date */
c-[nc] { color: #0077aa } /* Name.Class */
c-[no] { color: #0077aa } /* Name.Constant */
c-[nd] { color: #0077aa } /* Name.Decorator */
c-[ni] { color: #0077aa } /* Name.Entity */
c-[ne] { color: #0077aa } /* Name.Exception */
c-[nf] { color: #0077aa } /* Name.Function */
c-[nl] { color: #0077aa } /* Name.Label */
c-[nn] { color: #0077aa } /* Name.Namespace */
c-[py] { color: #0077aa } /* Name.Property */
c-[ow] { color: #999999 } /* Operator.Word */
c-[mb] { color: #000000 } /* Literal.Number.Bin */
c-[mf] { color: #000000 } /* Literal.Number.Float */
c-[mh] { color: #000000 } /* Literal.Number.Hex */
c-[mi] { color: #000000 } /* Literal.Number.Integer */
c-[mo] { color: #000000 } /* Literal.Number.Oct */
c-[sb] { color: #a67f59 } /* Literal.String.Backtick */
c-[sc] { color: #a67f59 } /* Literal.String.Char */
c-[sd] { color: #a67f59 } /* Literal.String.Doc */
c-[se] { color: #a67f59 } /* Literal.String.Escape */
c-[sh] { color: #a67f59 } /* Literal.String.Heredoc */
c-[si] { color: #a67f59 } /* Literal.String.Interpol */
c-[sx] { color: #a67f59 } /* Literal.String.Other */
c-[sr] { color: #a67f59 } /* Literal.String.Regex */
c-[ss] { color: #a67f59 } /* Literal.String.Symbol */
c-[vc] { color: #0077aa } /* Name.Variable.Class */
c-[vg] { color: #0077aa } /* Name.Variable.Global */
c-[vi] { color: #0077aa } /* Name.Variable.Instance */
c-[il] { color: #000000 } /* Literal.Number.Integer.Long */
</style>
<style>/* style-darkmode */

@media (prefers-color-scheme: dark) {
    :root {
        --text: #ddd;
        --bg: black;

        --unofficial-watermark: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='400' height='400'%3E%3Cg fill='%23100808' transform='translate(200 200) rotate(-45) translate(-200 -200)' stroke='%23100808' stroke-width='3'%3E%3Ctext x='50%25' y='220' style='font: bold 70px sans-serif; text-anchor: middle; letter-spacing: 6px;'%3EUNOFFICIAL%3C/text%3E%3Ctext x='50%25' y='305' style='font: bold 70px sans-serif; text-anchor: middle; letter-spacing: 6px;'%3EDRAFT%3C/text%3E%3C/g%3E%3C/svg%3E");

        --logo-bg: #1a5e9a;
        --logo-active-bg: #c00;
        --logo-text: white;

        --tocnav-normal-text: #999;
        --tocnav-normal-bg: var(--bg);
        --tocnav-hover-text: var(--tocnav-normal-text);
        --tocnav-hover-bg: #080808;
        --tocnav-active-text: #f44;
        --tocnav-active-bg: var(--tocnav-normal-bg);

        --tocsidebar-text: var(--text);
        --tocsidebar-bg: #080808;
        --tocsidebar-shadow: rgba(255,255,255,.1);
        --tocsidebar-heading-text: hsla(203,20%,40%,.7);

        --toclink-text: var(--text);
        --toclink-underline: #6af;
        --toclink-visited-text: var(--toclink-text);
        --toclink-visited-underline: #054572;

        --heading-text: #8af;

        --hr-text: var(--text);

        --algo-border: #456;

        --del-text: #f44;
        --del-bg: transparent;
        --ins-text: #4a4;
        --ins-bg: transparent;

        --a-normal-text: #6af;
        --a-normal-underline: #555;
        --a-visited-text: var(--a-normal-text);
        --a-visited-underline: var(--a-normal-underline);
        --a-hover-bg: rgba(25%, 25%, 25%, .2);
        --a-active-text: #f44;
        --a-active-underline: var(--a-active-text);

        --borderedblock-bg: rgba(255, 255, 255, .05);

        --blockquote-border: silver;
        --blockquote-bg: var(--borderedblock-bg);
        --blockquote-text: currentcolor;

        --issue-border: #e05252;
        --issue-bg: var(--borderedblock-bg);
        --issue-text: var(--text);
        --issueheading-text: hsl(0deg, 70%, 70%);

        --example-border: hsl(50deg, 90%, 60%);
        --example-bg: var(--borderedblock-bg);
        --example-text: var(--text);
        --exampleheading-text: hsl(50deg, 70%, 70%);

        --note-border: hsl(120deg, 100%, 35%);
        --note-bg: var(--borderedblock-bg);
        --note-text: var(--text);
        --noteheading-text: hsl(120, 70%, 70%);
        --notesummary-underline: silver;

        --assertion-border: #444;
        --assertion-bg: var(--borderedblock-bg);
        --assertion-text: var(--text);

        --advisement-border: orange;
        --advisement-bg: #222218;
        --advisement-text: var(--text);
        --advisementheading-text: #f84;

        --warning-border: red;
        --warning-bg: hsla(40,100%,20%,0.95);
        --warning-text: var(--text);

        --amendment-border: #330099;
        --amendment-bg: #080010;
        --amendment-text: var(--text);
        --amendmentheading-text: #cc00ff;

        --def-border: #8ccbf2;
        --def-bg: #080818;
        --def-text: var(--text);
        --defrow-border: #136;

        --datacell-border: silver;

        --indexinfo-text: #aaa;

        --indextable-hover-text: var(--text);
        --indextable-hover-bg: #181818;

        --outdatedspec-bg: rgba(255, 255, 255, .5);
        --outdatedspec-text: black;
        --outdated-bg: maroon;
        --outdated-text: white;
        --outdated-shadow: red;

        --editedrec-bg: darkorange;
    }
    /* In case a transparent-bg image doesn't expect to be on a dark bg,
       which is quite common in practice... */
    img { background: white; }
}
@media (prefers-color-scheme: dark) {
    :root {
        --selflink-text: black;
        --selflink-bg: silver;
        --selflink-hover-text: white;
    }
}

@media (prefers-color-scheme: dark) {
    .highlight:not(.idl) { background: rgba(255, 255, 255, .05); }

    c-[a] { color: #d33682 } /* Keyword.Declaration */
    c-[b] { color: #d33682 } /* Keyword.Type */
    c-[c] { color: #2aa198 } /* Comment */
    c-[d] { color: #2aa198 } /* Comment.Multiline */
    c-[e] { color: #268bd2 } /* Name.Attribute */
    c-[f] { color: #b58900 } /* Name.Tag */
    c-[g] { color: #cb4b16 } /* Name.Variable */
    c-[k] { color: #d33682 } /* Keyword */
    c-[l] { color: #657b83 } /* Literal */
    c-[m] { color: #657b83 } /* Literal.Number */
    c-[n] { color: #268bd2 } /* Name */
    c-[o] { color: #657b83 } /* Operator */
    c-[p] { color: #657b83 } /* Punctuation */
    c-[s] { color: #6c71c4 } /* Literal.String */
    c-[t] { color: #6c71c4 } /* Literal.String.Single */
    c-[u] { color: #6c71c4 } /* Literal.String.Double */
    c-[ch] { color: #2aa198 } /* Comment.Hashbang */
    c-[cp] { color: #2aa198 } /* Comment.Preproc */
    c-[cpf] { color: #2aa198 } /* Comment.PreprocFile */
    c-[c1] { color: #2aa198 } /* Comment.Single */
    c-[cs] { color: #2aa198 } /* Comment.Special */
    c-[kc] { color: #d33682 } /* Keyword.Constant */
    c-[kn] { color: #d33682 } /* Keyword.Namespace */
    c-[kp] { color: #d33682 } /* Keyword.Pseudo */
    c-[kr] { color: #d33682 } /* Keyword.Reserved */
    c-[ld] { color: #657b83 } /* Literal.Date */
    c-[nc] { color: #268bd2 } /* Name.Class */
    c-[no] { color: #268bd2 } /* Name.Constant */
    c-[nd] { color: #268bd2 } /* Name.Decorator */
    c-[ni] { color: #268bd2 } /* Name.Entity */
    c-[ne] { color: #268bd2 } /* Name.Exception */
    c-[nf] { color: #268bd2 } /* Name.Function */
    c-[nl] { color: #268bd2 } /* Name.Label */
    c-[nn] { color: #268bd2 } /* Name.Namespace */
    c-[py] { color: #268bd2 } /* Name.Property */
    c-[ow] { color: #657b83 } /* Operator.Word */
    c-[mb] { color: #657b83 } /* Literal.Number.Bin */
    c-[mf] { color: #657b83 } /* Literal.Number.Float */
    c-[mh] { color: #657b83 } /* Literal.Number.Hex */
    c-[mi] { color: #657b83 } /* Literal.Number.Integer */
    c-[mo] { color: #657b83 } /* Literal.Number.Oct */
    c-[sa] { color: #6c71c4 } /* Literal.String.Affix */
    c-[sb] { color: #6c71c4 } /* Literal.String.Backtick */
    c-[sc] { color: #6c71c4 } /* Literal.String.Char */
    c-[dl] { color: #6c71c4 } /* Literal.String.Delimiter */
    c-[sd] { color: #6c71c4 } /* Literal.String.Doc */
    c-[se] { color: #6c71c4 } /* Literal.String.Escape */
    c-[sh] { color: #6c71c4 } /* Literal.String.Heredoc */
    c-[si] { color: #6c71c4 } /* Literal.String.Interpol */
    c-[sx] { color: #6c71c4 } /* Literal.String.Other */
    c-[sr] { color: #6c71c4 } /* Literal.String.Regex */
    c-[ss] { color: #6c71c4 } /* Literal.String.Symbol */
    c-[fm] { color: #268bd2 } /* Name.Function.Magic */
    c-[vc] { color: #cb4b16 } /* Name.Variable.Class */
    c-[vg] { color: #cb4b16 } /* Name.Variable.Global */
    c-[vi] { color: #cb4b16 } /* Name.Variable.Instance */
    c-[vm] { color: #cb4b16 } /* Name.Variable.Magic */
    c-[il] { color: #657b83 } /* Literal.Number.Integer.Long */
}
</style>
 </head><body class="h-entry toc-sidebar"><p id="toc-nav"><a id="toc-jump" href="#toc"><span aria-hidden="true">↑</span> <span>Jump to Table of Contents</span></a><a id="toc-toggle" href="#toc"><span aria-hidden="true">←</span> <span>Collapse Sidebar</span></a></p>
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">P2268R0<br>Freestanding Roadmap</h1>
   <h2 class="no-num no-toc no-ref heading settled" id="subtitle"><span class="content">Published Proposal, <time class="dt-updated" datetime="2020-12-10">2020-12-10</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     </dt><dd><a class="u-url" href="https://wg21.link/P2268R0">https://wg21.link/P2268R0</a>
     </dd><dt class="editor">Author:
     </dt><dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:ben.craig@gmail.com">Ben Craig</a> (<span class="p-org org">NI</span>)
     </dd><dt>Audience:
     </dt><dd>SG14
     </dd><dt>Project:
     </dt><dd>ISO/IEC JTC1/SC22/WG21 14882: Programming Language — C++
     </dd><dt>Source:
     </dt><dd><a href="https://github.com/ben-craig/freestanding_proposal/blob/master/roadmap.bs">github.com/ben-craig/freestanding_proposal/blob/master/roadmap.bs</a>
    </dd></dl>
   </div>
   <div data-fill-with="warning"></div>
   <hr title="Separator for header">
  </div>
  <div class="p-summary" data-fill-with="abstract">
   <h2 class="no-num no-toc no-ref heading settled" id="abstract"><span class="content">Abstract</span></h2>
   <p>Describe future, high level freestanding papers</p>
  </div>
  <nav data-fill-with="table-of-contents" id="toc">
   <h2 class="no-num no-toc no-ref" id="contents">Table of Contents</h2>
   <ol class="toc" role="directory">
    <li><a href="#intro"><span class="secno">1</span> <span class="content">Introduction</span></a>
    </li><li>
     <a href="#p0829_pieces"><span class="secno">2</span> <span class="content"><span>[P0829]</span> pieces</span></a>
     <ol class="toc">
      <li><a href="#c_and_float_facilities"><span class="secno">2.1</span> <span class="content"><code class="highlight"><c- o="">&lt;</c-><c- n="">cstdlib</c-><c- o="">&gt;</c-></code>, <code class="highlight"><c- o="">&lt;</c-><c- n="">charconv</c-><c- o="">&gt;</c-></code>, <code class="highlight"><c- o="">&lt;</c-><c- n="">cmath</c-><c- o="">&gt;</c-></code>, <code class="highlight"><c- o="">&lt;</c-><c- n="">cinttypes</c-><c- o="">&gt;</c-></code>, <code class="highlight"><c- o="">&lt;</c-><c- n="">cstring</c-><c- o="">&gt;</c-></code>, <code class="highlight"><c- o="">&lt;</c-><c- n="">cwchar</c-><c- o="">&gt;</c-></code>, and <code class="highlight"><c- n="">char_traits</c-></code></span></a>
      </li><li><a href="#algorithms_and_friends"><span class="secno">2.2</span> <span class="content"><span>[diagnostics]</span>, <code class="highlight"><c- o="">&lt;</c-><c- n="">algorithm</c-><c- o="">&gt;</c-></code>, <code class="highlight"><c- o="">&lt;</c-><c- n="">numeric</c-><c- o="">&gt;</c-></code>, <code class="highlight"><c- n="">lock_guard</c-></code>, <code class="highlight"><c- n="">unique_lock</c-></code>, <code class="highlight"><c- o="">&lt;</c-><c- n="">span</c-><c- o="">&gt;</c-></code></span></a>
      </li><li><a href="#partial_classes"><span class="secno">2.3</span> <span class="content">Partial classes</span></a>
      </li><li><a href="#random_header"><span class="secno">2.4</span> <span class="content"><code class="highlight"><c- o="">&lt;</c-><c- n="">random</c-><c- o="">&gt;</c-></code></span></a>
      </li><li><a href="#chrono_header"><span class="secno">2.5</span> <span class="content"><code class="highlight"><c- o="">&lt;</c-><c- n="">chrono</c-><c- o="">&gt;</c-></code> / <span>[time]</span></span></a>
     </li></ol>
    </li><li>
     <a href="#beyond_p0829"><span class="secno">3</span> <span class="content">Beyond <span>[P0829]</span></span></a>
     <ol class="toc">
      <li><a href="#constexpr_to_consteval"><span class="secno">3.1</span> <span class="content"><code class="highlight"><c- k="">constexpr</c-></code> as <code class="highlight"><c- k="">consteval</c-></code></span></a>
      </li><li>
       <a href="#startup_termintation"><span class="secno">3.2</span> <span class="content">Startup and termination control</span></a>
       <ol class="toc">
        <li><a href="#replaceable_terminate"><span class="secno">3.2.1</span> <span class="content">Replaceable <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">terminate</c-></code> {#replaceable_terminate}</span></a>
        </li><li><a href="#link_time_arrays"><span class="secno">3.2.2</span> <span class="content">Link-time arrays {#link_time_arrays}</span></a>
        </li><li><a href="#expose_global_ctors"><span class="secno">3.2.3</span> <span class="content">Exposing existing global constructor link-time arrays {#expose_global_ctors}</span></a>
        </li><li><a href="#thread_local_customization"><span class="secno">3.2.4</span> <span class="content"><code class="highlight"><c- k="">thread_local</c-></code> customization points {#thread_local_customization}</span></a>
       </li></ol>
      </li><li>
       <a href="#error_handling"><span class="secno">3.3</span> <span class="content">Error handling</span></a>
       <ol class="toc">
        <li><a href="#dtor_call_reason"><span class="secno">3.3.1</span> <span class="content">Destructor call reason {#dtor_call_reason}</span></a>
        </li><li><a href="#non_local_exception"><span class="secno">3.3.2</span> <span class="content">Non-local exception objects {#non_local_exception}</span></a>
        </li><li><a href="#noexcept_blocks"><span class="secno">3.3.3</span> <span class="content"><code class="highlight"><c- k="">noexcept</c-></code> blocks {#noexcept_blocks}</span></a>
        </li><li><a href="#trim_exception_header"><span class="secno">3.3.4</span> <span class="content">Trim exception header {#trim_exception_header}</span></a>
       </li></ol>
      </li><li>
       <a href="#hard"><span class="secno">3.4</span> <span class="content">No known path forward</span></a>
       <ol class="toc">
        <li><a href="#locked_atomics"><span class="secno">3.4.1</span> <span class="content">Locked atomics {#locked_atomics}</span></a>
        </li><li><a href="#thread_safe_statics"><span class="secno">3.4.2</span> <span class="content">Thread-safe statics {#thread_safe_statics}</span></a>
        </li><li><a href="#rtti"><span class="secno">3.4.3</span> <span class="content">RTTI {#rtti}</span></a>
        </li><li><a href="#floating_point"><span class="secno">3.4.4</span> <span class="content">Floating point {#floating_point}</span></a>
       </li></ol>
     </li></ol>
    </li><li>
     <a href="#wip"><span class="secno">4</span> <span class="content">Work in progress</span></a>
     <ol class="toc">
      <li><a href="#p2013"><span class="secno">4.1</span> <span class="content"><span>[P2013]</span> Freestanding Language: Optional <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code></span></a>
      </li><li><a href="#P1642"><span class="secno">4.2</span> <span class="content"><span>[P1642]</span> Freestanding Library: Easy [utilities], [ranges], and [iterators]</span></a>
      </li><li><a href="#P2198"><span class="secno">4.3</span> <span class="content"><span>[P2198]</span> Freestanding Feature-Test Macros and Implementation-Defined Extensions</span></a>
     </li></ol>
    </li><li>
     <a href="#related_wip"><span class="secno">5</span> <span class="content">Related work in progress</span></a>
     <ol class="toc">
      <li><a href="#related_stl_modules"><span class="secno">5.1</span> <span class="content"><span>[P0581]</span> Standard Library Modules</span></a>
      </li><li><a href="#related_expected"><span class="secno">5.2</span> <span class="content"><span>[P0323]</span> <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">expected</c-></code></span></a>
      </li><li><a href="#related_renwick"><span class="secno">5.3</span> <span class="content"><span>Renwick exceptions</span></span></a>
      </li><li><a href="#related_p0709"><span class="secno">5.4</span> <span class="content"><span>[P0709]</span> Zero-overhead deterministic exceptions: Throwing values</span></a>
     </li></ol>
    </li><li><a href="#papers_and_issues"><span class="secno">6</span> <span class="content">Applied papers and issues</span></a>
    </li><li>
     <a href="#retired"><span class="secno">7</span> <span class="content">Retired papers</span></a>
     <ol class="toc">
      <li><a href="#retired_p0829"><span class="secno">7.1</span> <span class="content"><span>[P0829]</span> Freestanding Proposal</span></a>
      </li><li><a href="#retired_p1641"><span class="secno">7.2</span> <span class="content"><span>[P1641]</span> Freestanding Library: Rewording the Status Quo</span></a>
      </li><li><a href="#retired_p1105"><span class="secno">7.3</span> <span class="content"><span>[P1105]</span> Leaving no room for a lower-level language: A C++ Subset</span></a>
      </li><li><a href="#retired_p1212"><span class="secno">7.4</span> <span class="content"><span>[P1212]</span> Modules and freestanding</span></a>
      </li><li><a href="#retired_p1372"><span class="secno">7.5</span> <span class="content"><span>[P1372]</span> Giving atomic_ref implementers more flexibility by providing customization points for non-lock-free implementation</span></a>
     </li></ol>
    </li><li><a href="#ack"><span class="secno">8</span> <span class="content">Acknowledgments</span></a>
    </li><li>
     <a href="#references"><span class="secno"></span> <span class="content">References</span></a>
     <ol class="toc">
      <li><a href="#informative"><span class="secno"></span> <span class="content">Informative References</span></a>
     </li></ol>
   </li></ol>
  </nav>
  <main>
   <h2 class="heading settled" data-level="1" id="intro"><span class="secno">1. </span><span class="content">Introduction</span><a class="self-link" href="#intro"></a></h2>
    "Fixing" freestanding is too large of a task for one person.
This paper is describing the technical directions that could be taken to
 make conforming freestanding C++ a useful and widely implemented 
language.
The author does not have the time or resources to perform the due 
diligence testing and implementation for all of these facilities.
This paper is largely a request for collaborators on freestanding 
related facilities.
Please contact ben.craig@gmail.com if you are interested in creating 
prototype implementations and coauthoring papers on these topics. 
   <h2 class="heading settled" data-level="2" id="p0829_pieces"><span class="secno">2. </span><span class="content"><a data-link-type="biblio" href="#biblio-p0829">[P0829]</a> pieces</span><a class="self-link" href="#p0829_pieces"></a></h2>
    The following sections are all smaller pieces of the retired <a data-link-type="biblio" href="#biblio-p0829">[P0829]</a>.
They are listed in roughly priority order.
All of these pieces have some amount of freestanding implementation experience. 
   <h3 class="heading settled" data-level="2.1" id="c_and_float_facilities"><span class="secno">2.1. </span><span class="content"><code class="highlight"><c- o="">&lt;</c-><c- n="">cstdlib</c-><c- o="">&gt;</c-></code>, <code class="highlight"><c- o="">&lt;</c-><c- n="">charconv</c-><c- o="">&gt;</c-></code>, <code class="highlight"><c- o="">&lt;</c-><c- n="">cmath</c-><c- o="">&gt;</c-></code>, <code class="highlight"><c- o="">&lt;</c-><c- n="">cinttypes</c-><c- o="">&gt;</c-></code>, <code class="highlight"><c- o="">&lt;</c-><c- n="">cstring</c-><c- o="">&gt;</c-></code>, <code class="highlight"><c- o="">&lt;</c-><c- n="">cwchar</c-><c- o="">&gt;</c-></code>, and <code class="highlight"><c- n="">char_traits</c-></code></span><a class="self-link" href="#c_and_float_facilities"></a></h3>
    Adding the relevant parts of the above facilities to freestanding requires answering a few questions. 
   <ul>
    <li data-md="">
     <p>What do we want to do with floating point in the freestanding library?</p>
    </li><li data-md="">
     <p>What do we want to do with parts of the C library that could be made freestanding, but aren’t freestanding in C?</p>
   </li></ul>
   <p>My recommendation will be that we <code class="highlight"><c- o="">=</c-><c- k="">delete</c-></code>
 floating point overloads.
This way, freestanding implementations with core language floating point
 support won’t have differing runtime library behavior on hosted and 
freestanding implementations.
If the floating point overloads were omitted, then a <code class="highlight"><c- b="">float</c-></code> argument would resolve to an integer overload in freestanding, and a floating point overload in hosted implementations. <code class="highlight"><c- o="">&lt;</c-><c- n="">charconv</c-><c- o="">&gt;</c-></code>
 floating point overloads are particularly challenging, as modern 
implementations of these facilities involve enormous lookup tables that 
would prove problematic on space constrained implementations.</p>
   <p>The other major alternative is to keep floating point operations 
in freestanding implementations.
This would be the "wrong" behavior for kernel users, as floating point 
usage on many platforms (32-bit x86 Windows, most Linux platforms) will 
corrupt the floating point state in user mode code.</p>
   <p>Adding C functions to C++ freestanding has precedent, notably with <code class="highlight"><c- n="">abort</c-></code>, <code class="highlight"><c- n="">atexit</c-></code>, <code class="highlight"><c- n="">at_quick_exit</c-></code>, <code class="highlight"><c- n="">exit</c-></code>, and <code class="highlight"><c- n="">quick_exit</c-></code>.
This is an issue to bring to the newly formed C/C++ liason study group. <code class="highlight"><c- o="">&lt;</c-><c- n="">cwchar</c-><c- o="">&gt;</c-></code>
 may end up being a casualty to consensus here, as even though it would 
be a useful facility that fundamentally makes sense in freestanding, it 
is a costly to port facility (because of assembly) that is rarely used.</p>
   <h3 class="heading settled" data-level="2.2" id="algorithms_and_friends"><span class="secno">2.2. </span><span class="content"><a href="https://wg21.link/diagnostics">[diagnostics]</a>, <code class="highlight"><c- o="">&lt;</c-><c- n="">algorithm</c-><c- o="">&gt;</c-></code>, <code class="highlight"><c- o="">&lt;</c-><c- n="">numeric</c-><c- o="">&gt;</c-></code>, <code class="highlight"><c- n="">lock_guard</c-></code>, <code class="highlight"><c- n="">unique_lock</c-></code>, <code class="highlight"><c- o="">&lt;</c-><c- n="">span</c-><c- o="">&gt;</c-></code></span><a class="self-link" href="#algorithms_and_friends"></a></h3>
    The above list of facilities is largely a grab-bag, but many of them are more useful if <code class="highlight"><c- n="">memcpy</c-></code> is made available in the <code class="highlight"><c- o="">&lt;</c-><c- n="">cstring</c-><c- o="">&gt;</c-></code> paper. 
   <p>Very little in <a href="https://wg21.link/diagnostics">[diagnostics]</a> is usable in freestanding, but the error code definitions in <code class="highlight"><c- o="">&lt;</c-><c- n="">cerrno</c-><c- o="">&gt;</c-></code> and <code class="highlight"><c- o="">&lt;</c-><c- n="">system_error</c-><c- o="">&gt;</c-></code> are fine.</p>
   <p>The details on specifically what to keep for these headers can be extracted from <a data-link-type="biblio" href="#biblio-p0829">[P0829]</a>.</p>
   <h3 class="heading settled" data-level="2.3" id="partial_classes"><span class="secno">2.3. </span><span class="content">Partial classes</span><a class="self-link" href="#partial_classes"></a></h3>
    <code class="highlight"><c- n="">array</c-></code>, <code class="highlight"><c- n="">string_view</c-></code>, <code class="highlight"><c- n="">variant</c-></code>, <code class="highlight"><c- n="">optional</c-></code>, and <code class="highlight"><c- n="">bitset</c-></code>
 are all classes that are fundamentally compatible with freestanding, 
but they all have non-critical functions that are not compatible.
These are generally functions that throw exceptions, or, in <code class="highlight"><c- n="">bitset</c-></code>'s case, use std::string. 
   <p><a data-link-type="biblio" href="#biblio-p0829">[P0829]</a> highlights which functions need to be addressed.
Rather than omitting the throwing functions, the functions should be "=deleted", so as to avoid overload resolution differences.
This is needed for cases where users derive from standard types and add overloads of standard functions.</p>
   <p><code class="highlight"><c- n="">bitset</c-></code> is more complicated because of the constructor overload set.
One of the overloads accepts a <code class="highlight"><c- n="">basic_string</c-></code>, and another accepts <code class="highlight"><c- n="">charT</c-> <c- o="">*</c-></code>.
Passing a <code class="highlight"><c- n="">string_view</c-></code> to <code class="highlight"><c- n="">bitset</c-></code> seems entirely reasonable.
Given the difficulty in making this work, it may be prudent to <i>not</i> bring <code class="highlight"><c- n="">bitset</c-></code> to freestanding.
It is the author’s belief that this would not be a great loss, as <code class="highlight"><c- n="">bitset</c-></code> doesn’t actually solve the bit manipulation problems that kernel and embedded developers commonly encounter.</p>
   <p><code class="highlight"><c- n="">string_view</c-></code> requires <code class="highlight"><c- n="">char_traits</c-></code> and <code class="highlight"><c- o="">&lt;</c-><c- n="">cstring</c-><c- o="">&gt;</c-></code>.</p>
   <h3 class="heading settled" data-level="2.4" id="random_header"><span class="secno">2.4. </span><span class="content"><code class="highlight"><c- o="">&lt;</c-><c- n="">random</c-><c- o="">&gt;</c-></code></span><a class="self-link" href="#random_header"></a></h3>
    <a data-link-type="biblio" href="#biblio-p0829">[P0829]</a> describes which <code class="highlight"><c- o="">&lt;</c-><c- n="">random</c-><c- o="">&gt;</c-></code> facilities are a good fit for freestanding.
This paper would need to deal with the specification hurdles of <code class="highlight"><c- k="">operator</c-><c- o="">&lt;&lt;</c-></code>.
The iostreams <code class="highlight"><c- k="">operator</c-><c- o="">&lt;&lt;</c-></code> overloads for <code class="highlight"><c- o="">&lt;</c-><c- n="">random</c-><c- o="">&gt;</c-></code> types are not listed in the synopsis, as they are permitted to be either hidden friends, or free functions.
This makes it editorially more difficult to omit. 
   <h3 class="heading settled" data-level="2.5" id="chrono_header"><span class="secno">2.5. </span><span class="content"><code class="highlight"><c- o="">&lt;</c-><c- n="">chrono</c-><c- o="">&gt;</c-></code> / <a href="https://wg21.link/time">[time]</a></span><a class="self-link" href="#chrono_header"></a></h3>
    Time arithmetic with underlying integer types is entirely reasonable on freestanding platforms.
However, <code class="highlight"><c- o="">&lt;</c-><c- n="">chrono</c-><c- o="">&gt;</c-></code> <code class="highlight"><c- n="">time_point</c-></code>s need an underlying Cpp17Clock.
Cpp17Clock requires a <code class="highlight"><c- n="">now</c-><c- p="">()</c-></code> function, which requires OS or hardware knowledge that is not appropriate for a freestanding implementation.
This paper would need to figure out what should be done with the existing types that satisfy the Cpp17Clock requirements.
Note that the in-flight <a data-link-type="biblio" href="#biblio-p2212">P2212: Relax Requirements for time_point::clock</a> should be kept in mind when working through the details. 
   <h2 class="heading settled" data-level="3" id="beyond_p0829"><span class="secno">3. </span><span class="content">Beyond <a data-link-type="biblio" href="#biblio-p0829">[P0829]</a></span><a class="self-link" href="#beyond_p0829"></a></h2>
    The following are papers that go beyond what <a data-link-type="biblio" href="#biblio-p0829">[P0829]</a> proposes.
These all need implementation experience before being proposed to WG21. 
   <h3 class="heading settled" data-level="3.1" id="constexpr_to_consteval"><span class="secno">3.1. </span><span class="content"><code class="highlight"><c- k="">constexpr</c-></code> as <code class="highlight"><c- k="">consteval</c-></code></span><a class="self-link" href="#constexpr_to_consteval"></a></h3>
    Freestanding has restrictions on the execution environment, but 
generally doesn’t have restrictions on the compilation environment.
In principle, everything that can be done at compile time for a hosted 
target can also be done at compile time for a freestanding target.
Having a compile time <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">vector</c-></code> would be beneficial, even on systems without a heap. 
   <p>A paper in this area would add blanket wording that ensures everything in the standard library that is <code class="highlight"><c- k="">constexpr</c-></code> is available at compile time for freestanding implementations.
If the entity is marked <code class="highlight"><c- c1="">// freestanding</c-></code>, then it would be available at runtime as well.
This would generally be implemented (and possibly specified) as making the function optionally <code class="highlight"><c- k="">consteval</c-></code> on freestanding implementations.
The freestanding implementation would either provide a <code class="highlight"><c- k="">consteval</c-></code> version of the facility, or a <code class="highlight"><c- k="">constexpr</c-></code> version if the target can support it.</p>
   <p>This paper would need to audit the standard library’s <code class="highlight"><c- k="">constexpr</c-></code> facilities and audit the <code class="highlight"><c- k="">constexpr</c-></code> papers in flight.
The paper would need to resolve complications of split overload sets, if any exist.</p>
   <p>The paper would need to evaluate semantic changes that could occur
 when porting freestanding code to hosted, particularly for classes that
 are <code class="highlight"><c- k="">constexpr</c-></code> but not freestanding (like <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">vector</c-></code> and <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">string</c-></code>). <code class="highlight"><c- k="">consteval</c-></code> objects can be destroyed at different times than <code class="highlight"><c- k="">constexpr</c-></code> objects.</p>
   <p>A <code class="highlight"><c- k="">consteval</c-></code> <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">string</c-></code> may be part of a solution to excluding <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">bitset</c-></code> functions that take a <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">string</c-></code> at runtime.</p>
   <p>It may also make sense to split this into multiple papers: one that covers all <code class="highlight"><c- k="">constexpr</c-></code> non-member functions, and another that covers all <code class="highlight"><c- k="">constexpr</c-></code> classes.</p>
   <h3 class="heading settled" data-level="3.2" id="startup_termintation"><span class="secno">3.2. </span><span class="content">Startup and termination control</span><a class="self-link" href="#startup_termintation"></a></h3>
   <h4 class="heading settled" data-level="3.2.1" id="replaceable_terminate"><span class="secno">3.2.1. </span><span class="content">Replaceable <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">terminate</c-></code> {#replaceable_terminate}</span><a class="self-link" href="#replaceable_terminate"></a></h4>
   <p>By default, <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">terminate</c-></code> delegates the work of termination to <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">abort</c-></code>. <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">abort</c-></code> will then use OS facilities to terminate the process.
On freestanding platforms, there’s a good chance that the C library <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">abort</c-></code> won’t link, because it is attempting to use OS facilities that don’t exist.
In addition, there are often additional or customized actions that need to be performed on embedded platforms.</p>
   <p>C++ already has a way to provide additional or customized actions for <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">terminate</c-></code>, and that is by changing the terminate handler at runtime.
The problem with this approach is that runtime is too late. <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">abort</c-></code> will be odr-used at build time, no matter how early in the runtime process the user switches the termination handler.
The user may end up linking in an otherwise unused atomics support library for <code class="highlight"><c- n="">set_terminate</c-></code> to use so that it won’t cause a data race.</p>
   <p>A paper addressing this would make <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">terminate</c-></code> a replaceable function, similar to <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code>.
Input would be needed from the ABI review group, as it is unclear whether making <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">terminate</c-></code> replaceable would be an ABI break or not.</p>
   <p>A further step could be taken to make <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">terminate</c-></code> optional on freestanding implementations, similar to how <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code> was made optional in <a data-link-type="biblio" href="#biblio-p2013">[P2013]</a>.
This would be controversial, as it would effectively make exceptions, <code class="highlight"><c- k="">dynamic_cast</c-></code>, and other features (<a href="https://wg21.link/except.terminate#1">[except.terminate]</a>) optional as well.
Note that there is usage experience for not having <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">terminate</c-></code> or it’s associated features (<a data-link-type="biblio" href="#biblio-p1105">[P1105]</a>).</p>
   <p>If <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">terminate</c-></code> where made a build-time replaceable function, then <code class="highlight"><c- n="">get_terminate</c-></code> and <code class="highlight"><c- n="">set_terminate</c-></code> would no longer need to be freestanding.</p>
   <h4 class="heading settled" data-level="3.2.2" id="link_time_arrays"><span class="secno">3.2.2. </span><span class="content">Link-time arrays {#link_time_arrays}</span><a class="self-link" href="#link_time_arrays"></a></h4>
   <p>C++ linkers have the ability to take symbols from multiple 
translation units and merge those symbols into a single array.
This facility is used as an implementation strategy for global 
constructors, thread local storage areas, and exception handling tables.
Each translation unit’s object file advertises some portion of the 
array.
The linker then either concatenates the arrays together in the final 
binary, or does some other kind of merging operation.</p>
   <p>It would be useful to expose this facility directly to the 
programmer.
Unit test frameworks usually have macros that create global objects that
 register a unit test with a singleton during program startup.
All the registrants are known at link time, yet we end up paying a 
runtime cost for the registration.
LLVM internals have optimization passes that are also registered via 
global object constructors.</p>
   <p>Here’s some expositional, strawman syntax to further convey the ideas suggested above.</p>
<pre class="highlight"><c- c1="">// test_framework.h</c->
<c- k="">using</c-> <c- n="">test_func</c-> <c- o="">=</c-> <c- b="">bool</c-> <c- p="">(</c-><c- o="">*</c-><c- p="">)();</c->
<c- c1="">// declare link-time array</c->
<c- k="">extern</c-> <c- k="">const</c-> <c- n="">test_func</c-> <c- n="">g_tests</c-><c- p="">[</c-><c- k="">register</c-><c- p="">];</c->

<c- c1="">// always_pass.cpp</c->
<c- cp="">#include</c-> "test_framework.h"
<c- b="">bool</c-> <c- nf="">always_pass</c-><c- p="">()</c-> <c- p="">{</c-><c- k="">return</c-> true<c- p="">;}</c->
<c- c1="">// add items to link-time array</c->
<c- k="">const</c-> <c- n="">test_func</c-> <c- n="">g_tests</c-><c- p="">[</c-><c- k="">register</c-><c- p="">]</c-> <c- o="">=</c-> <c- p="">{</c-><c- n="">always_pass</c-><c- p="">};</c->

<c- c1="">// always_fail.cpp</c->
<c- cp="">#include</c-> "test_framework.h"
<c- b="">bool</c-> <c- nf="">fail1</c-><c- p="">()</c-> <c- p="">{</c-><c- k="">return</c-> false<c- p="">;}</c->
<c- b="">bool</c-> <c- nf="">fail2</c-><c- p="">()</c-> <c- p="">{</c-><c- k="">return</c-> false<c- p="">;}</c->
<c- c1="">// add items to link-time array</c->
<c- k="">const</c-> <c- n="">test_func</c-> <c- n="">g_tests</c-><c- p="">[</c-><c- k="">register</c-><c- p="">]</c-> <c- o="">=</c-> <c- p="">{</c-><c- n="">fail1</c-><c- p="">,</c-> <c- n="">fail2</c-><c- p="">};</c->

<c- c1="">// main.cpp</c->
<c- cp="">#include</c-> "test_framework.h"
<c- b="">int</c-> <c- nf="">main</c-><c- p="">()</c-> <c- p="">{</c->
    <c- c1="">// g_tests contains {always_pass, fail1, fail2},</c->
    <c- c1="">// though not necessarily in that order</c->
    <c- k="">for</c-><c- p="">(</c-><c- n="">test_func</c-> <c- nl="">f</c-> <c- p="">:</c-> <c- n="">g_tests</c-><c- p="">)</c-> <c- p="">{</c->
        <c- k="">if</c-><c- p="">(</c-><c- o="">!</c-><c- n="">f</c-><c- p="">())</c-> <c- k="">return</c-> <c- mi="">1</c-><c- p="">;</c->
    <c- p="">}</c->
    <c- k="">return</c-> <c- mi="">0</c-><c- p="">;</c->
<c- p="">}</c->
</pre>
   <p>The use of <code class="highlight"><c- k="">register</c-></code> in the above code is strawman syntax.
The author of this future paper needs to figure out how to expose the end of the array.
This could be done with a non-constant-expression <code class="highlight"><c- k="">sizeof</c-></code>.
It could be done with a "magic" type, perhaps <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">span</c-></code>.
It could be done by exposing an end iterator / pointer.
There are likely other options as well.</p>
   <p>Link-time arrays are a useful primitive, as evidenced by their 
existing use for other language features.
Exposing them to programmers would allow for opt-in fixes to current 
problems.
Imagine having a link-time array that contains a "priority" value 
alongside an initialization function.
The consumer of the array could then sort the array (or a copy of it) by
 priority, then run the initialization functions.
This would portably solve some users issues with static initialization 
ordering by giving users the power to express the desired ordering.</p>
   <p>Link-time arrays could also provide a way to call "global 
constructors" in a dynamic library outside of various operating system 
locks.</p>
   <p>Link-time arrays could give users enough control to manually destroy and recreate an open set of global resources.</p>
   <p>This feature should probably be restricted to global arrays.  It 
may also make sense for an initial version to be restricted to some 
category of simple types (trivial types? literal types?).</p>
   <p>It is unclear to me how this feature could expose heterogenous 
"arrays" like those needed for thread_local storage initialization.
Getting the alignment right on individual elements seems particularly 
challenging.</p>
   <h4 class="heading settled" data-level="3.2.3" id="expose_global_ctors"><span class="secno">3.2.3. </span><span class="content">Exposing existing global constructor link-time arrays {#expose_global_ctors}</span><a class="self-link" href="#expose_global_ctors"></a></h4>
   <p>Link-time arrays on their own are useful for freestanding, but not
 uniquely so.
The reason they get mentioned in this freestanding roadmap is that 
implementations could then portably expose existing facilities, like the
 global constructor list.
Kernel and embedded users could then portably control when the global 
constructors are called.</p>
   <p>An author of such a paper needs to be sure to keep the destruction side of things in mind as well.</p>
   <h4 class="heading settled" data-level="3.2.4" id="thread_local_customization"><span class="secno">3.2.4. </span><span class="content"><code class="highlight"><c- k="">thread_local</c-></code> customization points {#thread_local_customization}</span><a class="self-link" href="#thread_local_customization"></a></h4>
   <p><code class="highlight"><c- k="">thread_local</c-></code> currently requires the compiler, linker, and operating system to collaborate on a <code class="highlight"><c- k="">thread_local</c-></code> protocol.
When the OS creates a thread, it will often want to know how much storage to set aside for <code class="highlight"><c- k="">thread_local</c-></code> variables.
It will want to know what the initial contents of that storage should be.
Currently, that information is not made portably available to users authoring their own OS.</p>
   <p>Once the per-thread storage is initialized, the compiler needs to know how to find the storage when accessing a variable.
Perhaps an extension point that exposes a numeric thread ID can be the bridge between the compiler runtime and user code.</p>
   <p>This potential paper has many unknowns.
There are many challenges regarding ABI compatibility and existing implementations.
It may also make sense to make <code class="highlight"><c- k="">thread_local</c-></code> support on freestanding implementations optional.</p>
   <p>SG1 in the San Diego 2018 meeting provided this feedback on <a data-link-type="biblio" href="#biblio-p1105">[P1105]</a>:</p>
   <p>Conforming freestanding implementations could make thread_local ill-formed<br> SF F N A SA<br> 3 12 5 0 0</p>
   <h3 class="heading settled" data-level="3.3" id="error_handling"><span class="secno">3.3. </span><span class="content">Error handling</span><a class="self-link" href="#error_handling"></a></h3>
    Error handling as a whole is the area in most need of work in freestanding.
There aren’t currently any good, standardized error handling facilities for freestanding platforms. 
   <p>The following facilities could help make <a data-link-type="biblio" href="#biblio-renwicklowcost">Renwick exceptions</a> or <a data-link-type="biblio" href="#biblio-p0709">[P0709]</a> exceptions more useful on freestanding platforms, while still satisfying the underlying use cases.</p>
   <h4 class="heading settled" data-level="3.3.1" id="dtor_call_reason"><span class="secno">3.3.1. </span><span class="content">Destructor call reason {#dtor_call_reason}</span><a class="self-link" href="#dtor_call_reason"></a></h4>
    <a data-link-type="biblio" href="#biblio-p0052">P0052: Generic Scope Guard and RAII Wrapper for the Standard Library</a> proposes <code class="highlight"><c- n="">scope_fail</c-></code> and <code class="highlight"><c- n="">scope_success</c-></code> (among other facilities).
These facilities need to know whether a destructor is being called as part of unwinding, or as part of normal execution.
The reference implementation relies on <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">uncaught_exceptions</c-></code>, which typically relies on some form of thread-local storage. 
   <p>In practice, thread-local storage is not widely available on freestanding platforms.
In addition, thread-local storage has concurrency issues with coroutines that migrate threads, as well as <a data-link-type="biblio" href="#biblio-p0876">[P0876]</a> fibers.
It would be nice to be able to implement <code class="highlight"><c- n="">scope_fail</c-></code>, <code class="highlight"><c- n="">scope_success</c-></code>, and similar facilities without the need to rely on thread-local storage.</p>
   <p>One way is to have an alternate signature for destructors that allows the user to discriminate between the two cases.</p>
<pre class="highlight"><c- k="">struct</c-> <c- n="">Strawman</c-> <c- p="">{</c->
  <c- o="">~</c-><c- n="">Strawman</c-><c- p="">(</c-><c- b="">bool</c-> <c- n="">success</c-><c- p="">)</c-> <c- p="">{</c->
    <c- k="">if</c-><c- p="">(</c-><c- n="">success</c-><c- p="">)</c-> <c- p="">{</c->
      <c- n="">success_action</c-><c- p="">();</c->
    <c- p="">}</c-> <c- k="">else</c-> <c- p="">{</c->
      <c- n="">fail_action</c-><c- p="">();</c->
    <c- p="">}</c->
  <c- p="">}</c->
<c- p="">};</c->
</pre>
   <p>We only need to allow one destructor per class.
A class with boolean destructor would only be able to be used as a 
non-member, a member of a class with a boolean destructor, or as a 
subobject of a class with a boolean destructor.
Classes with void destructors could be members of classes with boolean 
destructors.
More definition and exploration is needed around things like inheritance
 and virtual destructors.</p>
   <p>This general approach would likely make classes like <code class="highlight"><c- n="">scope_success</c-></code> and <code class="highlight"><c- n="">scope_fail</c-></code> faster and smaller, as the happy path doesn’t need to capture any state to compare later.
It removes the need for thread-local storage for this use case.</p>
   <h4 class="heading settled" data-level="3.3.2" id="non_local_exception"><span class="secno">3.3.2. </span><span class="content">Non-local exception objects {#non_local_exception}</span><a class="self-link" href="#non_local_exception"></a></h4>
    <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">uncaught_exceptions</c-></code> isn’t the only way in which the exception handling mechanism uses thread-local storage. <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">current_exception</c-></code> and <code class="highlight"><c- k="">throw</c-><c- p="">;</c-></code> also use thread-local storage.
If we could directly capture a <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">exception_ptr</c-></code>, or something similar to one, then we could avoid thread-local storage. 
<pre class="highlight"><c- c1="">// strawman syntax only</c->
<c- b="">int</c-> <c- nf="">may_throw</c-><c- p="">();</c->
<c- n="">std</c-><c- o="">::</c-><c- n="">expected</c-><c- o="">&lt;</c-><c- b="">int</c-><c- p="">,</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">ex_ptr2</c-><c- o="">&gt;</c-> <c- n="">f</c-><c- p="">()</c-> <c- p="">{</c->
  <c- k="">try</c-> <c- p="">{</c->
    <c- k="">return</c-> <c- n="">may_throw</c-><c- p="">();</c->
  <c- p="">}</c-> <c- k="">catch</c-><c- p="">(</c-><c- n="">std</c-><c- o="">::</c-><c- n="">ex_ptr2</c-> <c- nl="">e</c-> <c- p="">:</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">exception</c-> <c- o="">&amp;</c-><c- n="">orig</c-><c- p="">)</c-> <c- p="">{</c->
    <c- c1="">// catches everything derived from std::exception, provides</c->
    <c- c1="">// an ex_ptr2 for capturing and rethrowing purposes</c->
    <c- n="">std</c-><c- o="">::</c-><c- n="">cout</c-><c- o="">&lt;&lt;</c-><c- n="">orig</c-><c- p="">.</c-><c- n="">what</c-><c- p="">();</c->
    <c- k="">return</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">unexpected</c-><c- p="">(</c-><c- n="">e</c-><c- p="">);</c->
  <c- p="">}</c-> <c- k="">catch</c-><c- p="">(</c-><c- n="">std</c-><c- o="">::</c-><c- n="">ex_ptr2</c-> <c- nl="">e</c-> <c- p="">:</c-> <c- p="">...)</c-> <c- p="">{</c->
    <c- c1="">// catches everything, provides an ex_ptr2 for capturing and</c->
    <c- c1="">// rethrowing purposes</c->
    <c- k="">return</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">unexpected</c-><c- p="">(</c-><c- n="">e</c-><c- p="">);</c->
  <c- p="">}</c->
<c- p="">}</c->
</pre>
   <p>Such a facility could be used to implement <a data-link-type="biblio" href="#biblio-guillemot">"Lippincott" functions</a>, or to transport an exception across threads.
It may be possible to reuse the current <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">exception_ptr</c-></code>
 for this facility, but reuse here shouldn’t be considered a necessary 
design constraint.
A new type may be able to do deep, stack based copies of exception 
objects, potentially avoiding using the heap entirely (offer not valid 
in Itanium ABI jurisdictions).</p>
   <p>There is likely a lot of overlap between this suggestion, and <a data-link-type="biblio" href="#biblio-p1066">P1066: How to catch an <code class="highlight"><c- n="">exception_ptr</c-></code> without even <code class="highlight"><c- k="">try</c-></code>-ing</a>.</p>
   <h4 class="heading settled" data-level="3.3.3" id="noexcept_blocks"><span class="secno">3.3.3. </span><span class="content"><code class="highlight"><c- k="">noexcept</c-></code> blocks {#noexcept_blocks}</span><a class="self-link" href="#noexcept_blocks"></a></h4>
    One of the ways to combat exception overhead is by accurately marking large numbers of functions as <code class="highlight"><c- k="">noexcept</c-></code>.
This only reduces overhead when the <code class="highlight"><c- k="">noexcept</c-></code> function only calls other functions that the implementation can prove don’t throw.
Marking lots of functions as <code class="highlight"><c- k="">noexcept</c-></code> adds a fair amount of syntactic noise though. <code class="highlight"><c- k="">noexcept</c-></code> blocks could reduce that noise. 
<pre class="highlight"><c- k="">noexcept</c-> <c- p="">{</c->
  <c- b="">void</c-> <c- n="">does_not_throw</c-><c- p="">();</c->
  <c- b="">void</c-> <c- nf="">also_does_not_throw</c-><c- p="">();</c->
  <c- b="">void</c-> <c- nf="">may_throw</c-><c- p="">()</c-> <c- k="">noexcept</c-><c- p="">(</c->true<c- p="">);</c->
<c- p="">}</c->
</pre>
   <p>One of the major challenges in accurate <code class="highlight"><c- k="">noexcept</c-></code> annotation is dealing with functions from C libraries. <code class="highlight"><c- k="">extern</c-> <c- s="">"C"</c-></code> functions are allowed to throw, but most don’t.
Very few C functions are marked as <code class="highlight"><c- k="">noexcept</c-></code>. <code class="highlight"><c- k="">noexcept</c-></code> blocks are one way to deal with that.</p>
<pre class="highlight"><c- k="">noexcept</c-> <c- p="">{</c->
  <c- cp="">#include</c-> "some_c_header.h"
<c- p="">}</c->
</pre>
   <p>This is likely to lead to (usually harmless) ODR violations.</p>
   <h4 class="heading settled" data-level="3.3.4" id="trim_exception_header"><span class="secno">3.3.4. </span><span class="content">Trim exception header {#trim_exception_header}</span><a class="self-link" href="#trim_exception_header"></a></h4>
    If and when destructor call reasons and non-local exception objects 
get standardized, we could remove freestanding-hostile functionality 
from freestanding.
In particular, we could stop requiring <code class="highlight"><c- n="">uncaught_exceptions</c-><c- p="">()</c-></code>, <code class="highlight"><c- n="">current_exception</c-><c- p="">()</c-></code>, and <code class="highlight"><c- k="">throw</c-><c- p="">;</c-></code> from being required on freestanding implementations.
This may be sufficient for something like <a data-link-type="biblio" href="#biblio-renwicklowcost">Renwick exceptions</a> or <a data-link-type="biblio" href="#biblio-p0709">[P0709]</a> to be successful without requiring thread-local storage. 
   <h3 class="heading settled" data-level="3.4" id="hard"><span class="secno">3.4. </span><span class="content">No known path forward</span><a class="self-link" href="#hard"></a></h3>
    The following topics are problem areas for freestanding, but the 
author doesn’t have any great ideas on how to address them in WG21. 
   <h4 class="heading settled" data-level="3.4.1" id="locked_atomics"><span class="secno">3.4.1. </span><span class="content">Locked atomics {#locked_atomics}</span><a class="self-link" href="#locked_atomics"></a></h4>
    Operating systems and embedded devices often need to write interrupt handling code.
The rules for interrupt-safe code are very similar to the rules for signal-safe code.
Locked atomics / non-lock-free atomics are a portability trap in these environments. 
   <p><a data-link-type="biblio" href="#biblio-p1105">[P1105]</a> proposed making locked atomics ill-formed on freestanding platforms.</p>
   <p>SG1 in the San Diego 2018 meeting provided this feedback on <a data-link-type="biblio" href="#biblio-p1105">[P1105]</a>:</p>
   <p>Conforming freestanding implementations could omit lock-free[sic] atomics<br> SF F N A SA<br> 2 6 4 6 2</p>
   <p>[--Note
The wording of the poll seems to have been minuted slightly wrong.
Omitting non-lock-free atomics was the intent.
--end note --]</p>
   <h4 class="heading settled" data-level="3.4.2" id="thread_safe_statics"><span class="secno">3.4.2. </span><span class="content">Thread-safe statics {#thread_safe_statics}</span><a class="self-link" href="#thread_safe_statics"></a></h4>
    Thread-safe statics require locking support.
Similar to locked atomics, there is no one right choice. 
   <p><a data-link-type="biblio" href="#biblio-p1105">[P1105]</a> Proposed making thread-safe statics ill-formed on freestanding platforms.</p>
   <p>SG1 in the San Diego 2018 meeting provided this feedback on <a data-link-type="biblio" href="#biblio-p1105">[P1105]</a>:</p>
   <p>Conforming freestanding implementations could omit thread-safe statics<br> SF F N A SA<br> 0 6 8 4 2<br></p>
   <h4 class="heading settled" data-level="3.4.3" id="rtti"><span class="secno">3.4.3. </span><span class="content">RTTI {#rtti}</span><a class="self-link" href="#rtti"></a></h4>
    The non-throwing parts of RTTI are implementable on most freestanding platforms.
The issue is that it is very hard to optimize away unused <code class="highlight"><c- n="">type_info</c-></code>s. 
   <p><a data-link-type="biblio" href="#biblio-p1105">[P1105]</a> recommends making <code class="highlight"><c- k="">typeid</c-><c- p="">(</c-><c- n="">expr</c-><c- p="">)</c-></code> and <code class="highlight"><c- k="">dynamic_cast</c-></code> ill-formed on freestanding platforms.
It seems unlikely that such a direction will gain consensus in WG21.</p>
   <h4 class="heading settled" data-level="3.4.4" id="floating_point"><span class="secno">3.4.4. </span><span class="content">Floating point {#floating_point}</span><a class="self-link" href="#floating_point"></a></h4>
    Unprotected use of floating point operations in kernel environments 
will corrupt the user mode state on many operating systems.  This is 
true even when the operations are just loads and stores.
Some operating systems provide a way to explicitly save and restore the 
floating point state, so that floating point can be used in a given 
region. 
   <p>Embedded processors often do not have dedicated floating point units.
On these platforms, floating point is emulated in software.
This floating point emulation is often very large in terms of code size.</p>
   <p>Ideally, there would be a portable way to discourage floating point use in these environments, without making it impossible.</p>
   <p><a data-link-type="biblio" href="#biblio-p1105">[P1105]</a> 
recommended making the floating point types ill-formed in environments 
where floating point isn’t supported.
This approach would be difficult to get consensus on.
It would also make it much more difficult to get consistent overload set
 behavior when moving code between floating point and hosted 
environments.</p>
   <h2 class="heading settled" data-level="4" id="wip"><span class="secno">4. </span><span class="content">Work in progress</span><a class="self-link" href="#wip"></a></h2>
   <h3 class="heading settled" data-level="4.1" id="p2013"><span class="secno">4.1. </span><span class="content"><a data-link-type="biblio" href="#biblio-p2013">[P2013]</a> Freestanding Language: Optional <code class="highlight"><c- o="">::</c-><c- k="">operator</c-> <c- k="">new</c-></code></span><a class="self-link" href="#p2013"></a></h3>
    P2013R1 is awaiting further EWG review.
EWG reviewed P2013R0 favorably in the 2020 Prague meeting, and requested wording.
Wording is present and ready for review in P2013R1. 
   <h3 class="heading settled" data-level="4.2" id="P1642"><span class="secno">4.2. </span><span class="content"><a data-link-type="biblio" href="#biblio-p1642">[P1642]</a> Freestanding Library: Easy [utilities], [ranges], and [iterators]</span><a class="self-link" href="#P1642"></a></h3>
    P1642R4 combines the wording in P1641R3 and the library additions from P1642R3.
P1642R4 is awaiting further LEWG review. 
   <p>The non-feature test macro parts of P1641R3 and P1642R3 were 
reviewed favorably over LEWG telecon.
LEWG requested that those parts be combined into a single paper, and 
that LEWG not spend future time discussing the contents of the library 
additions.</p>
   <h3 class="heading settled" data-level="4.3" id="P2198"><span class="secno">4.3. </span><span class="content"><a data-link-type="biblio" href="#biblio-p2198">[P2198]</a> Freestanding Feature-Test Macros and Implementation-Defined Extensions</span><a class="self-link" href="#P2198"></a></h3>
    P2198R0 has taken all the feature-test macro parts from P1642R3 and P1641R3, and consolidated them here.
P2198R0 needs to be reviewed by SG10, as it is doing something more involved than just including a feature test macro. 
   <h2 class="heading settled" data-level="5" id="related_wip"><span class="secno">5. </span><span class="content">Related work in progress</span><a class="self-link" href="#related_wip"></a></h2>
   <h3 class="heading settled" data-level="5.1" id="related_stl_modules"><span class="secno">5.1. </span><span class="content"><a data-link-type="biblio" href="#biblio-p0581">[P0581]</a> Standard Library Modules</span><a class="self-link" href="#related_stl_modules"></a></h3>
    The way we partition the standard library into modules has the 
potential to change how freestanding is advertised and messaged 
significantly.
The partitioning could also place new constraints on freestanding. 
   <h3 class="heading settled" data-level="5.2" id="related_expected"><span class="secno">5.2. </span><span class="content"><a data-link-type="biblio" href="#biblio-p0323">[P0323]</a> <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">expected</c-></code></span><a class="self-link" href="#related_expected"></a></h3>
    Error handling is currently the largest sore point in freestanding, and <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">expected</c-></code> is one proven approach that can address many error handling needs. 
   <h3 class="heading settled" data-level="5.3" id="related_renwick"><span class="secno">5.3. </span><span class="content"><a data-link-type="biblio" href="#biblio-renwicklowcost">Renwick exceptions</a></span><a class="self-link" href="#related_renwick"></a></h3>
    This paper describes an implementation method of exceptions that 
could resolve many long standing implementability and performance issues
 with exceptions in freestanding environments.
This is currently the best hope that C++ has for a one-size-fits-most 
error handling mechanism. 
   <p>Most of the work in this paper is beyond the authority of WG21.
The paper asks for ABI changes, and for implementers to make different trade-offs than they have traditionally made.
The paper also asks the freestanding community to use a language feature that they have traditionally shunned.</p>
   <h3 class="heading settled" data-level="5.4" id="related_p0709"><span class="secno">5.4. </span><span class="content"><a data-link-type="biblio" href="#biblio-p0709">[P0709]</a> Zero-overhead deterministic exceptions: Throwing values</span><a class="self-link" href="#related_p0709"></a></h3>
    This paper describes an additional form of exception handling that can coexist with today’s C++ exceptions.
This is currently the best hope that C++ has for exceptions where the user can make function-specific performance trade-offs. 
   <p>If this paper gets accepted, then there will likely be a need for 
many follow-on papers to parameterize the error handling for many C++ 
facilities.
Users would want to be able to provide an allocator to <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">vector</c-></code> that would make that instantiation use P0709 exceptions.
Users would want to be able to make coroutine promise types report allocation failures through P0709 exceptions.
Users may even want a variety of <code class="highlight"><c- k="">dynamic_cast</c-></code> that uses P0709 exceptions.</p>
   <h2 class="heading settled" data-level="6" id="papers_and_issues"><span class="secno">6. </span><span class="content">Applied papers and issues</span><a class="self-link" href="#papers_and_issues"></a></h2>
   <ul>
    <li data-md="">
     <p><a data-link-type="biblio" href="#biblio-lwg3148">[LWG3148]</a> <code class="highlight"><c- o="">&lt;</c-><c- n="">concepts</c-><c- o="">&gt;</c-></code> should be freestanding</p>
    </li><li data-md="">
     <p><a data-link-type="biblio" href="#biblio-p1855">[P1855]</a> Make <code class="highlight"><c- o="">&lt;</c-><c- n="">compare</c-><c- o="">&gt;</c-></code> freestanding</p>
   </li></ul>
   <h2 class="heading settled" data-level="7" id="retired"><span class="secno">7. </span><span class="content">Retired papers</span><a class="self-link" href="#retired"></a></h2>
   <h3 class="heading settled" data-level="7.1" id="retired_p0829"><span class="secno">7.1. </span><span class="content"><a data-link-type="biblio" href="#biblio-p0829">[P0829]</a> Freestanding Proposal</span><a class="self-link" href="#retired_p0829"></a></h3>
    P0829 was too large to be effectively reviewed, so it has been split up. <a data-link-type="biblio" href="#biblio-p1641">[P1641]</a>, <a data-link-type="biblio" href="#biblio-p1642">[P1642]</a>, and <a data-link-type="biblio" href="#biblio-p2198">[P2198]</a> are the current successors to P0829, but more are needed.
See <a href="#p0829_pieces">§ 2 [P0829] pieces</a> for some of the other papers that still need to be authored. 
   <h3 class="heading settled" data-level="7.2" id="retired_p1641"><span class="secno">7.2. </span><span class="content"><a data-link-type="biblio" href="#biblio-p1641">[P1641]</a> Freestanding Library: Rewording the Status Quo</span><a class="self-link" href="#retired_p1641"></a></h3>
    Most of the wording aspects of this paper have moved to P1642, and the feature test macro parts have moved to P2198. 
   <h3 class="heading settled" data-level="7.3" id="retired_p1105"><span class="secno">7.3. </span><span class="content"><a data-link-type="biblio" href="#biblio-p1105">[P1105]</a> Leaving no room for a lower-level language: A C++ Subset</span><a class="self-link" href="#retired_p1105"></a></h3>
    P1105 was meant to describe a direction.
Follow-on papers were meant to act on that direction.
P2013 is one such paper. 
   <p>When SG1 reviewed this paper in the 2018 San Diego meeting, they 
reacted favorably to the thread_local parts, and unfavorably to the 
locked atomics and thread safe static parts.</p>
   <h3 class="heading settled" data-level="7.4" id="retired_p1212"><span class="secno">7.4. </span><span class="content"><a data-link-type="biblio" href="#biblio-p1212">[P1212]</a> Modules and freestanding</span><a class="self-link" href="#retired_p1212"></a></h3>
    This paper was a reaction to <a data-link-type="biblio" href="#biblio-p0581">[P0581]</a>.
One of the questions this paper asked was to put the language support 
facilities that require an operating system in a different module from 
the freestanding facilities.
EWG was opposed to this direction in the San Diego 2018 meeting.
The author’s position regarding freestanding and standard library 
modules has changed significantly since the San Diego 2018 meeting. 
   <h3 class="heading settled" data-level="7.5" id="retired_p1372"><span class="secno">7.5. </span><span class="content"><a data-link-type="biblio" href="#biblio-p1372">[P1372]</a> Giving atomic_ref implementers more flexibility by providing customization points for non-lock-free implementation</span><a class="self-link" href="#retired_p1372"></a></h3>
    This paper was not received favorably by SG1 in San Diego’s 2018 meeting. 
   <h2 class="heading settled" data-level="8" id="ack"><span class="secno">8. </span><span class="content">Acknowledgments</span><a class="self-link" href="#ack"></a></h2>
    Thank you to Brandon Streiff for reviewing this paper and providing additional use cases for link-time arrays. 
  </main>
<script>
(function() {
  "use strict";
  var collapseSidebarText = '<span aria-hidden="true">←</span> '
                          + '<span>Collapse Sidebar</span>';
  var expandSidebarText   = '<span aria-hidden="true">→</span> '
                          + '<span>Pop Out Sidebar</span>';
  var tocJumpText         = '<span aria-hidden="true">↑</span> '
                          + '<span>Jump to Table of Contents</span>';

  var sidebarMedia = window.matchMedia('screen and (min-width: 78em)');
  var autoToggle   = function(e){ toggleSidebar(e.matches) };
  if(sidebarMedia.addListener) {
    sidebarMedia.addListener(autoToggle);
  }

  function toggleSidebar(on) {
    if (on == undefined) {
      on = !document.body.classList.contains('toc-sidebar');
    }

    /* Don’t scroll to compensate for the ToC if we’re above it already. */
    var headY = 0;
    var head = document.querySelector('.head');
    if (head) {
      // terrible approx of "top of ToC"
      headY += head.offsetTop + head.offsetHeight;
    }
    var skipScroll = window.scrollY < headY;

    var toggle = document.getElementById('toc-toggle');
    var tocNav = document.getElementById('toc');
    if (on) {
      var tocHeight = tocNav.offsetHeight;
      document.body.classList.add('toc-sidebar');
      document.body.classList.remove('toc-inline');
      toggle.innerHTML = collapseSidebarText;
      if (!skipScroll) {
        window.scrollBy(0, 0 - tocHeight);
      }
      tocNav.focus();
      sidebarMedia.addListener(autoToggle); // auto-collapse when out of room
    }
    else {
      document.body.classList.add('toc-inline');
      document.body.classList.remove('toc-sidebar');
      toggle.innerHTML = expandSidebarText;
      if (!skipScroll) {
        window.scrollBy(0, tocNav.offsetHeight);
      }
      if (toggle.matches(':hover')) {
        /* Unfocus button when not using keyboard navigation,
           because I don’t know where else to send the focus. */
        toggle.blur();
      }
    }
  }

  function createSidebarToggle() {
    /* Create the sidebar toggle in JS; it shouldn’t exist when JS is off. */
    var toggle = document.createElement('a');
      /* This should probably be a button, but appearance isn’t standards-track.*/
    toggle.id = 'toc-toggle';
    toggle.class = 'toc-toggle';
    toggle.href = '#toc';
    toggle.innerHTML = collapseSidebarText;

    sidebarMedia.addListener(autoToggle);
    var toggler = function(e) {
      e.preventDefault();
      sidebarMedia.removeListener(autoToggle); // persist explicit off states
      toggleSidebar();
      return false;
    }
    toggle.addEventListener('click', toggler, false);


    /* Get <nav id=toc-nav>, or make it if we don’t have one. */
    var tocNav = document.getElementById('toc-nav');
    if (!tocNav) {
      tocNav = document.createElement('p');
      tocNav.id = 'toc-nav';
      /* Prepend for better keyboard navigation */
      document.body.insertBefore(tocNav, document.body.firstChild);
    }
    /* While we’re at it, make sure we have a Jump to Toc link. */
    var tocJump = document.getElementById('toc-jump');
    if (!tocJump) {
      tocJump = document.createElement('a');
      tocJump.id = 'toc-jump';
      tocJump.href = '#toc';
      tocJump.innerHTML = tocJumpText;
      tocNav.appendChild(tocJump);
    }

    tocNav.appendChild(toggle);
  }

  var toc = document.getElementById('toc');
  if (toc) {
    createSidebarToggle();
    toggleSidebar(sidebarMedia.matches);

    /* If the sidebar has been manually opened and is currently overlaying the text
       (window too small for the MQ to add the margin to body),
       then auto-close the sidebar once you click on something in there. */
    toc.addEventListener('click', function(e) {
      if(e.target.tagName.toLowerCase() == "a" && document.body.classList.contains('toc-sidebar') && !sidebarMedia.matches) {
        toggleSidebar(false);
      }
    }, false);
  }
  else {
    console.warn("Can’t find Table of Contents. Please use <nav id='toc'> around the ToC.");
  }

  /* Wrap tables in case they overflow */
  var tables = document.querySelectorAll(':not(.overlarge) > table.data, :not(.overlarge) > table.index');
  var numTables = tables.length;
  for (var i = 0; i < numTables; i++) {
    var table = tables[i];
    var wrapper = document.createElement('div');
    wrapper.className = 'overlarge';
    table.parentNode.insertBefore(wrapper, table);
    wrapper.appendChild(table);
  }

})();
</script>
  <h2 class="no-num no-ref heading settled" id="references"><span class="content">References</span><a class="self-link" href="#references"></a></h2>
  <h3 class="no-num no-ref heading settled" id="informative"><span class="content">Informative References</span><a class="self-link" href="#informative"></a></h3>
  <dl>
   <dt id="biblio-guillemot">[Guillemot]
   </dt><dd>Nicolas Guillemot. <a href="http://cppsecrets.blogspot.com/2013/12/using-lippincott-function-for.html">Using a Lippincott Function for Centralized Exception Handling</a>. URL: <a href="http://cppsecrets.blogspot.com/2013/12/using-lippincott-function-for.html">http://cppsecrets.blogspot.com/2013/12/using-lippincott-function-for.html</a>
   </dd><dt id="biblio-lwg3148">[LWG3148]
   </dt><dd>Casey Carter. <a href="https://wg21.link/LWG3148">`&lt;concepts&gt;` should be freestanding</a>. URL: <a href="https://wg21.link/LWG3148">https://wg21.link/LWG3148</a>
   </dd><dt id="biblio-p0052">[P0052]
   </dt><dd>Peter Sommerlad; Andrew L. Sandoval. <a href="https://wg21.link/P0052r10">Generic Scope Guard and RAII Wrapper for the Standard Library</a>. URL: <a href="https://wg21.link/P0052r10">https://wg21.link/P0052r10</a>
   </dd><dt id="biblio-p0323">[P0323]
   </dt><dd>Vicente Botet; JF Bastien. <a href="https://wg21.link/P0323">`std::expected`</a>. URL: <a href="https://wg21.link/P0323">https://wg21.link/P0323</a>
   </dd><dt id="biblio-p0581">[P0581]
   </dt><dd>Marshall Clow; et al. <a href="http://wg21.link/P0581">Standard Library Modules</a>. URL: <a href="http://wg21.link/P0581">http://wg21.link/P0581</a>
   </dd><dt id="biblio-p0709">[P0709]
   </dt><dd>Herb Sutter. <a href="http://wg21.link/P0709">Zero-overhead deterministic exceptions: Throw values</a>. URL: <a href="http://wg21.link/P0709">http://wg21.link/P0709</a>
   </dd><dt id="biblio-p0829">[P0829]
   </dt><dd>Ben Craig. <a href="https://wg21.link/P0829">Freestanding Proposal</a>. URL: <a href="https://wg21.link/P0829">https://wg21.link/P0829</a>
   </dd><dt id="biblio-p0876">[P0876]
   </dt><dd>Oliver Kowalke; Nat Goodspeed. <a href="https://wg21.link/P0876R10">fiber_context- fibers without scheduler</a>. URL: <a href="https://wg21.link/P0876R10">https://wg21.link/P0876R10</a>
   </dd><dt id="biblio-p1066">[P1066]
   </dt><dd>Mathias Stearn. <a href="http://wg21.link/P1066R1">How to catch an exception_ptr without even try-ing</a>. URL: <a href="http://wg21.link/P1066R1">http://wg21.link/P1066R1</a>
   </dd><dt id="biblio-p1105">[P1105]
   </dt><dd>Ben Craig; Ben Saks. <a href="https://wg21.link/P1105R1">Leaving no room for a lower-level language: A C++ Subset</a>. URL: <a href="https://wg21.link/P1105R1">https://wg21.link/P1105R1</a>
   </dd><dt id="biblio-p1212">[P1212]
   </dt><dd>Ben Craig. <a href="https://wg21.link/P1212R0">Modules and Freestanding</a>. URL: <a href="https://wg21.link/P1212R0">https://wg21.link/P1212R0</a>
   </dd><dt id="biblio-p1372">[P1372]
   </dt><dd>Daisy Hollman. <a href="https://wg21.link/P1372R0">Giving `atomic_ref` implementers more flexibility by providing customization points for non-lock-free implementation</a>. URL: <a href="https://wg21.link/P1372R0">https://wg21.link/P1372R0</a>
   </dd><dt id="biblio-p1641">[P1641]
   </dt><dd>Ben Craig. <a href="https://wg21.link/P1641R3">Freestanding Library: Rewording the Status Quo</a>. URL: <a href="https://wg21.link/P1641R3">https://wg21.link/P1641R3</a>
   </dd><dt id="biblio-p1642">[P1642]
   </dt><dd>Ben Craig. <a href="https://wg21.link/P1642R4">Freestanding Library: Easy [utilities], [ranges], and [iterators]</a>. URL: <a href="https://wg21.link/P1642R4">https://wg21.link/P1642R4</a>
   </dd><dt id="biblio-p1855">[P1855]
   </dt><dd>Ben Craig. <a href="https://wg21.link/P1855R0">Make &lt;compare&gt; freestanding</a>. URL: <a href="https://wg21.link/P1855R0">https://wg21.link/P1855R0</a>
   </dd><dt id="biblio-p2013">[P2013]
   </dt><dd>Ben Craig. <a href="https://wg21.link/P2013R3">Freestanding Language: Optional `::operator new`</a>. URL: <a href="https://wg21.link/P2013R3">https://wg21.link/P2013R3</a>
   </dd><dt id="biblio-p2198">[P2198]
   </dt><dd>Ben Craig. <a href="https://wg21.link/P2198R1">Freestanding Feature-Test Macros and Implementation-Defined Extensions</a>. URL: <a href="https://wg21.link/P2198R1">https://wg21.link/P2198R1</a>
   </dd><dt id="biblio-p2212">[P2212]
   </dt><dd>Alexey Dmitriev; Howard Hinnant. <a href="https://wg21.link/p2212r2">Relax Requirements for time_point::clock</a>. URL: <a href="https://wg21.link/p2212r2">https://wg21.link/p2212r2</a>
   </dd><dt id="biblio-renwicklowcost">[RenwickLowCost]
   </dt><dd>James Renwick; Tom Spink; Bjoern Franke. <a href="https://www.research.ed.ac.uk/portal/en/publications/lowcost-deterministic-c-exceptions-for-embedded-systems(2cfc59d5-fa95-45e0-83b2-46e51098cf1f).html">Low-cost Deterministic C++ Exceptions for Embedded Systems</a>. URL: <a href="https://www.research.ed.ac.uk/portal/en/publications/lowcost-deterministic-c-exceptions-for-embedded-systems(2cfc59d5-fa95-45e0-83b2-46e51098cf1f).html">https://www.research.ed.ac.uk/portal/en/publications/lowcost-deterministic-c-exceptions-for-embedded-systems(2cfc59d5-fa95-45e0-83b2-46e51098cf1f).html</a>
  </dd></dl></body></html>