1 //: Everything this project/binary supports.
  2 //: This should give you a sense for what to look forward to in later layers.
  3 
  4 :(before "End Commandline Parsing")
  5 if (argc <= 1 || is_equal(argv[1], "--help")) {
  6   //: this is the functionality later layers will provide
  7   // currently no automated tests for commandline arg parsing
  8   cerr << get(Help, "usage");
  9   return 0;
 10 }
 11 
 12 //: Support for option parsing.
 13 //: Options always begin with '--' and are always the first arguments. An
 14 //: option will never follow a non-option.
 15 char** arg = &argv[1];
 16 while (argc > 1 && starts_with(*arg, "--")) {
 17   if (false)
 18     ;  // no-op branch just so any further additions can consistently always start with 'else'
 19   // End Commandline Options(*arg)
 20   else
 21     cerr << "skipping unknown option " << *arg << '\n';
 22   --argc;  ++argv;  ++arg;
 23 }
 24 
 25 if (is_equal(argv[1], "help")) {
 26   if (argc == 2) {
 27     cerr << "help on what?\n";
 28     help_contents();
 29     return 0;
 30   }
 31   string key(argv[2]);
 32   // End Help Special-cases(key)
 33   if (contains_key(Help, key)) {
 34     cerr << get(Help, key);
 35     return 0;
 36   }
 37   else {
 38     cerr << "No help found for '" << key << "'\n";
 39     help_contents();
 40     cerr << "Please check your command for typos.\n";
 41     return 1;
 42   }
 43 }
 44 
 45 :(code)
 46 void help_contents() {
 47   cerr << "Available top-level topics:\n";
 48   cerr << "  usage\n";
 49   // End Help Contents
 50 }
 51 
 52 :(before "End Globals")
 53 map<string, string> Help;
 54 :(before "End Includes")
 55 #include <map>
 56 using std::map;
 57 :(before "End One-time Setup")
 58 init_help();
 59 :(code)
 60 void init_help() {
 61   put(Help, "usage",
 62     "Welcome to SubX, a better way to program in machine code.\n"
 63     "SubX uses a subset of the x86 instruction set. SubX programs will run\n"
 64     "without modification on Linux computers.\n"
 65     "It provides a better experience and better error messages than\n"
 66     "programming directly in machine code, but you have to stick to the\n"
 67     "instructions it supports.\n"
 68     "\n"
 69     "== Ways to invoke subx\n"
 70     "- Run tests:\n"
 71     "    subx test\n"
 72     "- See this message:\n"
 73     "    subx --help\n"
 74     "- Convert a textual SubX program into a standard ELF binary that you can\n"
 75     "  run on your computer:\n"
 76     "    subx translate input1.subx input2.subx ... -o <output ELF binary>\n"
 77     "- Run a SubX binary using SubX itself (for better error messages):\n"
 78     "    subx run <ELF binary>\n"
 79     "\n"
 80     "== Debugging aids\n"
 81     "- Add '--trace' to any of these commands to save a trace.\n"
 82     "- Add '--debug' to add information to traces. 'subx --debug translate' will\n"
 83     "  save metadata to disk that 'subx --debug --trace run' uses to make traces\n"
 84     "  more informative.\n"
 85     "\n"
 86     "Options starting with '--' must always come before any other arguments.\n"
 87     "\n"
 88     "To start learning how to write SubX programs, see Readme.md (particularly\n"
 89     "the section on the x86 instruction set) and then run:\n"
 90     "  subx help\n"
 91   );
 92   // End Help Texts
 93 }
 94 
 95 :(code)
 96 bool is_equal(char* s, const char* lit) {
 97   return strncmp(s, lit, strlen(lit)) == 0;
 98 }
 99 
100 bool starts_with(const string& s, const string& pat) {
101   string::const_iterator a=s.begin(), b=pat.begin();
102   for (/*nada*/;  a!=s.end() && b!=pat.end();  ++a, ++b)
103     if (*a != *b) return false;
104   return b == pat.end();
105 }
106 
107 //: I'll throw some style conventions here for want of a better place for them.
108 //: As a rule I hate style guides. Do what you want, that's my motto. But since
109 //: we're dealing with C/C++, the one big thing we want to avoid is undefined
110 //: behavior. If a compiler ever encounters undefined behavior it can make
111 //: your program do anything it wants.
112 //:
113 //: For reference, my checklist of undefined behaviors to watch out for:
114 //:   out-of-bounds access
115 //:   uninitialized variables
116 //:   use after free
117 //:   dereferencing invalid pointers: null, a new of size 0, others
118 //:
119 //:   casting a large number to a type too small to hold it
120 //:
121 //:   integer overflow
122 //:   division by zero and other undefined expressions
123 //:   left-shift by negative count
124 //:   shifting values by more than or equal to the number of bits they contain
125 //:   bitwise operations on signed numbers
126 //:
127 //:   Converting pointers to types of different alignment requirements
128 //:     T* -> void* -> T*: defined
129 //:     T* -> U* -> T*: defined if non-function pointers and alignment requirements are same
130 //:     function pointers may be cast to other function pointers
131 //:
132 //:       Casting a numeric value into a value that can't be represented by the target type (either directly or via static_cast)
133 //:
134 //: To guard against these, some conventions:
135 //:
136 //: 0. Initialize all primitive variables in functions and constructors.
137 //:
138 //: 1. Minimize use of pointers and pointer arithmetic. Avoid 'new' and
139 //: 'delete' as far as possible. Rely on STL to perform memory management to
140 //: avoid use-after-free issues (and memory leaks).
141 //:
142 //: 2. Avoid naked arrays to avoid out-of-bounds access. Never use operator[]
143 //: except with map. Use at() with STL vectors and so on.
144 //:
145 //: 3. Valgrind all the things.
146 //:
147 //: 4. Avoid unsigned numbers. Not strictly an undefined-behavior issue, but
148 //: the extra range doesn't matter, and it's one less confusing category of
149 //: interaction gotchas to worry about.
150 //:
151 //: Corollary: don't use the size() method on containers, since it returns an
152 //: unsigned and that'll cause warnings about mixing signed and unsigned,
153 //: yadda-yadda. Instead use this macro below to perform an unsafe cast to
154 //: signed. We'll just give up immediately if a container's ever too large.
155 //: Basically, Mu is not concerned about this being a little slower than it
156 //: could be. (https://gist.github.com/rygorous/e0f055bfb74e3d5f0af20690759de5a7)
157 //:
158 //: Addendum to corollary: We're going to uniformly use int everywhere, to
159 //: indicate that we're oblivious to number size, and since Clang on 32-bit
160 //: platforms doesn't yet support multiplication over 64-bit integers, and
161 //: since multiplying two integers seems like a more common situation to end
162 //: up in than integer overflow.
163 :(before "End Includes")
164 #define SIZE(X) (assert((X).size() < (1LL<<(sizeof(int)*8-2))), static_cast<int>((X).size()))
165 
166 //: 5. Integer overflow is guarded against at runtime using the -ftrapv flag
167 //: to the compiler, supported by Clang (GCC version only works sometimes:
168 //: http://stackoverflow.com/questions/20851061/how-to-make-gcc-ftrapv-work).
169 :(before "atexit(reset)")
170 initialize_signal_handlers();  // not always necessary, but doesn't hurt
171 //? cerr << INT_MAX+1 << '\n';  // test overflow
172 //? assert(false);  // test SIGABRT
173 :(code)
174 // based on https://spin.atomicobject.com/2013/01/13/exceptions-stack-traces-c
175 void initialize_signal_handlers() {
176   struct sigaction action;
177   bzero(&action, sizeof(action));
178   action.sa_sigaction = dump_and_exit;
179   sigemptyset(&action.sa_mask);
180   sigaction(SIGABRT, &action, NULL);  // assert() failure or integer overflow on linux (with -ftrapv)
181   sigaction(SIGILL,  &action, NULL);  // integer overflow on OS X (with -ftrapv)
182 }
183 void dump_and_exit(int sig, siginfo_t* /*unused*/, void* /*unused*/) {
184   switch (sig) {
185     case SIGABRT:
186       #ifndef __APPLE__
187         cerr << "SIGABRT: might be an integer overflow if it wasn't an assert() failure\n";
188         _Exit(1);
189       #endif
190       break;
191     case SIGILL:
192       #ifdef __APPLE__
193         cerr << "SIGILL: most likely caused by integer overflow\n";
194         _Exit(1);
195       #endif
196       break;
197     default:
198       break;
199   }
200 }
201 :(before "End Includes")
202 #include <signal.h>
203 
204 //: For good measure we'll also enable SIGFPE.
205 :(before "atexit(reset)")
206 feenableexcept(FE_OVERFLOW | FE_UNDERFLOW);
207 //? assert(sizeof(int) == 4 && sizeof(float) == 4);
208 //? //                          | exp   |  mantissa
209 //? int smallest_subnormal = 0b00000000000000000000000000000001;
210 //? float smallest_subnormal_f = *reinterpret_cast<float*>(&smallest_subnormal);
211 //? cerr << "ε: " << smallest_subnormal_f << '\n';
212 //? cerr << "ε/2: " << smallest_subnormal_f/2 << " (underflow)\n";  // test SIGFPE
213 :(before "End Includes")
214 #include <fenv.h>
215 :(code)
216 #ifdef __APPLE__
217 // Public domain polyfill for feenableexcept on OS X
218 // http://www-personal.umich.edu/~williams/archive/computation/fe-handling-example.c
219 int feenableexcept(unsigned int excepts) {
220   static fenv_t fenv;
221   unsigned int new_excepts = excepts & FE_ALL_EXCEPT;
222   unsigned int old_excepts;
223   if (fegetenv(&fenv)) return -1;
224   old_excepts = fenv.__control & FE_ALL_EXCEPT;
225   fenv.__control &= ~new_excepts;
226   fenv.__mxcsr &= ~(new_excepts << 7);
227   return fesetenv(&fenv) ? -1 : old_excepts;
228 }
229 #endif
230 
231 //: 6. Map's operator[] being non-const is fucking evil.
232 :(before "Globals")  // can't generate prototypes for these
233 // from http://stackoverflow.com/questions/152643/idiomatic-c-for-reading-from-a-const-map
234 template<typename T> typename T::mapped_type& get(T& map, typename T::key_type const& key) {
235   typename T::iterator iter(map.find(key));
236   if (iter == map.end()) {
237     cerr << "get couldn't find key '" << key << "'\n";
238     assert(iter != map.end());
239   }
240   return iter->second;
241 }
242 template<typename T> typename T::mapped_type const& get(const T& map, typename T::key_type const& key) {
243   typename T::const_iterator iter(map.find(key));
244   if (iter == map.end()) {
245     cerr << "get couldn't find key '" << key << "'\n";
246     assert(iter != map.end());
247   }
248   return iter->second;
249 }
250 template<typename T> typename T::mapped_type const& put(T& map, typename T::key_type const& key, typename T::mapped_type const& value) {
251   map[key] = value;
252   return map[key];
253 }
254 template<typename T> bool contains_key(T& map, typename T::key_type const& key) {
255   return map.find(key) != map.end();
256 }
257 template<typename T> typename T::mapped_type& get_or_insert(T& map, typename T::key_type const& key) {
258   return map[key];
259 }
260 template<typename T> typename T::mapped_type const& put_new(T& map, typename T::key_type const& key, typename T::mapped_type const& value) {
261   assert(map.find(key) == map.end());
262   map[key] = value;
263   return map[key];
264 }
265 //: The contract: any container that relies on get_or_insert should never call
266 //: contains_key.
267 
268 //: 7. istreams are a royal pain in the arse. You have to be careful about
269 //: what subclass you try to putback into. You have to watch out for the pesky
270 //: failbit and badbit. Just avoid eof() and use this helper instead.
271 :(code)
272 bool has_data(istream& in) {
273   return in && !in.eof();
274 }
275 
276 :(before "End Includes")
277 #include <assert.h>
278 
279 #include <iostream>
280 using std::istream;
281 using std::ostream;
282 using std::iostream;
283 using std::cin;
284 using std::cout;
285 using std::cerr;
286 #include <iomanip>
287 
288 #include <string.h>
289 #include <string>
290 using std::string;
291 
292 #include <algorithm>
293 using std::min;
294 using std::max;