From cb3981e5fcd62578883d6cae68b2d427767a47e7 Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Wed, 13 Nov 2013 09:32:40 +0100
Subject: [PATCH 01/20] automake: don't treat warnings as errors.

---
 configure.ac | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/configure.ac b/configure.ac
index 4a81bb1..4f880af 100644
--- a/configure.ac
+++ b/configure.ac
@@ -6,7 +6,7 @@
 # common initialisation of autotools
 ####
 AC_INIT([SimulAVR], [1.1dev], [simulavr-devel@nongnu.org])
-AM_INIT_AUTOMAKE([1.10 -Wall -Werror foreign])
+AM_INIT_AUTOMAKE([1.10 -Wall foreign])
 AC_PREREQ([2.61])
 AC_CONFIG_MACRO_DIR([m4])
 AM_MAINTAINER_MODE

From 74c903349a322830c795d5916279962f5cabcd8c Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Tue, 19 Nov 2013 19:26:34 +0100
Subject: [PATCH 02/20] src/avrerror.h: fix a number of compilation warnings.

---
 src/avrerror.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/avrerror.h b/src/avrerror.h
index 0a8d7b0..c75ceca 100644
--- a/src/avrerror.h
+++ b/src/avrerror.h
@@ -32,8 +32,12 @@
 #define ATTRIBUTE_NORETURN __declspec(noreturn)
 #define ATTRIBUTE_PRINTF(string_arg, first_arg)
 #elif defined(__GNUC__)
+#ifndef ATTRIBUTE_NORETURN
 #define ATTRIBUTE_NORETURN __attribute__((noreturn))
+#endif
+#ifndef ATTRIBUTE_PRINTF
 #define ATTRIBUTE_PRINTF(string_arg, first_arg) __attribute__ ((format (printf, string_arg, first_arg)))
+#endif
 #else
 #define ATTRIBUTE_NORETURN
 #define ATTRIBUTE_PRINTF(string_arg, first_arg)

From faa97b1137e043c693e6b7290ac9e4185ee50d3d Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Sat, 16 Nov 2013 17:00:57 +0100
Subject: [PATCH 03/20] src/avrerror.cpp: fix MESSAGE handling.

---
 src/avrerror.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/avrerror.cpp b/src/avrerror.cpp
index 1c26b47..2015b85 100644
--- a/src/avrerror.cpp
+++ b/src/avrerror.cpp
@@ -133,9 +133,10 @@ void SystemConsoleHandler::vfmessage(const char *file, int line, const char *fmt
     va_start(ap, fmt);
     vsnprintf(messageStringBuffer, sizeof(messageStringBuffer), mfmt, ap);
     va_end(ap);
-    if(fmt[strlen(fmt) - 1] != '\n')
-        *wrnStream << std::endl;
     *msgStream << messageStringBuffer;
+    if(fmt[strlen(fmt) - 1] != '\n')
+        *msgStream << std::endl;
+    msgStream->flush();
 }
 
 void SystemConsoleHandler::vfwarning(const char *file, int line, const char *fmt, ...) {

From 65957743fdc96b243f9ac7bc4136ced336491b13 Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Sat, 16 Nov 2013 23:10:06 +0100
Subject: [PATCH 04/20] src/avrerror.cpp: simplify plain messages.

---
 src/avrerror.cpp | 8 +++++---
 src/avrerror.h   | 6 +++---
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/avrerror.cpp b/src/avrerror.cpp
index 2015b85..a67d656 100644
--- a/src/avrerror.cpp
+++ b/src/avrerror.cpp
@@ -127,11 +127,13 @@ void SystemConsoleHandler::TraceNextLine(void) {
     }
 }
 
-void SystemConsoleHandler::vfmessage(const char *file, int line, const char *fmt, ...) {
+void SystemConsoleHandler::vfmessage(const char *fmt, ...) {
     va_list ap;
-    char *mfmt = getFormatString("MESSAGE", file, line, fmt);
+    snprintf(formatStringBuffer, sizeof(formatStringBuffer),
+             "MESSAGE %s", fmt);
     va_start(ap, fmt);
-    vsnprintf(messageStringBuffer, sizeof(messageStringBuffer), mfmt, ap);
+    vsnprintf(messageStringBuffer, sizeof(messageStringBuffer),
+              formatStringBuffer, ap);
     va_end(ap);
     *msgStream << messageStringBuffer;
     if(fmt[strlen(fmt) - 1] != '\n')
diff --git a/src/avrerror.h b/src/avrerror.h
index c75ceca..9e752f9 100644
--- a/src/avrerror.h
+++ b/src/avrerror.h
@@ -74,8 +74,8 @@ class SystemConsoleHandler {
         void TraceNextLine(void);
         
         //! Format and send a message to message stream (default stdout)
-        void vfmessage(const char *file, int line, const char *fmt, ...)
-            ATTRIBUTE_PRINTF(4, 5);
+        void vfmessage(const char *fmt, ...)
+            ATTRIBUTE_PRINTF(2, 3);
         //! Format and send a warning message to warning stream (default stderr)
         void vfwarning(const char *file, int line, const char *fmt, ...)
             ATTRIBUTE_PRINTF(4, 5);
@@ -127,7 +127,7 @@ extern int global_verbose_on;
 //! Helper function for writing trace (trace IO access)
 void trioaccess(const char *t, unsigned char val);
 
-#define avr_message(fmt, ...) sysConHandler.vfmessage(__FILE__, __LINE__, fmt, ## __VA_ARGS__)
+#define avr_message(fmt, ...) sysConHandler.vfmessage(fmt, ## __VA_ARGS__)
 #define avr_warning(fmt, ...) sysConHandler.vfwarning(__FILE__, __LINE__, fmt, ## __VA_ARGS__)
 #define avr_failure(fmt, ...) sysConHandler.vferror(__FILE__, __LINE__, fmt, ## __VA_ARGS__)
 #define avr_error(fmt, ...)   sysConHandler.vffatal(__FILE__, __LINE__, fmt, ## __VA_ARGS__)

From 179be746c0a228b571b89a29d3adcd72291afebe Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Sat, 16 Nov 2013 23:37:37 +0100
Subject: [PATCH 05/20] Use avr_message() for verbose messages.

This enhances encapsulation and simplifies code, both of which are
generally considered to be a good thing.
---
 src/avrdevice.cpp |  3 +--
 src/avrerror.cpp  |  3 +++
 src/cmd/main.cpp  | 50 ++++++++++++++++-------------------------------
 src/hwstack.cpp   |  3 +--
 4 files changed, 22 insertions(+), 37 deletions(-)

diff --git a/src/avrdevice.cpp b/src/avrdevice.cpp
index 37b236d..aff75a7 100644
--- a/src/avrdevice.cpp
+++ b/src/avrdevice.cpp
@@ -275,8 +275,7 @@ int AvrDevice::Step(bool &untilCoreStepFinished, SystemClockOffset *nextStepIn_n
             }
 
             if(EP.end() != find(EP.begin(), EP.end(), PC)) {
-                if(global_verbose_on)
-                    cout << "Simulation finished!" << endl;
+                avr_message("Simulation finished!");
                 SystemClock::Instance().stop();
                 dump_manager->cycle();
                 return 0;
diff --git a/src/avrerror.cpp b/src/avrerror.cpp
index a67d656..4156160 100644
--- a/src/avrerror.cpp
+++ b/src/avrerror.cpp
@@ -128,6 +128,9 @@ void SystemConsoleHandler::TraceNextLine(void) {
 }
 
 void SystemConsoleHandler::vfmessage(const char *fmt, ...) {
+    if ( ! global_verbose_on)
+        return;
+
     va_list ap;
     snprintf(formatStringBuffer, sizeof(formatStringBuffer),
              "MESSAGE %s", fmt);
diff --git a/src/cmd/main.cpp b/src/cmd/main.cpp
index a4dca69..9c7ce5b 100644
--- a/src/cmd/main.cpp
+++ b/src/cmd/main.cpp
@@ -257,37 +257,31 @@ int main(int argc, char *argv[]) {
                     cerr << "maxRunTime is zero" << endl;
                     exit(1);
                 }
-                if(global_verbose_on)
-                    cout << "Maximum Run Time: " << maxRunTime << endl;
+                avr_message("Maximum Run Time: %lld", maxRunTime);
                 break;
             
             case 'u':
-                if(global_verbose_on)
-                    cout << "Run with User Interface at Port 7777" << endl;
+                avr_message("Run with User Interface at Port 7777");
                 userinterface_flag = 1;
                 break;
             
             case 'f':
-                if(global_verbose_on)
-                    cout << "File to load: " << optarg << endl;
+                avr_message("File to load: %s", optarg);
                 filename = optarg;
                 break;
             
             case 'd':
-                if(global_verbose_on)
-                    cout << "Device to simulate: " << optarg << endl;
+                avr_message("Device to simulate: %s", optarg);
                 devicename = optarg;
                 break;
             
             case 'g':
-                if(global_verbose_on)
-                    cout << "Running as gdb-server" << endl;
+                avr_message("Running as gdb-server");
                 gdbserver_flag = 1;
                 break;
             
             case 'G':
-                if(global_verbose_on)
-                    cout << "Running with debug information from gdbserver" << endl;
+                avr_message("Running with debug information from gdbserver");
                 global_gdb_debug = 1;
                 gdbserver_flag = 1;
                 break;
@@ -297,13 +291,12 @@ int main(int argc, char *argv[]) {
                     cerr << "GDB Server Port is not a number" << endl;
                     exit(1);
                 }
-                if(global_verbose_on)
-                    cout << "Running on port: " << optarg << endl;
+                avr_message("Running on port: %ld", global_gdbserver_port);
                 break;
             
             case 't':
-                if(global_verbose_on)
-                    cout << "Running in Trace Mode with maximum " << linestotrace << " lines per file" << endl;
+                avr_message("Running in Trace Mode with maximum %lld lines per file",
+                            linestotrace);
 
                 sysConHandler.SetTraceFile(optarg, linestotrace);
                 break;
@@ -395,33 +388,26 @@ int main(int argc, char *argv[]) {
     
     //if we want to insert some special "pipe" Registers we could do this here:
     if(readFromPipeFileName != "") {
-        if(global_verbose_on)
-            cout << "Add ReadFromPipe-Register at 0x"
-                 << hex << readFromPipeOffset
-                 << " and read from file: " << readFromPipeFileName << endl;
+        avr_message("Add ReadFromPipe-Register at 0x%lx and read from file: %s",
+                    readFromPipeOffset, readFromPipeFileName.c_str());
         dev1->ReplaceIoRegister(readFromPipeOffset,
             new RWReadFromFile(dev1, "FREAD", readFromPipeFileName.c_str()));
     }
     
     if(writeToPipeFileName != "") {
-        if(global_verbose_on)
-            cout << "Add WriteToPipe-Register at 0x"
-                 << hex << writeToPipeOffset
-                 << " and write to file: " << writeToPipeFileName << endl;
+        avr_message("Add WriteToPipe-Register at 0x%lx and write to file: %s",
+                    writeToPipeOffset, writeToPipeFileName.c_str());
         dev1->ReplaceIoRegister(writeToPipeOffset,
             new RWWriteToFile(dev1, "FWRITE", writeToPipeFileName.c_str()));
     }
     
     if(writeToAbort) {
-        if(global_verbose_on)
-            cout << "Add WriteToAbort-Register at 0x" << hex
-                 << writeToAbort << endl;
+        avr_message("Add WriteToAbort-Register at 0x%lx", writeToAbort);
         dev1->ReplaceIoRegister(writeToAbort, new RWAbort(dev1, "ABORT"));
     }
     
     if(writeToExit) {
-        if(global_verbose_on)
-            cout << "Add WriteToExit-Register at 0x" << hex << writeToExit << endl;
+        avr_message("Add WriteToExit-Register at 0x%lx", writeToExit);
         dev1->ReplaceIoRegister(writeToExit, new RWExit(dev1, "EXIT"));
     }
     
@@ -433,8 +419,7 @@ int main(int argc, char *argv[]) {
     //if we have a file we can check out for termination lines.
     vector<string>::iterator ii;
     for(ii = terminationArgs.begin(); ii != terminationArgs.end(); ii++) {
-        if(global_verbose_on)
-            cout << "Termination or Breakpoint Symbol: " << *ii << endl;
+        avr_message("Termination or Breakpoint Symbol: %s", (*ii).c_str());
         dev1->RegisterTerminationSymbol((*ii).c_str());
     }
     
@@ -456,8 +441,7 @@ int main(int argc, char *argv[]) {
             SystemClock::Instance().Run(maxRunTime);
         }
     } else { // gdb should be activated
-        if(global_verbose_on)
-            cout << "Going to gdb..." << endl;
+        avr_message("Going to gdb...");
         GdbServer gdb1(dev1, global_gdbserver_port, global_gdb_debug, globalWaitForGdbConnection);
         SystemClock::Instance().Add(&gdb1);
         SystemClock::Instance().Endless();
diff --git a/src/hwstack.cpp b/src/hwstack.cpp
index c28bf17..e08b990 100644
--- a/src/hwstack.cpp
+++ b/src/hwstack.cpp
@@ -322,8 +322,7 @@ void ThreadList::OnPop()
 	new_thread->m_ip = 0x0000;
 	new_thread->m_alive = true;
 
-    if(global_verbose_on)
-        fprintf(stderr, "Context switch at PC 0x%05x from thread %d to %d\n", addr, m_cur_thread, n);
+    avr_message("Context switch at PC 0x%05x from thread %d to %d\n", addr, m_cur_thread, n);
     m_cur_thread = n;
 }
 

From 4f6fa7c9406c2dd8595e933e8f6294c5e23f85cf Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Sat, 16 Nov 2013 22:32:56 +0100
Subject: [PATCH 06/20] Swap -v and -V command line parameters.

About every tool on this planet uses a lowercase v for "verbose",
do it here, too.
---
 doc/mdate-sh      |  2 +-
 doc/simulavr.texi |  4 ++--
 doc/usage.rst     |  4 ++--
 src/cmd/main.cpp  | 12 ++++++------
 4 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/doc/mdate-sh b/doc/mdate-sh
index 83d2700..c3dfb1b 100755
--- a/doc/mdate-sh
+++ b/doc/mdate-sh
@@ -45,7 +45,7 @@ Report bugs to <bug-automake@gnu.org>.
 EOF
     exit $?
     ;;
-  -v | --v*)
+  -V | --v*)
     echo "mdate-sh $scriptversion"
     exit $?
     ;;
diff --git a/doc/simulavr.texi b/doc/simulavr.texi
index 5f95962..117941b 100644
--- a/doc/simulavr.texi
+++ b/doc/simulavr.texi
@@ -179,9 +179,9 @@ no matter if it is ever reached or not.
 run with user interface for external pin handling at port 7777. This
 does not open any graphics but activates the interface to communicate
 with the environment simulation.
-@item -v --version
+@item -V --version
 show the software version of simulavr
-@item -V --verbose
+@item -v --verbose
 output some hints to console
 @item -W --writetopipe <offset>,<file>
 add a special pipe register to device at IO-Offset and opens <file> for writing
diff --git a/doc/usage.rst b/doc/usage.rst
index b7b7aef..a9bc38f 100644
--- a/doc/usage.rst
+++ b/doc/usage.rst
@@ -8,10 +8,10 @@ Invoke simulavr::
 Common options
 --------------
 
-``-v, --version``
+``-V, --version``
   show the software version of simulavr
   
-``-V, --verbose``
+``-v, --verbose``
   output some hints to console
   
 ``-h, --help``
diff --git a/src/cmd/main.cpp b/src/cmd/main.cpp
index 9c7ce5b..ca60731 100644
--- a/src/cmd/main.cpp
+++ b/src/cmd/main.cpp
@@ -120,7 +120,7 @@ const char Usage[] =
     "-e --writetoexit <offset>\n"
     "                      add a special register at IO-offset\n"
     "                      which exits simulator run\n"
-    "-V --verbose          output some hints to console\n"
+    "-v --verbose          output some hints to console\n"
     "-T --terminate <label> or <address>\n"
     "                      stops simulation if PC runs on <label> or <address>\n"
     "-B --breakpoint <label> or <address>\n"
@@ -130,7 +130,7 @@ const char Usage[] =
     "                      <tracer>[:further-options ...]\n"
     "-o <trace-value-file> Specifies a file into which all available trace value names\n"
     "                      will be written.\n"
-    "-v --version          print out version and exit immediately\n"
+    "-V --version          print out version and exit immediately\n"
     "-h --help             print this help\n"
     "\n";
 
@@ -175,13 +175,13 @@ int main(int argc, char *argv[]) {
             {"maxruntime", 1, 0, 'm'},
             {"nogdbwait", 0, 0, 'n'},
             {"trace", 1, 0, 't'},
-            {"version", 0, 0, 'v'},
+            {"version", 0, 0, 'V'},
             {"cpufrequency", 1, 0, 'F'},
             {"readfrompipe", 1, 0, 'R'},
             {"writetopipe", 1, 0, 'W'},
             {"writetoabort", 1, 0, 'a'},
             {"writetoexit", 1, 0, 'e'},
-            {"verbose", 0, 0, 'V'},
+            {"verbose", 0, 0, 'v'},
             {"terminate", 1, 0, 'T'},
             {"breakpoint", 1, 0, 'B'},
             {"irqstatistic", 0, 0, 's'},
@@ -199,7 +199,7 @@ int main(int argc, char *argv[]) {
                 terminationArgs.push_back(optarg);
                 break;
             
-            case 'V':
+            case 'v':
                 global_verbose_on = 1;
                 break;
             
@@ -301,7 +301,7 @@ int main(int argc, char *argv[]) {
                 sysConHandler.SetTraceFile(optarg, linestotrace);
                 break;
             
-            case 'v':
+            case 'V':
                 cout << "SimulAVR " << VERSION << endl
                      << "See documentation for copyright and distribution terms" << endl
                      << endl;

From e06733f0d66c2c2b360d64033f26bc4255c35fbf Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Thu, 14 Nov 2013 01:09:44 +0100
Subject: [PATCH 07/20] Update examples/stdiodemo/README.

---
 examples/stdiodemo/README | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/examples/stdiodemo/README b/examples/stdiodemo/README
index 6fcce03..820c258 100644
--- a/examples/stdiodemo/README
+++ b/examples/stdiodemo/README
@@ -4,15 +4,11 @@
 
 Author: Knut Schwichtenberg <kschwi@web.de>
 
+Build the example (after configuring and building in the main directory):
 
-Joel Sherrill Notes
-===================
+  make
 
-3 March 2009
-Temporarily, the Makefile.am is a real Makefile. The rest of the
-contents of this directory appear to work with the autotools
-tree but the Makefile Knut provided has not yet been converted to
-a Makefile.am properly. Until this is complete
+Run the example:
+
+  ../../src/simulavr -d atmega128 --file stdiodemo.elf
 
-make -f Makefile.notauto 
-make -f Makefile.notauto clean

From 9a6eac73b344730c90b2ad955c0cd6bc046bcf0a Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Fri, 15 Nov 2013 15:44:57 +0100
Subject: [PATCH 08/20] Add yet another example, simple_serial.

This example is extremely simple, it does nothing fancy, breath taking
or showing advanced coding skills. It also depends on neither TCL nor
Python. It's purpose is to exercise the UART serial port and to show
how to make this port available in a simulation _without_ altering the
binary.

The code is tested on real hardware already and works just as expected.
---
 configure.ac                       |   1 +
 examples/Makefile.am               |   2 +-
 examples/simple_serial/.gitignore  |   3 +
 examples/simple_serial/Makefile.am |  42 +++++++
 examples/simple_serial/README      |  48 +++++++
 examples/simple_serial/main.c      |  56 +++++++++
 examples/simple_serial/serial.c    | 193 +++++++++++++++++++++++++++++
 examples/simple_serial/serial.h    |  47 +++++++
 8 files changed, 391 insertions(+), 1 deletion(-)
 create mode 100644 examples/simple_serial/.gitignore
 create mode 100644 examples/simple_serial/Makefile.am
 create mode 100644 examples/simple_serial/README
 create mode 100644 examples/simple_serial/main.c
 create mode 100644 examples/simple_serial/serial.c
 create mode 100644 examples/simple_serial/serial.h

diff --git a/configure.ac b/configure.ac
index 4f880af..03950c6 100644
--- a/configure.ac
+++ b/configure.ac
@@ -215,6 +215,7 @@ AC_CONFIG_FILES([
   examples/atmega48/Makefile examples/atmega128_timer/Makefile
   examples/atmel_key/Makefile examples/feedback/Makefile examples/simple_ex1/Makefile
   examples/spi/Makefile examples/stdiodemo/Makefile examples/python/Makefile
+  examples/simple_serial/Makefile
 ])
 
 ## Certain files should only be generated if Tcl is available and enabled
diff --git a/examples/Makefile.am b/examples/Makefile.am
index 556cb18..f98a40c 100644
--- a/examples/Makefile.am
+++ b/examples/Makefile.am
@@ -5,7 +5,7 @@
 
 examplesdir = $(docdir)/examples
 
-SUBDIRS = simple_ex1
+SUBDIRS = simple_ex1 simple_serial
 if USE_TCL
 SUBDIRS += anacomp atmega48 spi stdiodemo feedback atmega128_timer atmel_key
 endif
diff --git a/examples/simple_serial/.gitignore b/examples/simple_serial/.gitignore
new file mode 100644
index 0000000..fde070e
--- /dev/null
+++ b/examples/simple_serial/.gitignore
@@ -0,0 +1,3 @@
+*.elf
+*.hex
+
diff --git a/examples/simple_serial/Makefile.am b/examples/simple_serial/Makefile.am
new file mode 100644
index 0000000..bebf7a7
--- /dev/null
+++ b/examples/simple_serial/Makefile.am
@@ -0,0 +1,42 @@
+#
+#  $Id$
+#
+
+examplesdir = $(docdir)/examples/simple_serial
+
+EXAMPLE = simple_serial
+
+AVR_GCC = @AVR_GCC@
+AVR_CPU = atmega644
+AVR_FREQUENCY = 20000000
+AVR_CFLAGS = -g -O2 -mmcu=$(AVR_CPU) -DF_CPU=$(AVR_FREQUENCY)
+AVR_OBJS = main.o serial.o
+SIMULAVR_ARGS = -d $(AVR_CPU) -f $(EXAMPLE).elf
+
+EXTRA_DIST = main.c serial.c serial.h
+
+examples_DATA = $(EXAMPLE).hex $(EXAMPLE).elf $(EXTRA_DIST) README
+
+CLEANFILES = $(EXAMPLE).hex $(EXAMPLE).elf $(AVR_OBJS)
+
+
+do: $(EXAMPLE).elf
+	../../src/simulavr $(SIMULAVR_ARGS)
+
+program: $(EXAMPLE).hex
+	avrdude -c stk500v2 -b 115200 -p $(AVR_CPU) -P $(SERIAL_AVR) \
+	-U flash:w:$<
+
+
+$(EXAMPLE).hex: $(EXAMPLE).elf
+	avr-objcopy -j .text -j .data -O ihex -R .eeprom -R .fuse -R .lock $< $@
+
+$(EXAMPLE).elf: $(AVR_OBJS)
+	$(AVR_GCC) $(AVR_CFLAGS) -o $@ $^
+
+main.o: $(srcdir)/main.c
+	$(AVR_GCC) $(AVR_CFLAGS) -c -o $@ $<
+
+serial.o: $(srcdir)/serial.c  $(srcdir)/serial.h
+	$(AVR_GCC) $(AVR_CFLAGS) -c -o $@ $<
+
diff --git a/examples/simple_serial/README b/examples/simple_serial/README
new file mode 100644
index 0000000..9456914
--- /dev/null
+++ b/examples/simple_serial/README
@@ -0,0 +1,48 @@
+#
+#  $Id$
+#
+#
+# Copyright (C) 2013 Markus Hitter <mah@jump-ing.de>
+
+
+This example illustrates how one can communicate with the simulated AVR
+using its USART. The other end of the communications line is stdin/stdout,
+so you can simply interact with the simulated AVR by typing into the
+terminal you used to start it with.
+
+The firmware provided can be uploaded to real hardware as-is and should do
+just the same when accessed through a serial terminal. This is an important
+point, because in main.c you can see how few tweaks to the original code
+are required to allow interacting with a simulated run. All of these tweaks
+don't alter the binary actually executed at all.
+
+Building and running the example:
+
+ - Have SimulAVR built, default configuration options are fine.
+
+ - Go to examples/simple_serial (here).
+
+ - Build the example:
+
+      make
+
+ - Run the example:
+
+      make do
+
+ - Upload the example to and run it on real hardware (this isn't exactly
+   flexible, yet, it might require some tweaks to the Makefile to match
+   /your/ hardware):
+
+      export SERIAL_AVR=/dev/<your device here>
+      make program
+      gtkterm -p $SERIAL_AVR -s 19200
+
+Interaction:
+
+Well, extremely simple. It's a code example, after all. Type characters and
+the characters will be sent back with some extra text. That's all, I hope
+this fuels your imagination.
+
+
+
diff --git a/examples/simple_serial/main.c b/examples/simple_serial/main.c
new file mode 100644
index 0000000..4b3c092
--- /dev/null
+++ b/examples/simple_serial/main.c
@@ -0,0 +1,56 @@
+ /*
+ ****************************************************************************
+ *
+ * simple_serial - A demo for the SimulAVR simulator.
+ * Copyright (C) 2013 Markus Hitter <mah@jump-ing.de>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ ****************************************************************************
+ *
+ *  $Id$
+ *
+ * Super trivial example exercising the UART serial communications line.
+ *
+ * It's purpose is to show how SimulAVR can redirect serial communications
+ * in a way useful for running in a simulator, while requiring NO code
+ * modifications which would change it's behaviour compared to running
+ * on real hardware or disallowing to run the very same compiled binary
+ * on that hardware. The compiled binary should work in the simulator just
+ * as fine as on hardware.
+ */
+
+#include "serial.h"
+
+#include <avr/interrupt.h>
+
+
+// This is all we need:
+int main (void) {
+
+  serial_init();
+  sei();
+
+  serial_writestr_P(PSTR("Hello, world!\n\nNow, please type:\n"));
+
+  for (;;) {
+    if (serial_rxchars() != 0) {
+      uint8_t c = serial_popchar();
+      serial_writestr_P(PSTR("received: <"));
+      serial_writechar(c);
+      serial_writestr_P(PSTR(">\n"));
+    }
+  }
+}
diff --git a/examples/simple_serial/serial.c b/examples/simple_serial/serial.c
new file mode 100644
index 0000000..0c9724c
--- /dev/null
+++ b/examples/simple_serial/serial.c
@@ -0,0 +1,193 @@
+/*
+ *  $Id$
+ *
+ * Serial subsystem
+ *
+ * Copyright (C) 2009 Michael Moon <triffid.hunter@gmail.com>
+ *               2010 Markus Hitter <mah@jump-ing.de>
+ *
+ * This is a pretty lean, fast and powerful serial subsystem, taken from
+ * RepRaps' Teacup firmware: https://github.com/Traumflug/Teacup_Firmware .
+ * For even more simplification, support for XON/XOFF flow control was stripped.
+ *
+ * The system uses ringbuffers for both transmit and receive, and
+ * intelligently decides whether to wait or drop transmitted characters if
+ * the buffer is full. It's tested on many versions of the ATmega.
+ */
+#include "serial.h"
+
+#include <avr/interrupt.h>
+
+// Baud rate.
+#define BAUD 19200
+
+// Size of TX and RX buffers. MUST be a power of 2 and 256 or less.
+#define BUFSIZE 64
+
+// rx buffer head pointer. Points to next available space.
+volatile uint8_t rxhead = 0;
+// rx buffer tail pointer. Points to last character in buffer.
+volatile uint8_t rxtail = 0;
+// rx buffer
+volatile uint8_t rxbuf[BUFSIZE];
+
+// tx buffer head pointer. Points to next available space.
+volatile uint8_t txhead = 0;
+// tx buffer tail pointer. Points to last character in buffer.
+volatile uint8_t txtail = 0;
+// tx buffer
+volatile uint8_t txbuf[BUFSIZE];
+
+// check if we can read from this buffer
+#define buf_canread(buffer) ((buffer ## head - buffer ## tail) & (BUFSIZE - 1))
+// read from buffer
+#define buf_pop(buffer, data) do { data = buffer ## buf[buffer ## tail]; buffer ## tail = (buffer ## tail + 1) & (BUFSIZE - 1); } while (0)
+
+// check if we can write to this buffer
+#define buf_canwrite(buffer) ((buffer ## tail - buffer ## head - 1) & (BUFSIZE - 1))
+// write to buffer
+#define buf_push(buffer, data) do { buffer ## buf[buffer ## head] = data; buffer ## head = (buffer ## head + 1) & (BUFSIZE - 1); } while (0)
+
+/*
+ * ringbuffer logic:
+ * head = written data pointer
+ * tail = read data pointer
+ *
+ * when head == tail, buffer is empty
+ * when head + 1 == tail, buffer is full
+ * thus, number of available spaces in buffer is (tail - head) & bufsize
+ *
+ * can write:
+ * (tail - head - 1) & (BUFSIZE - 1)
+ *
+ * write to buffer:
+ * buf[head++] = data; head &= (BUFSIZE - 1);
+ *
+ * can read:
+ * (head - tail) & (BUFSIZE - 1)
+ *
+ * read from buffer:
+ * data = buf[tail++]; tail &= (BUFSIZE - 1);
+ */
+
+// initialise serial subsystem
+void serial_init() {
+  // set up baud generator and interrupts, clear buffers
+
+  #if BAUD > 38401
+    UCSR0A = MASK(U2X0);
+    UBRR0 = (((F_CPU / 8) / BAUD) - 0.5);
+  #else
+    UCSR0A = 0;
+    UBRR0 = (((F_CPU / 16) / BAUD) - 0.5);
+  #endif
+
+  UCSR0B = MASK(RXEN0) | MASK(TXEN0);
+  UCSR0C = MASK(UCSZ01) | MASK(UCSZ00);
+
+  UCSR0B |= MASK(RXCIE0) | MASK(UDRIE0);
+}
+
+// receive interrupt
+// Using the pragma inside the function is incompatible with Arduinos' gcc.
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#ifdef  USART_RX_vect
+ISR(USART_RX_vect) {
+#else
+ISR(USART0_RX_vect) {
+#endif
+  // we have received a character, stuff it in the rx buffer
+  // if we can, or drop it if we can't
+  if (buf_canwrite(rx))
+    buf_push(rx, UDR0);
+  else {
+    // Not reading the character makes the interrupt logic to swamp us with
+    // retries, so better read it and throw it away.
+    // #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+    uint8_t trash;
+    // #pragma GCC diagnostic pop
+
+    trash = UDR0;
+  }
+}
+#pragma GCC diagnostic pop
+
+// transmit buffer ready interrupt
+#ifdef  USART_UDRE_vect
+ISR(USART_UDRE_vect) {
+#else
+ISR(USART0_UDRE_vect) {
+#endif
+  // provide the next character to transmit if we can,
+  // otherwise disable this interrupt
+  if (buf_canread(tx))
+    buf_pop(tx, UDR0);
+  else
+    UCSR0B &= ~MASK(UDRIE0);
+}
+
+// check how many characters can be read
+uint8_t serial_rxchars() {
+  return buf_canread(rx);
+}
+
+// read one character
+uint8_t serial_popchar() {
+  uint8_t c = 0;
+
+  // it's imperative that we check, because if the buffer is empty
+  // and we pop, we'll go through the whole buffer again
+  if (buf_canread(rx))
+    buf_pop(rx, c);
+
+  return c;
+}
+
+// send one character
+void serial_writechar(uint8_t data) {
+  // check if interrupts are enabled
+  if (SREG & MASK(SREG_I)) {
+    // if they are, we should be ok to block since the
+    // tx buffer is emptied from an interrupt
+    for ( ; buf_canwrite(tx) == 0; );
+    buf_push(tx, data);
+  }
+  else {
+    // interrupts are disabled- maybe we're in one?
+    // anyway, instead of blocking, only write if we have room
+    if (buf_canwrite(tx))
+      buf_push(tx, data);
+  }
+  // enable TX interrupt so we can send this character
+  UCSR0B |= MASK(UDRIE0);
+}
+
+// send a string
+void serial_writestr(uint8_t *data) {
+  uint8_t i = 0, r;
+
+  // Yes, this is *supposed* to be assignment rather than comparison, so we
+  // break when r is assigned zero.
+  while ((r = data[i++]))
+    serial_writechar(r);
+}
+
+/*
+ * Write from FLASH
+ *
+ * Extensions to output flash memory pointers. This prevents the data to
+ * become part of the .data segment instead of the .code segment. That means
+ * less memory is consumed for multi-character writes.
+ *
+ * For single character writes (i.e. '\n' instead of "\n"), using
+ * serial_writechar() directly is the better choice.
+*/
+void serial_writestr_P(PGM_P data) {
+  uint8_t r, i = 0;
+
+  // Yes, this is *supposed* to be assignment rather than comparison, so we
+  // break when r is assigned zero.
+  while ((r = pgm_read_byte(&data[i++])))
+    serial_writechar(r);
+}
+
diff --git a/examples/simple_serial/serial.h b/examples/simple_serial/serial.h
new file mode 100644
index 0000000..0b980e5
--- /dev/null
+++ b/examples/simple_serial/serial.h
@@ -0,0 +1,47 @@
+/*
+ *  $Id$
+ *
+ * Serial subsystem
+ *
+ * Copyright (C) 2009 Michael Moon <triffid.hunter@gmail.com>
+ *               2010 Markus Hitter <mah@jump-ing.de>
+ *
+ * This is a pretty lean, fast and powerful serial subsystem, taken from
+ * RepRaps' Teacup firmware: https://github.com/Traumflug/Teacup_Firmware .
+ * For even more simplification, support for XON/XOFF flow control was stripped.
+ *
+ * The system uses ringbuffers for both transmit and receive, and
+ * intelligently decides whether to wait or drop transmitted characters if
+ * the buffer is full. It's tested on many versions of the ATmega.
+ */
+
+#ifndef _SERIAL_H
+#define _SERIAL_H
+
+#include <stdint.h>
+#include <avr/io.h>
+#include <avr/pgmspace.h>
+
+#define MASK(PIN) (1 << PIN)
+
+// initialise serial subsystem
+void serial_init(void);
+
+// return number of characters in the receive buffer,
+// and number of spaces in the send buffer
+uint8_t serial_rxchars(void);
+
+// read one character
+uint8_t serial_popchar(void);
+
+// send one character
+void serial_writechar(uint8_t data);
+
+// read/write many characters
+void serial_writestr(uint8_t *data);
+
+// write from flash
+void serial_writestr_P(PGM_P data);
+
+#endif  /* _SERIAL_H */
+

From 63a9c705bfac21678d331aa2da2b6bd6312d1dca Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Fri, 15 Nov 2013 22:44:07 +0100
Subject: [PATCH 09/20] Allow to store simulation parameters inside the ELF
 file.

For now this is a proof of concept. Storing parameters works fine,
reading them back, too, but instead of being used, they're simple
written to the console. For now the parameters are device type and
cpu frequency, but the concept can be extended easily to all other
command line parameters.

The proof is applied to the simple_serial example.

The point of this strategy is to avoid the neccessity to run
simulavr with more command line parameters than just the name of
the ELF file. At compilation time we know best for which device
we compile, after all.
---
 examples/simple_serial/Makefile.am |   1 +
 examples/simple_serial/main.c      |  20 ++++++
 src/avrreadelf.cpp                 |  49 ++++++++++++-
 src/simulavr_info.h                | 112 +++++++++++++++++++++++++++++
 4 files changed, 180 insertions(+), 2 deletions(-)
 create mode 100644 src/simulavr_info.h

diff --git a/examples/simple_serial/Makefile.am b/examples/simple_serial/Makefile.am
index bebf7a7..75158dc 100644
--- a/examples/simple_serial/Makefile.am
+++ b/examples/simple_serial/Makefile.am
@@ -10,6 +10,7 @@ AVR_GCC = @AVR_GCC@
 AVR_CPU = atmega644
 AVR_FREQUENCY = 20000000
 AVR_CFLAGS = -g -O2 -mmcu=$(AVR_CPU) -DF_CPU=$(AVR_FREQUENCY)
+AVR_CFLAGS += -Wl,--section-start=.siminfo=0x900000
 AVR_OBJS = main.o serial.o
 SIMULAVR_ARGS = -d $(AVR_CPU) -f $(EXAMPLE).elf
 
diff --git a/examples/simple_serial/main.c b/examples/simple_serial/main.c
index 4b3c092..44dd2ed 100644
--- a/examples/simple_serial/main.c
+++ b/examples/simple_serial/main.c
@@ -36,6 +36,26 @@
 
 #include <avr/interrupt.h>
 
+/*
+ * Here we tell SimulAVR for which device and which frequency we build this
+ * code. The nice thing is, these macros add a section to the ELF file, so
+ * they can be read by SimulAVR, but they're also ignored when converted to
+ * an ihex file for hardware upload. Accordingly, the executed binary for
+ * SimulAVR and real hardware is the same, no need to recompile for one or
+ * another. The more important result of this is, behaviour is also exactly
+ * the same, no extra cycles for serving simulator matters.
+ *
+ * One small caveat: To stop the linker from stripping this section, avr-gcc
+ * needs an extra parameter when linking the binary (see Makefile.am):
+ *
+ *   -Wl,--section-start=.siminfo=0x900000
+ *
+ * For details on these macros, see the comments in simulavr_info.h.
+ */
+#include "../../src/simulavr_info.h"
+SIMINFO_DEVICE("atmega644");
+SIMINFO_CPUFREQUENCY(F_CPU);
+
 
 // This is all we need:
 int main (void) {
diff --git a/src/avrreadelf.cpp b/src/avrreadelf.cpp
index 2828bdc..d5d1a09 100644
--- a/src/avrreadelf.cpp
+++ b/src/avrreadelf.cpp
@@ -30,9 +30,11 @@
 #endif
 
 #include <string>
+#include <cstring>
 #include <map>
 
 #include "avrdevice_impl.h"
+#include "simulavr_info.h"
 
 #include "avrreadelf.h"
 
@@ -193,7 +195,9 @@ void ELFLoad(const AvrDevice * core) {
             } else if(vma >= 0x840000 && vma < 0x840400) {
                 /* signature space starting from 0x840000, do nothing */;
             } else
-                avr_warning("Unknown symbol address range found! (symbol='%s', address=0x%x)", symbol_table[i]->name, vma);
+                if ( ! strcmp(symbol_table[i]->name, ".siminfo") &&
+                     ! strcmp(symbol_table[i]->name, "siminfo"))
+                    avr_warning("Unknown symbol address range found! (symbol='%s', address=0x%x)", symbol_table[i]->name, vma);
         }
         free(symbol_table);
     } else
@@ -203,7 +207,7 @@ void ELFLoad(const AvrDevice * core) {
     sec = abfd->sections;
     while(sec != 0) {
         // only loadable sections
-        if(sec->flags & SEC_LOAD) {
+        if(sec->flags & SEC_LOAD && strcmp(sec->name, ".siminfo")) {
             int size;
             size = sec->size;
 
@@ -247,6 +251,47 @@ void ELFLoad(const AvrDevice * core) {
             // free allocated space
             free(tmp);
         }
+        else if ( ! strcmp(sec->name, ".siminfo")) {
+          avr_warning(".siminfo section found!");
+          /*
+           * You wonder why the .siminfo section is read here, while this
+           * stuff also shows up as symbols, which are read above already?
+           * Well, doing things this way is pretty independent from ELF
+           * internals, other than finding the .siminfo section start pointer.
+           * Accordingly, we can add pretty much anything, as long as the
+           * interpretation here matches what's given in simulavr_info.h.
+           */
+          int size = sec->size;
+          unsigned char *data, *data_ptr, *data_end;
+
+          data = (unsigned char *)malloc(size);
+          if (data == NULL)
+            break;
+          bfd_get_section_contents(abfd, sec, data, 0, size);
+
+          data_ptr = data;
+          data_end = data + size;
+          while (data_ptr < data_end) {
+            char tag = *data_ptr++;
+            switch (tag) {
+              case SIMINFO_TAG_DEVICE:
+                avr_warning("device is %s", data_ptr);
+                while (*data_ptr != '\0')
+                  data_ptr++;
+                data_ptr++; // the '\0' its self
+                break;
+              case SIMINFO_TAG_CPUFREQUENCY:
+                avr_warning("frequency is %u", *(uint32_t *)data_ptr);
+                data_ptr += sizeof(uint32_t);
+                break;
+              default:
+                avr_warning("Unknown tag in ELF .siminfo section: %hu", tag);
+                data_ptr++;
+            }
+          }
+          free(data);
+        }
+
 
         sec = sec->next;
     }
diff --git a/src/simulavr_info.h b/src/simulavr_info.h
new file mode 100644
index 0000000..51def63
--- /dev/null
+++ b/src/simulavr_info.h
@@ -0,0 +1,112 @@
+/*
+ ****************************************************************************
+ *
+ * simulavr - A simulator for the Atmel AVR family of microcontrollers.
+ * Copyright (C) 2013 Markus Hitter <mah@jump-ing.de>
+ * ELF storage strategy inspired by simavr by Michel Pollet.
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ ****************************************************************************
+ *
+ *   $Id$
+ *
+ * This header provides macros to embed simulator setup information into
+ * a compiled ELF binary.
+ *
+ * Example:
+ *
+ * Add this somewhere at the root level of your AVR code:
+ *
+ *   #include "simulavr_info.h"
+ *   SIMINFO_DEVICE("atmega644");
+ *   SIMINFO_CPUFREQUENCY(F_CPU);
+ *
+ * Then link as usual, but add these linker flags to avr-gcc to prohibit
+ * the linker from removing the info sections at the link stage:
+ *
+ *   -Wl,--section-start=.siminfo=0x900000
+ *
+ * The value choosen here to be 0x900000 can be choosen freely, but must
+ * be above 0x840400, else it can conflict with program / eeprom / fuses /
+ * lockbits / signature data, see ELFLoad() in src/avrreadelf.cpp, line 215ff.
+ *
+ * You also have to avoid the -Wl,--gc-sections flag, which unfortunately
+ * increases binary size if you have unused functions.
+ *
+ * Having this done, running the ELF binary in the simulator will
+ * automatically inform simulavr for which AVR variant and CPU frequency
+ * the binary was built, making the corresponding command line parameters
+ * obsolete. In case you give both, in-binary and CLI parameters, CLI
+ * parameters take precedence.
+ *
+ * The really nice thing about this mechanism is, it doesn't alter the
+ * executed binary at all. You can upload and run this on real hardware,
+ * not a single byte of Flash memory or a single CPU cycle at runtime wasted.
+ */
+
+#ifndef __SIMULAVR_INFO_H__
+#define __SIMULAVR_INFO_H__
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define SIMINFO_SECTION __attribute__((section(".siminfo")))
+
+enum {
+  SIMINFO_TAG_NOTAG = 0, // keep this unused as a protection against empty data
+  SIMINFO_TAG_DEVICE,
+  SIMINFO_TAG_CPUFREQUENCY,
+};
+
+struct siminfo_long_t {
+  uint8_t tag;
+  uint32_t value;
+} __attribute__((__packed__));
+
+struct siminfo_string_t {
+  uint8_t tag;
+  char string[];
+} __attribute__((__packed__));
+
+
+/*
+ * This gives the device type, like "attiny45", "atmega128", "atmega644", etc.
+ */
+#define SIMINFO_DEVICE(name) \
+  const struct siminfo_string_t siminfo_device SIMINFO_SECTION = { \
+    SIMINFO_TAG_DEVICE, \
+    name \
+  }
+
+/*
+ * This gives the cpu frequency, like 8000000UL or 16000000UL.
+ */
+#define SIMINFO_CPUFREQUENCY(value) \
+  const struct siminfo_long_t siminfo_cpufrequency SIMINFO_SECTION = { \
+    SIMINFO_TAG_CPUFREQUENCY, \
+    value \
+  }
+
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif /* __SIMULAVR_INFO_H__ */

From 06c48bc6552ddf81e120c1980071e8814dfe7057 Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Sat, 16 Nov 2013 17:03:27 +0100
Subject: [PATCH 10/20] ELF simulation info storage: bring SIMINFO_DEVICE()
 into action.

---
 src/avrfactory.cpp |   4 +-
 src/avrreadelf.cpp | 117 ++++++++++++++++++++++++++++++++++++---------
 src/avrreadelf.h   |   2 +-
 src/cmd/main.cpp   |  36 ++++----------
 4 files changed, 107 insertions(+), 52 deletions(-)

diff --git a/src/avrfactory.cpp b/src/avrfactory.cpp
index 77bd154..c37b565 100644
--- a/src/avrfactory.cpp
+++ b/src/avrfactory.cpp
@@ -52,7 +52,9 @@ AvrDevice* AvrFactory::makeDevice(const char *in) {
     for(unsigned int i = 0; i < devname.size(); i++)
         devname[i] = tolower(devname[i]);
     if(devname == "unknown")
-        avr_error("Device type not specified, use -d | --device TYPE or insert '#insert <avr/signature.h>' into your source to specify device signature");
+        avr_error("Device type not specified, use -d | --device TYPE or "
+                  "insert a SIMINFO_DEVICE(name) macro into your source to "
+                  "specify the device name");
     AVRDeviceMap::iterator i = devmap.find(devname);
     if(i == devmap.end())
         avr_error("Invalid device specification: %s", in);
diff --git a/src/avrreadelf.cpp b/src/avrreadelf.cpp
index d5d1a09..00141ed 100644
--- a/src/avrreadelf.cpp
+++ b/src/avrreadelf.cpp
@@ -34,6 +34,7 @@
 #include <map>
 
 #include "avrdevice_impl.h"
+#include "avrsignature.h"
 #include "simulavr_info.h"
 
 #include "avrreadelf.h"
@@ -127,7 +128,7 @@ void ELFLoad(const AvrDevice * core) {
     fclose(f);
 }
 
-unsigned int ELFGetSignature(const char *filename) {
+unsigned int ELFGetDeviceNameAndSignature(const char *filename, char * devicename) {
     return -1;
 }
 #endif
@@ -275,7 +276,7 @@ void ELFLoad(const AvrDevice * core) {
             char tag = *data_ptr++;
             switch (tag) {
               case SIMINFO_TAG_DEVICE:
-                avr_warning("device is %s", data_ptr);
+                // Device name. Handled in ELFGetDeviceNameAndSignature().
                 while (*data_ptr != '\0')
                   data_ptr++;
                 data_ptr++; // the '\0' its self
@@ -299,41 +300,111 @@ void ELFLoad(const AvrDevice * core) {
     bfd_close(abfd);
 }
 
-unsigned int ELFGetSignature(const char *filename) {
-    bfd *abfd;
-    asection *sec;
-    unsigned int signature = -1;
+unsigned int ELFGetDeviceNameAndSignature(const char *filename, char *devicename) {
+    unsigned int signature = 0, new_sig = 0;
 
-    bfd_init();
-    abfd = bfd_openr(filename, NULL);
+    // Command line takes precedence.
+    if ( ! strcmp(devicename, "unknown")) {
+        bfd *abfd;
+        asection *sec;
 
-    if((abfd != NULL) && (bfd_check_format(abfd, bfd_object) == TRUE)) {
-        sec = abfd->sections;
-        while(sec != 0) {
-            if(sec->flags & SEC_LOAD) {
+        bfd_init();
+        abfd = bfd_openr(filename, NULL);
+
+        if((abfd != NULL) && (bfd_check_format(abfd, bfd_object) == TRUE)) {
+            sec = abfd->sections;
+            while(sec != 0) {
                 int size = sec->size;
-                unsigned char *tmp = (unsigned char *)malloc(size);
+                char *tmp = (char *)malloc(size);
 
-                bfd_get_section_contents(abfd, sec, tmp, 0, size);
+                if(sec->flags & SEC_LOAD) {
 
-                if(sec->vma >= 0x840000 && sec->vma < 0x840400) {
-                    // read and check signature, if available, space from 0x840000 to 0x840400
-                    if(size != 3) {
-                        free(tmp); // free memory before abort program
-                        avr_error("wrong device signature size in elf file, expected=3, given=%d", size);
-                    } else
-                        signature = (((tmp[2] << 8) + tmp[1]) << 8) + tmp[0];
+                    bfd_get_section_contents(abfd, sec, tmp, 0, size);
+
+                    if(sec->vma >= 0x840000 && sec->vma < 0x840400) {
+                        // read and check signature, if available, space from 0x840000 to 0x840400
+                        if(size != 3) {
+                            free(tmp); // free memory before abort program
+                            avr_error("wrong device signature size in elf file, expected=3, given=%d", size);
+                        } else
+                            signature = (((tmp[2] << 8) + tmp[1]) << 8) + tmp[0];
+                    }
                 }
 
+                if ( ! strcmp(sec->name, ".siminfo")) {
+                    char *data_ptr, *data_end;
+
+                    data_ptr = tmp;
+                    data_end = tmp + size;
+                    while (data_ptr < data_end) {
+                        char tag = *data_ptr++;
+                        switch (tag) {
+                          case SIMINFO_TAG_DEVICE:
+                            strncpy(devicename, data_ptr, 1024);
+                            devicename[1023] = '\0'; // safety
+                            while (*data_ptr != '\0')
+                                data_ptr++;
+                            data_ptr++; // the '\0' its self
+                            break;
+                          case SIMINFO_TAG_CPUFREQUENCY:
+                            // Handled in ELF_Load().
+                            data_ptr += sizeof(uint32_t);
+                            break;
+                          default:
+                            // Unknown tag, warning given in ELFLoad().
+                            data_ptr++;
+                        }
+                    }
+                }
                 free(tmp);
+                sec = sec->next;
             }
+            bfd_close(abfd);
+        }
+
+        if (strcmp(devicename, "unknown")) {
+            // We found a device name, find the signature of _this_ one.
+            std::map<std::string, unsigned int>::iterator cur =
+                AvrNameToSignatureMap.find(devicename);
+            if (cur != AvrNameToSignatureMap.end()) {
+                new_sig = cur->second;
+            } else {
+                avr_warning("signature for device '%s' not found", devicename);
+            }
+        }
 
-            sec = sec->next;
+        if (signature != 0) {
+            if (new_sig != 0 && signature != new_sig) {
+                avr_warning("ELF signature 0x%x taking precedence over ELF siminfo device name %s",
+                            signature, devicename);
+            }
+        } else
+            signature = new_sig;
+    }
+    else {
+        // We have a device name from the command line.
+        std::map<std::string, unsigned int>::iterator cur =
+            AvrNameToSignatureMap.find(devicename);
+        if (cur != AvrNameToSignatureMap.end()) {
+            signature = cur->second;
+        } else {
+            avr_warning("signature for device '%s' not found", devicename);
         }
+    }
 
-        bfd_close(abfd);
+    // If we've found _anything_, we've a signature now.
+    if (signature != 0) {
+        std::map<unsigned int, std::string>::iterator cur =
+            AvrSignatureToNameMap.find(signature);
+        if (cur != AvrSignatureToNameMap.end()) {
+            strncpy(devicename, cur->second.c_str(), 1024);
+        } else {
+            // Assume signatures found by device name never get here.
+            avr_warning("unknown signature in ELF file: 0x%x", signature);
+        }
     }
 
+    avr_message("Device name is %s", devicename);
     return signature;
 }
 #endif
diff --git a/src/avrreadelf.h b/src/avrreadelf.h
index d16195d..fb5a1e8 100644
--- a/src/avrreadelf.h
+++ b/src/avrreadelf.h
@@ -28,7 +28,7 @@
 
 #include "avrdevice.h"
 
-unsigned int ELFGetSignature(const char *filename);
+unsigned int ELFGetDeviceNameAndSignature(const char *filename, char *devicename);
 void ELFLoad(const AvrDevice * core);
 
 #endif
diff --git a/src/cmd/main.cpp b/src/cmd/main.cpp
index ca60731..4ce1743 100644
--- a/src/cmd/main.cpp
+++ b/src/cmd/main.cpp
@@ -26,6 +26,7 @@
 #include <iostream>
 #include <sstream>
 #include <string>
+#include <cstring>
 #include <map>
 using namespace std;
 
@@ -271,7 +272,6 @@ int main(int argc, char *argv[]) {
                 break;
             
             case 'd':
-                avr_message("Device to simulate: %s", optarg);
                 devicename = optarg;
                 break;
             
@@ -341,35 +341,17 @@ int main(int argc, char *argv[]) {
     
     /* check, if devicename is given or get it out from elf file, if given */
     unsigned int sig;
-    if(devicename == "unknown") {
-        // option -d | --device not given
-        if(filename != "unknown") {
-            // filename given, try to get signature
-            sig = ELFGetSignature(filename.c_str());
-            if(sig != -1) {
-                // signature in elf found, try to get devicename
-                std::map<unsigned int, std::string>::iterator cur  = AvrSignatureToNameMap.find(sig);
-                if(cur != AvrSignatureToNameMap.end()) {
-                    // devicename found
-                    devicename = cur->second;
-                } else {
-                    avr_warning("unknown signature in elf file '%s': 0x%x", filename.c_str(), sig);
-                }
-            }
-        }
+    char *new_devicename = (char *)malloc(1024); // can't be static
+
+    strncpy(new_devicename, devicename.c_str(), 1024);
+    if(filename != "unknown") {
+        sig = ELFGetDeviceNameAndSignature(filename.c_str(), new_devicename);
     }
 
     /* now we create the device and set device name and signature */
-    AvrDevice *dev1 = AvrFactory::instance().makeDevice(devicename.c_str());
-    std::map<std::string, unsigned int>::iterator cur  = AvrNameToSignatureMap.find(devicename);
-    if(cur != AvrNameToSignatureMap.end()) {
-        // signature found
-        sig = cur->second;
-    } else {
-        avr_warning("signature for device '%s' not found", devicename.c_str());
-        sig = -1;
-    }
-    dev1->SetDeviceNameAndSignature(devicename, sig);
+    AvrDevice *dev1 = AvrFactory::instance().makeDevice(new_devicename);
+    dev1->SetDeviceNameAndSignature(new_devicename, sig);
+    free(new_devicename);
     
     /* We had to wait with dumping the available tracing values
       until the device has been created! */

From 77389ef118d220fbded7f40e22e6660dfd10b561 Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Sat, 16 Nov 2013 22:28:42 +0100
Subject: [PATCH 11/20] ELF simulation info storage: bring
 SIMINFO_CPUFREQUENCY() into action.

Substantial part of this patch is a move from accessing protected
properties of class AvrDevice directly to using their Getters.
---
 src/avrreadelf.cpp | 27 +++++++++++++--------------
 src/avrreadelf.h   |  2 +-
 src/cmd/main.cpp   | 21 +++++++++++++++------
 3 files changed, 29 insertions(+), 21 deletions(-)

diff --git a/src/avrreadelf.cpp b/src/avrreadelf.cpp
index 00141ed..69e76ba 100644
--- a/src/avrreadelf.cpp
+++ b/src/avrreadelf.cpp
@@ -89,18 +89,18 @@ typedef struct {
 } Elf32_Phdr;
 
 void ELFLoad(const AvrDevice * core) {
-    FILE * f = fopen(core->actualFilename.c_str(), "rb");
+    FILE * f = fopen(core->GetFname().c_str(), "rb");
     if(f == NULL)
-        avr_error("Could not open file: %s", core->actualFilename.c_str());
+        avr_error("Could not open file: %s", core->GetFname().c_str());
 
     Elf32_Ehdr header;
     fread(&header, sizeof(header), 1, f);
     if(header.e_ident[0] != 0x7F || header.e_ident[1] != 'E'
         || header.e_ident[2] != 'L' || header.e_ident[3] != 'F')
-        avr_error("File '%s' is not an ELF file", core->actualFilename.c_str());
+        avr_error("File '%s' is not an ELF file", core->GetFname().c_str());
     // TODO: fix endianity in header
     if(header.e_machine != 83)
-        avr_error("ELF file '%s' is not for Atmel AVR architecture (%d)", core->actualFilename.c_str(), header.e_machine);
+        avr_error("ELF file '%s' is not for Atmel AVR architecture (%d)", core->GetFname().c_str(), header.e_machine);
 
     for(int i = 0; i < header.e_phnum; i++) {
         fseek(f, header.e_phoff + i * header.e_phentsize, SEEK_SET);
@@ -115,7 +115,7 @@ void ELFLoad(const AvrDevice * core) {
             continue;  // not into a Flash
         if(progHeader.p_filesz != progHeader.p_memsz) {
             avr_error("Segment sizes 0x%x and 0x%x in ELF file '%s' must be the same",
-                progHeader.p_filesz, progHeader.p_memsz, core->actualFilename.c_str());
+                progHeader.p_filesz, progHeader.p_memsz, core->GetFname().c_str());
         }
         unsigned char * tmp = new unsigned char[progHeader.p_filesz];
         fseek(f, progHeader.p_offset, SEEK_SET);
@@ -134,20 +134,20 @@ unsigned int ELFGetDeviceNameAndSignature(const char *filename, char * devicenam
 #endif
 
 #ifndef _MSC_VER
-void ELFLoad(const AvrDevice * core) {
+void ELFLoad(AvrDevice * core) {
     bfd *abfd;
     asection *sec;
 
     // open file
     bfd_init();
-    abfd = bfd_openr(core->actualFilename.c_str(), NULL);
+    abfd = bfd_openr(core->GetFname().c_str(), NULL);
 
     if(abfd == NULL)
-        avr_error("Could not open file: %s", core->actualFilename.c_str());
+        avr_error("Could not open file: %s", core->GetFname().c_str());
 
     // check format
     if(bfd_check_format(abfd, bfd_object) == FALSE)
-        avr_error("File '%s' isn't a elf object", core->actualFilename.c_str());
+        avr_error("File '%s' isn't a elf object", core->GetFname().c_str());
 
     // reading out the symbols
     long storage_needed;
@@ -202,7 +202,7 @@ void ELFLoad(const AvrDevice * core) {
         }
         free(symbol_table);
     } else
-        avr_warning("Elf file '%s' has no symbol table!", core->actualFilename.c_str());
+        avr_warning("Elf file '%s' has no symbol table!", core->GetFname().c_str());
 
     // load program, data and - if available - eeprom, fuses and signature
     sec = abfd->sections;
@@ -242,9 +242,9 @@ void ELFLoad(const AvrDevice * core) {
                     avr_error("wrong device signature size in elf file, expected=3, given=%d", size);
                 } else {
                     unsigned int sig = (((tmp[2] << 8) + tmp[1]) << 8) + tmp[0];
-                    if(core->devSignature != -1 && sig != core->devSignature) {
+                    if(core->GetDeviceSignature() != -1 && sig != core->GetDeviceSignature()) {
                         free(tmp); // free memory before abort program
-                        avr_error("wrong device signature, expected=0x%x, given=0x%x", core->devSignature, sig);
+                        avr_error("wrong device signature, expected=0x%x, given=0x%x", core->GetDeviceSignature(), sig);
                     }
                 }
             }
@@ -253,7 +253,6 @@ void ELFLoad(const AvrDevice * core) {
             free(tmp);
         }
         else if ( ! strcmp(sec->name, ".siminfo")) {
-          avr_warning(".siminfo section found!");
           /*
            * You wonder why the .siminfo section is read here, while this
            * stuff also shows up as symbols, which are read above already?
@@ -282,7 +281,7 @@ void ELFLoad(const AvrDevice * core) {
                 data_ptr++; // the '\0' its self
                 break;
               case SIMINFO_TAG_CPUFREQUENCY:
-                avr_warning("frequency is %u", *(uint32_t *)data_ptr);
+                core->SetClockFreq((SystemClockOffset)1000000000 / *(uint32_t *)data_ptr);
                 data_ptr += sizeof(uint32_t);
                 break;
               default:
diff --git a/src/avrreadelf.h b/src/avrreadelf.h
index fb5a1e8..9695826 100644
--- a/src/avrreadelf.h
+++ b/src/avrreadelf.h
@@ -29,6 +29,6 @@
 #include "avrdevice.h"
 
 unsigned int ELFGetDeviceNameAndSignature(const char *filename, char *devicename);
-void ELFLoad(const AvrDevice * core);
+void ELFLoad(AvrDevice * core);
 
 #endif
diff --git a/src/cmd/main.cpp b/src/cmd/main.cpp
index 4ce1743..36f25fa 100644
--- a/src/cmd/main.cpp
+++ b/src/cmd/main.cpp
@@ -145,7 +145,7 @@ int main(int argc, char *argv[]) {
     int global_gdb_debug = 0;
     bool globalWaitForGdbConnection = true; //please wait for gdb connection
     int userinterface_flag = 0;
-    unsigned long long fcpu = 4000000;
+    unsigned long long fcpu = 0;
     unsigned long long maxRunTime = 0;
     unsigned long long linestotrace = 1000000;
     UserInterface *ui;
@@ -237,9 +237,6 @@ int main(int argc, char *argv[]) {
                     cerr << "frequency is zero" << endl;
                     exit(1);
                 }
-                if(global_verbose_on)
-                    printf("Running with CPU frequency: %1.4f MHz (%lld Hz)\n",
-                           fcpu/1000000.0, fcpu);
                 break;
 
             case 'l':
@@ -408,8 +405,20 @@ int main(int argc, char *argv[]) {
     //if not gdb, the ui will be master controller :-)
     ui = (userinterface_flag == 1) ? new UserInterface(7777) : NULL;
     
-    dev1->SetClockFreq(1000000000 / fcpu); // time base is 1ns!
-    
+    if (fcpu != 0)
+        dev1->SetClockFreq((SystemClockOffset)1000000000 / fcpu); // time base is 1ns!
+
+    if (dev1->GetClockFreq() == 0) {
+        avr_warning("Clock frequency not given, defaulting to 4000000. "
+                    "Use -F | --cpufrequency FREQ or insert a "
+                    "SIMINFO_CPUFREQUENCY(freq) macro into your source %s",
+                    "to specify it.");
+        dev1->SetClockFreq((SystemClockOffset)1000000000 / 4000000);
+    }
+    avr_message("Running with CPU frequency: %1.3lf MHz (%lld Hz)\n",
+                (double)1000 / dev1->GetClockFreq(),
+                (unsigned long long)1000000000 / dev1->GetClockFreq());
+
     if(sysConHandler.GetTraceState())
         dev1->trace_on = 1;
     

From 276fe1fd1051d9f4920ff9d70bd6bf5f2e7ec037 Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Sat, 16 Nov 2013 23:57:59 +0100
Subject: [PATCH 12/20] ELF simulation info storage: introduce a length
 variable.

This makes the ELf file slightly bigger, but reading it more simple
and failure-proof.
---
 src/avrreadelf.cpp  | 33 ++++++++++++---------------------
 src/simulavr_info.h |  6 ++++++
 2 files changed, 18 insertions(+), 21 deletions(-)

diff --git a/src/avrreadelf.cpp b/src/avrreadelf.cpp
index 69e76ba..906364c 100644
--- a/src/avrreadelf.cpp
+++ b/src/avrreadelf.cpp
@@ -272,22 +272,20 @@ void ELFLoad(AvrDevice * core) {
           data_ptr = data;
           data_end = data + size;
           while (data_ptr < data_end) {
-            char tag = *data_ptr++;
+            char tag = *data_ptr;
+            char length = *(data_ptr + 1);
             switch (tag) {
               case SIMINFO_TAG_DEVICE:
                 // Device name. Handled in ELFGetDeviceNameAndSignature().
-                while (*data_ptr != '\0')
-                  data_ptr++;
-                data_ptr++; // the '\0' its self
                 break;
               case SIMINFO_TAG_CPUFREQUENCY:
-                core->SetClockFreq((SystemClockOffset)1000000000 / *(uint32_t *)data_ptr);
-                data_ptr += sizeof(uint32_t);
+                core->SetClockFreq((SystemClockOffset)1000000000 /
+                                   ((siminfo_long_t *)data_ptr)->value);
                 break;
               default:
                 avr_warning("Unknown tag in ELF .siminfo section: %hu", tag);
-                data_ptr++;
             }
+            data_ptr += length;
           }
           free(data);
         }
@@ -336,23 +334,16 @@ unsigned int ELFGetDeviceNameAndSignature(const char *filename, char *devicename
                     data_ptr = tmp;
                     data_end = tmp + size;
                     while (data_ptr < data_end) {
-                        char tag = *data_ptr++;
-                        switch (tag) {
-                          case SIMINFO_TAG_DEVICE:
-                            strncpy(devicename, data_ptr, 1024);
+                        char tag = *data_ptr;
+                        char length = *(data_ptr + 1);
+                        if (tag == SIMINFO_TAG_DEVICE) {
+                            strncpy(devicename,
+                                    ((siminfo_string_t *)data_ptr)->string, 1024);
                             devicename[1023] = '\0'; // safety
-                            while (*data_ptr != '\0')
-                                data_ptr++;
-                            data_ptr++; // the '\0' its self
                             break;
-                          case SIMINFO_TAG_CPUFREQUENCY:
-                            // Handled in ELF_Load().
-                            data_ptr += sizeof(uint32_t);
-                            break;
-                          default:
-                            // Unknown tag, warning given in ELFLoad().
-                            data_ptr++;
                         }
+                        // Everything else handled in ELFLoad().
+                        data_ptr += length;
                     }
                 }
                 free(tmp);
diff --git a/src/simulavr_info.h b/src/simulavr_info.h
index 51def63..a1a5514 100644
--- a/src/simulavr_info.h
+++ b/src/simulavr_info.h
@@ -77,11 +77,13 @@ enum {
 
 struct siminfo_long_t {
   uint8_t tag;
+  uint8_t length;
   uint32_t value;
 } __attribute__((__packed__));
 
 struct siminfo_string_t {
   uint8_t tag;
+  uint8_t length;
   char string[];
 } __attribute__((__packed__));
 
@@ -92,6 +94,9 @@ struct siminfo_string_t {
 #define SIMINFO_DEVICE(name) \
   const struct siminfo_string_t siminfo_device SIMINFO_SECTION = { \
     SIMINFO_TAG_DEVICE, \
+    /* We could use sizeof(siminfo_device) here, but avr-gcc has \
+       been seen to set length to 0 (zero), then. */ \
+    sizeof(name) + 2, \
     name \
   }
 
@@ -101,6 +106,7 @@ struct siminfo_string_t {
 #define SIMINFO_CPUFREQUENCY(value) \
   const struct siminfo_long_t siminfo_cpufrequency SIMINFO_SECTION = { \
     SIMINFO_TAG_CPUFREQUENCY, \
+    sizeof(uint32_t) + 2, \
     value \
   }
 

From cfcb58e4347dac7870c81e822ff6b78cf6b250d5 Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Mon, 18 Nov 2013 14:47:01 +0100
Subject: [PATCH 13/20] ELF simulation info storage: bail out on malformed
 .siminfo sections.

avr-gcc has been seen to set the length field to zero. Clearly a bug,
but ignoring bugs doesn't help.
---
 src/avrreadelf.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/avrreadelf.cpp b/src/avrreadelf.cpp
index 906364c..778df53 100644
--- a/src/avrreadelf.cpp
+++ b/src/avrreadelf.cpp
@@ -274,6 +274,8 @@ void ELFLoad(AvrDevice * core) {
           while (data_ptr < data_end) {
             char tag = *data_ptr;
             char length = *(data_ptr + 1);
+            // Length check already done in ELFGetDeviceNameAndSignature().
+
             switch (tag) {
               case SIMINFO_TAG_DEVICE:
                 // Device name. Handled in ELFGetDeviceNameAndSignature().
@@ -290,7 +292,6 @@ void ELFLoad(AvrDevice * core) {
           free(data);
         }
 
-
         sec = sec->next;
     }
 
@@ -336,6 +337,9 @@ unsigned int ELFGetDeviceNameAndSignature(const char *filename, char *devicename
                     while (data_ptr < data_end) {
                         char tag = *data_ptr;
                         char length = *(data_ptr + 1);
+                        if (length == 0)
+                            avr_error("Field of zero length in .siminfo"
+                                      "section in ELF file found.");
                         if (tag == SIMINFO_TAG_DEVICE) {
                             strncpy(devicename,
                                     ((siminfo_string_t *)data_ptr)->string, 1024);

From 9d470ca92e8b3f8a817942c0c0d444ee37caed1c Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Mon, 18 Nov 2013 13:45:19 +0100
Subject: [PATCH 14/20] ELF simulation info storage: introduce
 SIMINFO_SERIAL_OUT().

Applied to the simple_serial example, but no action yet,
just the info transport.
---
 examples/simple_serial/main.c |  1 +
 src/avrreadelf.cpp            |  6 ++++++
 src/simulavr_info.h           | 37 +++++++++++++++++++++++++++++++++++
 3 files changed, 44 insertions(+)

diff --git a/examples/simple_serial/main.c b/examples/simple_serial/main.c
index 44dd2ed..a1533fa 100644
--- a/examples/simple_serial/main.c
+++ b/examples/simple_serial/main.c
@@ -55,6 +55,7 @@
 #include "../../src/simulavr_info.h"
 SIMINFO_DEVICE("atmega644");
 SIMINFO_CPUFREQUENCY(F_CPU);
+SIMINFO_SERIAL_OUT("D1", "-", 19200);
 
 
 // This is all we need:
diff --git a/src/avrreadelf.cpp b/src/avrreadelf.cpp
index 778df53..0945144 100644
--- a/src/avrreadelf.cpp
+++ b/src/avrreadelf.cpp
@@ -284,6 +284,12 @@ void ELFLoad(AvrDevice * core) {
                 core->SetClockFreq((SystemClockOffset)1000000000 /
                                    ((siminfo_long_t *)data_ptr)->value);
                 break;
+              case SIMINFO_TAG_SERIAL_OUT:
+                avr_warning("Want to connect pin %s to file %s at %d baud.",
+                            ((siminfo_serial_t *)data_ptr)->pin,
+                            ((siminfo_serial_t *)data_ptr)->filename,
+                            ((siminfo_serial_t *)data_ptr)->baudrate);
+                break;
               default:
                 avr_warning("Unknown tag in ELF .siminfo section: %hu", tag);
             }
diff --git a/src/simulavr_info.h b/src/simulavr_info.h
index a1a5514..a79eea6 100644
--- a/src/simulavr_info.h
+++ b/src/simulavr_info.h
@@ -73,6 +73,7 @@ enum {
   SIMINFO_TAG_NOTAG = 0, // keep this unused as a protection against empty data
   SIMINFO_TAG_DEVICE,
   SIMINFO_TAG_CPUFREQUENCY,
+  SIMINFO_TAG_SERIAL_OUT,
 };
 
 struct siminfo_long_t {
@@ -87,6 +88,14 @@ struct siminfo_string_t {
   char string[];
 } __attribute__((__packed__));
 
+struct siminfo_serial_t {
+  uint8_t tag;
+  uint8_t length;
+  char pin[3];
+  uint32_t baudrate;
+  char filename[];
+} __attribute__((__packed__));
+
 
 /*
  * This gives the device type, like "attiny45", "atmega128", "atmega644", etc.
@@ -110,6 +119,34 @@ struct siminfo_string_t {
     value \
   }
 
+/*
+ * Create a serial out (Tx, from AVR) component. The given file will receive
+ * the characters/bytes. This can be connected to the same file as a serial in,
+ * if it's a special file like a real serial device or a pipe. Connecting both
+ * to the same regular file will mess things up.
+ *
+ * Using "-" as file name means connecting to the console (stdin/stdout).
+ *
+ * The pin to connect is named by a 2-character string, where "E2" means
+ * pin 2 on port E.
+ *
+ * Why a baud rate? Well, the component doesn't just fetch what's written
+ * to the UART send register, but interprets the signal on the pin. If your
+ * code sets a baud rate not matching the one given here, serial communications
+ * won't work. Just like a real serial device configured to work at 19200 baud
+ * won't work on a real serial port set to something else.
+ *
+ * Other parameters are fixed to 8N1, which means 8 bits, no parity, 1 stop bit.
+ */
+#define SIMINFO_SERIAL_OUT(pin, filename, baudrate) \
+  const struct siminfo_serial_t siminfo_serial_out SIMINFO_SECTION = { \
+    SIMINFO_TAG_SERIAL_OUT, \
+    sizeof(char[3]) + sizeof(uint32_t) + sizeof(filename) + 2, \
+    pin, \
+    baudrate, \
+    filename \
+  }
+
 
 #ifdef __cplusplus
 };

From b3352076c7c4a149f4e6b5bfb9f84b7e22e88f5c Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Mon, 18 Nov 2013 19:04:23 +0100
Subject: [PATCH 15/20] ui/serialrx: implement SerialRxFile.

This class moves serial output to a file, to a special file or to
stdout.

While there's special_output_port already, using an UI device
neither changes the AVR code nor does it influence AVR behaviour.
---
 src/ui/serialrx.cpp | 30 ++++++++++++++++++++++++++++++
 src/ui/serialrx.h   | 13 +++++++++++++
 2 files changed, 43 insertions(+)

diff --git a/src/ui/serialrx.cpp b/src/ui/serialrx.cpp
index 799e0cf..feee577 100644
--- a/src/ui/serialrx.cpp
+++ b/src/ui/serialrx.cpp
@@ -26,6 +26,7 @@
 #include "serialrx.h"
 #include "systemclock.h"
 #include "systemclocktypes.h"
+#include <iostream>
 
 using namespace std;
 
@@ -150,6 +151,35 @@ long SerialRxBuffered::Size(){
 // ===========================================================================
 
 
+SerialRxFile::SerialRxFile(const char *filename) {
+    if (std::string(filename) == "-")
+        stream.std::ostream::rdbuf(std::cout.rdbuf());
+    else
+        stream.open(filename);
+    // Enable automatic flushing, hitting ctrl-c to
+    // end a simulation doesn't call destructors.
+    stream << std::unitbuf;
+}
+
+SerialRxFile::~SerialRxFile() {
+    if (stream.std::ostream::rdbuf() != std::cout.rdbuf())
+        stream.close();
+}
+
+void SerialRxFile::CharReceived(unsigned char c){
+    if (sendInHex) {
+        stream << "0x" << std::hex << (unsigned int)c << " ";
+    } else {
+        stream << c;
+    }
+}
+
+
+// ===========================================================================
+// ===========================================================================
+// ===========================================================================
+
+
 SerialRx::SerialRx(UserInterface *_ui, const char *_name, const char *baseWindow):
     ui(_ui), name(_name)  {
         rx.RegisterCallback(this);
diff --git a/src/ui/serialrx.h b/src/ui/serialrx.h
index cd01623..ebd1a89 100644
--- a/src/ui/serialrx.h
+++ b/src/ui/serialrx.h
@@ -26,6 +26,7 @@
 #ifndef SERIALRX_H_INCLUDED
 #define SERIALRX_H_INCLUDED
 
+#include <fstream>
 #include "systemclocktypes.h"
 #include "ui.h"
 #include "pinnotify.h"
@@ -81,6 +82,18 @@ class SerialRxBuffered: public SerialRxBasic{
  };
 
 
+/** Reads bits from device pins, reconstructs UART bytes and sends them to
+ *  a file, a special file/com port or the console. */
+class SerialRxFile: public SerialRxBasic {
+    private:
+        std::ofstream stream;
+    protected:
+        virtual void CharReceived(unsigned char c);
+    public:
+        SerialRxFile(const char *filename);
+        ~SerialRxFile();
+ };
+
 /** Reads bits from device pins, reconstructs UART bytes and sends them to UI. */
 class SerialRx: public SerialRxBasic, public ExternalType{
     protected:

From 7dfe57dd714e39c331046fd48a10bdc2ace501ee Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Mon, 18 Nov 2013 16:25:20 +0100
Subject: [PATCH 16/20] ELF simulation info storage: bring SIMINFO_SERIAL_OUT()
 into action.

Once I found out on how it's done, it was surprisingly simple.

Even better for the user: No need for TCL, no need for Python, no
need for Swig, just add a single, simple macro to your AVR source
code.
---
 src/avrreadelf.cpp | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/avrreadelf.cpp b/src/avrreadelf.cpp
index 0945144..0193921 100644
--- a/src/avrreadelf.cpp
+++ b/src/avrreadelf.cpp
@@ -35,6 +35,7 @@
 
 #include "avrdevice_impl.h"
 #include "avrsignature.h"
+#include "serialrx.h"
 #include "simulavr_info.h"
 
 #include "avrreadelf.h"
@@ -285,10 +286,18 @@ void ELFLoad(AvrDevice * core) {
                                    ((siminfo_long_t *)data_ptr)->value);
                 break;
               case SIMINFO_TAG_SERIAL_OUT:
-                avr_warning("Want to connect pin %s to file %s at %d baud.",
+                avr_message("Connecting pin %s as serial out to file %s at %d baud.",
                             ((siminfo_serial_t *)data_ptr)->pin,
                             ((siminfo_serial_t *)data_ptr)->filename,
                             ((siminfo_serial_t *)data_ptr)->baudrate);
+                {
+                  Net *net = new Net();
+                  SerialRxFile *serial =
+                    new SerialRxFile(((siminfo_serial_t *)data_ptr)->filename);
+                  serial->SetBaudRate(((siminfo_serial_t *)data_ptr)->baudrate);
+                  net->Add(core->GetPin(((siminfo_serial_t *)data_ptr)->pin));
+                  net->Add(serial->GetPin("rx"));
+                }
                 break;
               default:
                 avr_warning("Unknown tag in ELF .siminfo section: %hu", tag);

From 27bd1f4c4d420d83b8ec6f40a6df7875687230a5 Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Tue, 19 Nov 2013 15:59:57 +0100
Subject: [PATCH 17/20] ELF simulation info storage: introduce
 SIMINFO_SERIAL_IN():

Almost the same as SIMINFO_SERIAL_IN(), but the other direction.
---
 examples/simple_serial/main.c |  1 +
 src/avrreadelf.cpp            |  6 ++++++
 src/simulavr_info.h           | 33 ++++++++++++++++++++++++---------
 3 files changed, 31 insertions(+), 9 deletions(-)

diff --git a/examples/simple_serial/main.c b/examples/simple_serial/main.c
index a1533fa..9de9f5f 100644
--- a/examples/simple_serial/main.c
+++ b/examples/simple_serial/main.c
@@ -55,6 +55,7 @@
 #include "../../src/simulavr_info.h"
 SIMINFO_DEVICE("atmega644");
 SIMINFO_CPUFREQUENCY(F_CPU);
+SIMINFO_SERIAL_IN("D0", "-", 19200);
 SIMINFO_SERIAL_OUT("D1", "-", 19200);
 
 
diff --git a/src/avrreadelf.cpp b/src/avrreadelf.cpp
index 0193921..796f88e 100644
--- a/src/avrreadelf.cpp
+++ b/src/avrreadelf.cpp
@@ -285,6 +285,12 @@ void ELFLoad(AvrDevice * core) {
                 core->SetClockFreq((SystemClockOffset)1000000000 /
                                    ((siminfo_long_t *)data_ptr)->value);
                 break;
+              case SIMINFO_TAG_SERIAL_IN:
+                avr_warning("Want to connect pin %s to file %s at %d baud.",
+                            ((siminfo_serial_t *)data_ptr)->pin,
+                            ((siminfo_serial_t *)data_ptr)->filename,
+                            ((siminfo_serial_t *)data_ptr)->baudrate);
+                break;
               case SIMINFO_TAG_SERIAL_OUT:
                 avr_message("Connecting pin %s as serial out to file %s at %d baud.",
                             ((siminfo_serial_t *)data_ptr)->pin,
diff --git a/src/simulavr_info.h b/src/simulavr_info.h
index a79eea6..52e392e 100644
--- a/src/simulavr_info.h
+++ b/src/simulavr_info.h
@@ -74,6 +74,7 @@ enum {
   SIMINFO_TAG_DEVICE,
   SIMINFO_TAG_CPUFREQUENCY,
   SIMINFO_TAG_SERIAL_OUT,
+  SIMINFO_TAG_SERIAL_IN,
 };
 
 struct siminfo_long_t {
@@ -120,24 +121,38 @@ struct siminfo_serial_t {
   }
 
 /*
- * Create a serial out (Tx, from AVR) component. The given file will receive
- * the characters/bytes. This can be connected to the same file as a serial in,
- * if it's a special file like a real serial device or a pipe. Connecting both
- * to the same regular file will mess things up.
+ * Create a serial in (Rx, to AVR) component. The the sent characters/bytes
+ * will be taken from the given file. This component can be connected to the
+ * same file as a serial out, if it's a special file like a real serial device
+ * or a pipe. Connecting both to the same regular file will mess things up.
  *
  * Using "-" as file name means connecting to the console (stdin/stdout).
  *
  * The pin to connect is named by a 2-character string, where "E2" means
  * pin 2 on port E.
  *
- * Why a baud rate? Well, the component doesn't just fetch what's written
- * to the UART send register, but interprets the signal on the pin. If your
- * code sets a baud rate not matching the one given here, serial communications
- * won't work. Just like a real serial device configured to work at 19200 baud
- * won't work on a real serial port set to something else.
+ * Why a baud rate? Well, the component doesn't just write to the UART receive
+ * register, but synthesizes actual serial signals on the pin, which in turn
+ * should be interpreted by your AVR code. If your code sets a baud rate not
+ * matching the one given here, serial communications won't work. Just like a
+ * real serial device configured to work at 19200 baud won't work on a real
+ * serial port set to something else.
  *
  * Other parameters are fixed to 8N1, which means 8 bits, no parity, 1 stop bit.
  */
+#define SIMINFO_SERIAL_IN(pin, filename, baudrate) \
+  const struct siminfo_serial_t siminfo_serial_in SIMINFO_SECTION = { \
+    SIMINFO_TAG_SERIAL_IN, \
+    sizeof(char[3]) + sizeof(uint32_t) + sizeof(filename) + 2, \
+    pin, \
+    baudrate, \
+    filename \
+  }
+
+/*
+ * Create a serial out (Tx, from AVR) component. Same as above, but the
+ * other direction. The serial port pin is continuously read and interpreted.
+ */
 #define SIMINFO_SERIAL_OUT(pin, filename, baudrate) \
   const struct siminfo_serial_t siminfo_serial_out SIMINFO_SECTION = { \
     SIMINFO_TAG_SERIAL_OUT, \

From 9773047f62b5d11b97f98e931e1be0f6f3747316 Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Tue, 19 Nov 2013 21:07:50 +0100
Subject: [PATCH 18/20] ui/serialtx: implement SerialTxFile.

Just like the Rx counterpart, this is for communications between
a file/special file/console and the actually simulated UART. Works
beautifully.
---
 src/ui/serialtx.cpp | 60 ++++++++++++++++++++++++++++++++++++++++++++-
 src/ui/serialtx.h   | 17 +++++++++++++
 2 files changed, 76 insertions(+), 1 deletion(-)

diff --git a/src/ui/serialtx.cpp b/src/ui/serialtx.cpp
index c13e580..cdf8652 100644
--- a/src/ui/serialtx.cpp
+++ b/src/ui/serialtx.cpp
@@ -107,7 +107,7 @@ void SerialTxBuffered::Send(unsigned char data)
 {
     inputBuffer.push_back(data); //write new char to input buffer
 
-    cerr << "TX: " << hex << data << " ";
+    // cerr << "TX: " << hex << data << endl;
     //if we not active, activate tx machine now
     if (txState==TX_DISABLED) {
         txState=TX_SEND_STARTBIT;
@@ -115,6 +115,10 @@ void SerialTxBuffered::Send(unsigned char data)
     }
 }
 
+bool SerialTxBuffered::Sending(void) {
+    return (txState != TX_DISABLED);
+}
+
 void SerialTxBuffered::SetBaudRate(SystemClockOffset baud){
     baudrate = baud;
 }
@@ -124,6 +128,60 @@ void SerialTxBuffered::SetHexInput(bool newValue){
 }
 
 
+// ===========================================================================
+// ===========================================================================
+// ===========================================================================
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <poll.h>
+
+SerialTxFile::SerialTxFile(const char *filename) {
+    if (std::string(filename) == "-")
+        fd = fileno(stdin);
+    else
+        fd = open(filename, O_RDONLY, O_CREAT);
+    if (fd < 0)
+        avr_error("open input file failed");
+    Reset();
+
+    SystemClock::Instance().Add(this);
+}
+
+SerialTxFile::~SerialTxFile() {
+    if (fd != fileno(stdin))
+        close(fd);
+}
+
+int SerialTxFile::Step(bool &trueHwStep,
+                       SystemClockOffset *timeToNextStepIn_ns) {
+
+    if (Sending()) {
+        SerialTxBuffered::Step(trueHwStep, timeToNextStepIn_ns);
+    }
+    
+#ifndef WIN32
+    pollfd cinfd[1];
+    cinfd[0].fd = fd;
+    cinfd[0].events = POLLIN;
+    if (poll(cinfd, 1, 0) > 0) {
+#else
+    HANDLE h = GetStdHandle(STD_INPUT_HANDLE);
+    if (WaitForSingleObject(h, 0) == WAIT_OBJECT_0) {
+#endif
+        unsigned char c;
+        if (read(fd, &c, 1)) {
+            Send((unsigned char)c);
+        }
+    }
+
+    if ( ! Sending()) // may have changed with Step() or Send()
+        // Polling for new data every millisecond should be enough. If there's
+        // more than one byte waiting, they're accepted at every serial clock
+        // tick, which means, ten times faster than they can be sent.
+        *timeToNextStepIn_ns = (SystemClockOffset)1000000;
+}
 
 // ===========================================================================
 // ===========================================================================
diff --git a/src/ui/serialtx.h b/src/ui/serialtx.h
index 7ce2ac4..9f92b0d 100644
--- a/src/ui/serialtx.h
+++ b/src/ui/serialtx.h
@@ -61,10 +61,27 @@ class SerialTxBuffered: public SimulationMember {
         virtual int Step(bool &trueHwStep, SystemClockOffset *timeToNextStepIn_ns=0);
         /// Add byte from UI to be sent to device's UART.
         virtual void Send(unsigned char data);
+        bool Sending(void);
         virtual void SetBaudRate(SystemClockOffset baud);
         virtual Pin* GetPin(const char *name); 
 };
 
+#include <stdio.h>
+#include <unistd.h>
+
+/** Reads  bytes from a file, a special file/com port or the console
+ *  and sends them to the device's UART. */
+class SerialTxFile: public SerialTxBuffered {
+    private:
+        // Use a classic file descriptor to have better
+        // control over buffers (and their avoidance).
+        int fd;
+    public:
+        SerialTxFile(const char *filename);
+        ~SerialTxFile();
+        virtual int Step(bool &trueHwStep, SystemClockOffset *timeToNextStepIn_ns=0);
+};
+
 
 /** Buffers byte from UI to be sent to device's UART. */
 class SerialTx: public SerialTxBuffered, public ExternalType {

From c93f23872c85444b9bd0657755b9c674d180ae69 Mon Sep 17 00:00:00 2001
From: Markus Hitter <mah@jump-ing.de>
Date: Tue, 19 Nov 2013 15:39:53 +0100
Subject: [PATCH 19/20] ELF simulation info storage: bring SIMINFO_SERIAL_IN()
 into action.

Just as the Rx counterpart, you can now connect to the console,
a pipe file or even a serial device file of the host. All without
additional scripting and languages, just a macro in the AVR source
code.
---
 src/avrreadelf.cpp | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/avrreadelf.cpp b/src/avrreadelf.cpp
index 796f88e..4d17130 100644
--- a/src/avrreadelf.cpp
+++ b/src/avrreadelf.cpp
@@ -36,6 +36,7 @@
 #include "avrdevice_impl.h"
 #include "avrsignature.h"
 #include "serialrx.h"
+#include "serialtx.h"
 #include "simulavr_info.h"
 
 #include "avrreadelf.h"
@@ -286,10 +287,18 @@ void ELFLoad(AvrDevice * core) {
                                    ((siminfo_long_t *)data_ptr)->value);
                 break;
               case SIMINFO_TAG_SERIAL_IN:
-                avr_warning("Want to connect pin %s to file %s at %d baud.",
-                            ((siminfo_serial_t *)data_ptr)->pin,
+                avr_message("Connecting file %s as serial in to pin %s at %d baud.",
                             ((siminfo_serial_t *)data_ptr)->filename,
+                            ((siminfo_serial_t *)data_ptr)->pin,
                             ((siminfo_serial_t *)data_ptr)->baudrate);
+                {
+                  Net *net = new Net();
+                  SerialTxFile *serial =
+                    new SerialTxFile(((siminfo_serial_t *)data_ptr)->filename);
+                  serial->SetBaudRate(((siminfo_serial_t *)data_ptr)->baudrate);
+                  net->Add(core->GetPin(((siminfo_serial_t *)data_ptr)->pin));
+                  net->Add(serial->GetPin("tx"));
+                }
                 break;
               case SIMINFO_TAG_SERIAL_OUT:
                 avr_message("Connecting pin %s as serial out to file %s at %d baud.",

From 1a918c7b3ecdbccde7b991a11813c7677cb4f971 Mon Sep 17 00:00:00 2001
From: Paolo Patruno <pat1@asus-pat1.pat1.dpn>
Date: Mon, 30 Dec 2013 10:47:05 +0100
Subject: [PATCH 20/20] added args to simulavr to define serial device

---
 src/cmd/main.cpp | 67 ++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 65 insertions(+), 2 deletions(-)

diff --git a/src/cmd/main.cpp b/src/cmd/main.cpp
index 36f25fa..e3771eb 100644
--- a/src/cmd/main.cpp
+++ b/src/cmd/main.cpp
@@ -60,6 +60,9 @@ using namespace std;
 
 #include "dumpargs.h"
 
+#include "serialrx.h"
+#include "serialtx.h"
+
 const char *SplitOffsetFile(const char *arg,
                             const char *name,
                             int base,
@@ -132,6 +135,8 @@ const char Usage[] =
     "-o <trace-value-file> Specifies a file into which all available trace value names\n"
     "                      will be written.\n"
     "-V --version          print out version and exit immediately\n"
+    "-z --uart             activate uart in/out on stdin/stdout\n"
+    "-b --baudrate         baudrate for UART (require -z)\n"
     "-h --help             print this help\n"
     "\n";
 
@@ -146,6 +151,7 @@ int main(int argc, char *argv[]) {
     bool globalWaitForGdbConnection = true; //please wait for gdb connection
     int userinterface_flag = 0;
     unsigned long long fcpu = 0;
+    unsigned long long baudrate = 9600;
     unsigned long long maxRunTime = 0;
     unsigned long long linestotrace = 1000000;
     UserInterface *ui;
@@ -161,6 +167,7 @@ int main(int argc, char *argv[]) {
     
     vector<string> tracer_opts;
     bool tracer_dump_avail = false;
+    bool enableUARTstd = false;
     string tracer_avail_out;
     
     while (1) {
@@ -186,11 +193,13 @@ int main(int argc, char *argv[]) {
             {"terminate", 1, 0, 'T'},
             {"breakpoint", 1, 0, 'B'},
             {"irqstatistic", 0, 0, 's'},
+            {"uart", 0, 0, 'z'},
+            {"baudrate", 1, 0, 'b'},
             {"help", 0, 0, 'h'},
             {0, 0, 0, 0}
         };
         
-        c = getopt_long(argc, argv, "a:e:f:d:gGm:p:t:uxyzhvnisF:R:W:VT:B:c:o:l:", long_options, &option_index);
+        c = getopt_long(argc, argv, "a:e:f:d:gGm:p:t:uxyzhvnisF:R:W:VT:B:c:o:l:b:", long_options, &option_index);
         if(c == -1)
             break;
         
@@ -324,6 +333,21 @@ int main(int argc, char *argv[]) {
                 enableIRQStatistic = true;
                 break;
             
+            case 'z':
+                enableUARTstd = true;
+                break;
+
+            case 'b':
+                if(!StringToUnsignedLongLong(optarg, &baudrate, NULL, 10)) {
+                    cerr << "baudrate is not a number" << endl;
+                    exit(1);
+                }
+                if(baudrate == 0) {
+                    cerr << "baudrate is zero" << endl;
+                    exit(1);
+                }
+                break;
+            
             default:
                 cout << Usage
                      << "Supported devices:" << endl
@@ -421,7 +445,46 @@ int main(int argc, char *argv[]) {
 
     if(sysConHandler.GetTraceState())
         dev1->trace_on = 1;
-    
+  
+    if (enableUARTstd){
+
+      struct inoserial_t {
+	char pin[3];
+	uint32_t baudrate;
+	char filename[2];
+      };
+
+
+      const struct inoserial_t inoserial_in = {"D0",baudrate,"-"};
+      const struct inoserial_t inoserial_out = {"D1",baudrate,"-"};
+
+      avr_message("Connecting file %s as serial in to pin %s at %d baud.",
+		  inoserial_in.filename,
+		  inoserial_in.pin,
+		  inoserial_in.baudrate);
+      
+      Net *netin = new Net();
+      SerialTxFile *serialin =
+	new SerialTxFile(inoserial_in.filename);
+      serialin->SetBaudRate(inoserial_in.baudrate);
+      netin->Add(dev1->GetPin(inoserial_in.pin));
+      netin->Add(serialin->GetPin("tx"));
+      
+
+      avr_message("Connecting pin %s as serial out to file %s at %d baud.",
+		  inoserial_out.pin,
+		  inoserial_out.filename,
+		  inoserial_out.baudrate);
+      
+      Net *netout = new Net();
+      SerialRxFile *serialout =
+	new SerialRxFile(inoserial_out.filename);
+      serialout->SetBaudRate(inoserial_out.baudrate);
+      netout->Add(dev1->GetPin(inoserial_out.pin));
+      netout->Add(serialout->GetPin("rx"));
+      
+    }
+  
     dman->start(); // start dump session
     
     if(gdbserver_flag == 0) { // no gdb