Warn when assembly doesn't appear to generate symbols

Author: shepmaster

ui/frontend/.prettierignore

@@ -19,6 +19,7 @@ node_modules
 !Header.tsx
 !HelpExample.tsx
 !Notifications.tsx
+!Output/Assembly.tsx
 !Output/OutputPrism.tsx
 !Output/PaneWithCode.tsx
 !Output/PaneWithMir.tsx

ui/frontend/Output.tsx

@@ -4,6 +4,7 @@ import { changeFocus } from './reducers/output/meta';
 import { Focus } from './types';
 
 import Execute from './Output/Execute';
+import Assembly from './Output/Assembly';
 import Gist from './Output/Gist';
 import SimplePane from './Output/SimplePane';
 import PaneWithMir from './Output/PaneWithMir';
@@ -73,7 +74,7 @@ const Output: React.FC = () => {
           {focus === Focus.Clippy && <SimplePane {...clippy} kind="clippy" />}
           {focus === Focus.Miri && <SimplePane {...miri} kind="miri" />}
           {focus === Focus.MacroExpansion && <SimplePane {...macroExpansion} kind="macro-expansion" />}
-          {focus === Focus.Asm && <PaneWithCode {...assembly} kind="asm" />}
+          {focus === Focus.Asm && <Assembly />}
           {focus === Focus.LlvmIr && <PaneWithCode {...llvmIr} kind="llvm-ir" />}
           {focus === Focus.Mir && <PaneWithMir {...mir} kind="mir" />}
           {focus === Focus.Hir && <PaneWithMir {...hir} kind="hir" />}

ui/frontend/Output/Assembly.tsx

@@ -0,0 +1,32 @@
+import React from 'react';
+
+import { useAppSelector } from '../hooks';
+import * as selectors from '../selectors';
+import PaneWithCode from './PaneWithCode';
+import Section from './Section';
+
+const Assembly: React.FC = () => {
+  const assembly = useAppSelector((state) => state.output.assembly);
+  const isAssemblyInProgress = useAppSelector(selectors.isAssemblyInProgressSelector);
+  const hasAssemblySymbols = useAppSelector(selectors.hasAssemblySymbolsSelector);
+
+  const warnAboutNoSymbols = !isAssemblyInProgress && !hasAssemblySymbols;
+
+  return (
+    <PaneWithCode {...assembly} kind="asm">
+      {warnAboutNoSymbols ? (
+        <Section kind="warning" label="Warnings">
+          No symbols detected — they may have been optimized away.
+          {'\n'}
+          Add the <code>#[unsafe(no_mangle)]</code> attribute to
+          {'\n'}
+          functions you want to see assembly for. Generic functions
+          {'\n'}
+          only generate assembly when concrete types are provided.
+        </Section>
+      ) : null}
+    </PaneWithCode>
+  );
+};
+
+export default Assembly;

ui/frontend/selectors/index.spec.ts

@@ -1,6 +1,6 @@
 import reducer from '../reducers';
 import { editCode } from '../reducers/code';
-import { hasMainFunctionSelector } from './index';
+import { hasAssemblySymbolsSelector, hasMainFunctionSelector } from './index';
 
 const buildState = (code: string) => reducer(undefined, editCode(code));
 
@@ -64,3 +64,51 @@ describe('checking for a main function', () => {
     expect(doMainFunctionSelector('fn main(/* comment */) {')).toBe(true);
   });
 });
+
+const doHasAssemblySymbolSelector = (code: string) => {
+  const state = reducer(
+    { output: { assembly: { code, requestsInProgress: 0 } } },
+    { type: 'test' },
+  );
+  return hasAssemblySymbolsSelector(state);
+};
+
+describe('checking for symbols in assembly output', () => {
+  test('empty code has no symbols', () => {
+    expect(doHasAssemblySymbolSelector('')).toBe(false);
+  });
+
+  test('instructions are not symbols', () => {
+    // x86_64
+    expect(doHasAssemblySymbolSelector('    	movl	%edi, 4(%rsp)')).toBe(false);
+    // arm
+    expect(doHasAssemblySymbolSelector('	sub	sp, sp, #32')).toBe(false);
+  });
+
+  test('mangled symbols are symbols', () => {
+    expect(doHasAssemblySymbolSelector('_ZN10playground3add17h903bea7e047dfb9fE:')).toBe(true);
+  });
+
+  test('unmangled symbols are symbols', () => {
+    expect(doHasAssemblySymbolSelector('playground::add:')).toBe(true);
+  });
+
+  test('unmangled symbols from traits are symbols', () => {
+    expect(
+      doHasAssemblySymbolSelector(
+        '<rand::rngs::reseeding::ReseedingCore<R,Rsdr> as rand_core::block::BlockRngCore>::generate:',
+      ),
+    ).toBe(true);
+  });
+
+  test('symbols with comments are symbols', () => {
+    // x86_64
+    expect(doHasAssemblySymbolSelector('add:                                    # @add')).toBe(
+      true,
+    );
+    // arm
+    expect(doHasAssemblySymbolSelector('add:                                    // @add')).toBe(
+      true,
+    );
+  });
+});

ui/frontend/selectors/index.ts

@@ -518,6 +518,18 @@ export const compileRequestPayloadSelector = createSelector(
   }),
 );
 
+export const isAssemblyInProgressSelector = createSelector(
+  (state: State) => state.output.assembly,
+  asm => asm.requestsInProgress > 0,
+);
+
+const ASSEMBLY_SYMBOLS_RE = /^[_a-zA-Z0-9<>, ]+:/m;
+
+export const hasAssemblySymbolsSelector = createSelector(
+  (state: State) => state.output.assembly,
+  asm => !!asm.code?.match(ASSEMBLY_SYMBOLS_RE),
+);
+
 export const themeSelector = createSelector(
   (state: State) => state,
   (state) => state.configuration.theme,