PowerShell, 18 14 bytes

$args#"sgra$"-

Try it online! !enilno ti yrT

First of the trivial comment-abuse answers

J, 3 bytes

-&0

Try it online!

-&0 is "argument minus 0"

0&- is "0 minus argument"

JavaScript, 11 bytes

n=>n//n->=n

Try it Online! | Reversed

x86 machine code, 3 bytes

C3 D8 F7

The above bytes of code define a function that is a no-op: it simply returns control to the caller. That function is followed by two garbage bytes that will not be executed, since they come after a return—they are in "no man's land". In assembler mnemonics:

ret ; C3 
fdiv st(0), st(7) ; D8 F7

Okay, so now some troll comes by and reverses the order of the bytes:

F7 D8 C3

These bytes now define a function that takes an integer argument in the EAX register, negates it, and returns control to the caller. In assembler mnemonics:

neg eax ; F7 D8
ret ; C3

So…that was simple. :-)

Note that we can make the "negation" instruction be anything we want, since it is never executed in the "forward" orientation and only executed in the "reversed" orientation. Therefore, we can follow the same pattern to do arbitrarily more complicated stuff. For example, here we take an integer argument in a different register (say, EDI, to follow the System V calling convention commonly used on *nix systems), negate it, and return it in the conventional EAX register:

C3 ret
D8 F7 fdiv st(0), st(7) ; garbage bytes that
F8 clc ; | never get executed,
89 .byte 0x89 ; / so nobody cares

  ↓ ↓

89 F8 mov eax, edi
F7 D8 neg eax
C3 ret

Jelly, 2 bytes

oN

Try it online! and its reverse.

oN - (input) OR ((input) negated)

No - ((input) negated) OR (input)

Haskell, 8 bytes

Anonymous identity function, turning into subtraction from 0 when reversed.

id--)-0(

Try it online!

Reversed:

(0-)--di

Try it online!

Whitespace, 48 bytes

S S S N
S N
S T N
T T T T T T N
S T N
N
N
T S N
T N
S S T N
T T S S T T T T T N
T S N
S N
S S S 

Letters S (space), T (tab), and N (new-line) added as highlighting only.

Minor modification of my Whitespace answer for the I reverse the source code, you negate the output! challenge.

Try it online or try it online reversed (with raw spaces, tabs and new-lines only).

Explanation:

Utilizing the Exit Program builtin being a short palindrome NNN.

The regular program will:

SSSN # Push 0 to the stack
SNS # Duplicate it
TNTT # Read STDIN as integer, and store it at heap address 0
TTT # Retrieve the input from heap address 0, and push it to the stack
TNST # Pop and print the top of the stack as number
NNN # Exit the program, making everything after it no-ops

The reverse program will:

SSSN # Push 0 to the stack
SNS # Duplicate it
TNTT # Read STDIN as integer, and store it at heap address 0
TTT # Retrieve the input from heap address 0, and push it to the stack
SSTTN # Push -1 to the stack
TSSN # Multiply the top two values on the stack together
TNST # Pop and print the top of the stack as number
NNN # Exit the program, making everything after it no-ops

Small additional explanation of pushing a number:

• First S: Enable Stack Manipulation


• Second S: Push a number to the stack


• 
  S or T: Positive/negative respectively


• Some S/T followed by a trailing N: number in binary, where S=0 and T=1
  

I.e. SSTTSTSN pushes -10. For the 0 we don't need an explicit S=0, so simply SSSN or SSTN is enough.

Perl 6 / Raku, 3 bytes

*-0

Try it online!

Creates a Whatever code block. Read in normally its standard block equivalent is -> x x - 0, but in reverse it becomes -> x 0 - x.

C (clang), 23 bytes

f(*x)//};x*-=x*improve this answer