How do I compile and run a VHDL program on Mac with ghdl?

Question

i just wrote a simple VHDL program. I saved the file as a .vhd file. Then I compiled it with

ghdl -a test.vhd

and then built and executable file with

ghdl -e test

And finally tried to run it with

ghdl -r test

What happened is that I now have a work-obj93.cf file that is visible and two other files, namely .. and . that are somehow invisible.

Can someone tell how exactly I can test a vhdl program on my Mac? Maybe in in combination with GTKWave.

Halbeib

you can ignore the .. and . files. they already existed. the . means the current directory (so ./dostuff means execute the dostuff binary that is in the current directory). .. is the same thing, only with the parent directory. for example: cd .. would take you one directory up – Waterless

@Russell Uhl Hey, thanks! But what exactly are those .and ..files?? I have never seen them before. – Halbeib

they are a way to navigate directories in a console. They are not really files. – Cinchona

@Cinchona Any idea how i can get ghdl work on my mac? – Halbeib

Sorry, I have not used ghdl a lot, nor have I ever used a mac for a prolonged time. I usually use Modelsim on windows or fedora FEL. – Cinchona

same. No idea how ghdl works. I just saw you were wondering what those . and .. things were. Sorry :/ – Waterless

Docs at: ghdl.readthedocs.io/en/latest/… pointed from README source github.com/tgingold/ghdl – Repressive

Answer 1

That as they say is a big ask!

There's a version of ghdl for OS X running on Intel processors for versions 10.5, 10.6,10.7 and 10.8 available from ghdl.free.fr (can be downloaded at GHDL for Mac OS X). It's the mcode version (like on Windows), which means it doesn't produce object codes or a standalone executable of a VHDL model with the consequence you can't bind foreign objects (subprograms) to the model.

The elaborated model only exists in memory at run time and the -e elaborate command is superfluous other than an entry in the working library .cf file. In an mcode version of ghdl the -r run command also elaborates. All you are going to see is the work-obj93.cf file for the working directory and any .cf files for pre-analyzed libraries, by default these will show up in /usr/local/ghdl/libraries, the executable ghdl found in /usr/local/bin links to /usr/local/ghdl/translate/ghdldrv/ghdl_mcode, and /usr/local/ghdl is a stripped down tree resulting from the compilation of the ghdl_mcode version.

This version is derived from svn129 (following the ghdl-0.29 release), and contains an i386 binary.

The documentation for ghdl is found in /usr/local/ghdl/doc/, there's the ghdl man page which is linked elsewhere, ghdl.html and ghdl.texi which are the ghdl manual and not linked elsewhere. In ghdl.html you could search for every occurrence of 'Windows' to find reference to the mcode version. As an oversight I didn't think to amend the ghdl manual to include the word mcode wherever Windows appeared and release modified manual.

Where ever 'Windows' appears it should be read as 'Windows or other mcode version'.

In the ghdl manual see 1.3 What is GHDL?, (The Windows(TM) version of GHDL is not based on GCC but on an internal code generator). Also 2.1 The hello world program:

2.1 The hello world program

To illustrate the large purpose of VHDL, here is a commented VHDL "Hello world" program.

 --  Hello world program.
 use std.textio.all; --  Imports the standard textio package.

 --  Defines a design entity, without any ports.
 entity hello_world is
 end hello_world;

 architecture behaviour of hello_world is
 begin
    process
       variable l : line;
    begin
       write (l, String'("Hello world!"));
       writeline (output, l);
       wait;
    end process;
 end behaviour;

Suppose this program is contained in the file hello.vhdl. First, you have to compile the file; this is called analysis of a design file in VHDL terms.

 $ ghdl -a hello.vhdl

This command creates or updates a file work-obj93.cf, which describes the library ‘work’. On GNU/Linux, this command generates a file hello.o, which is the object file corresponding to your VHDL program. The object file is not created on Windows.

Then, you have to build an executable file.

 $ ghdl -e hello_world

The ‘-e’ option means elaborate. With this option, GHDL creates code in order to elaborate a design, with the ‘hello’ entity at the top of the hierarchy.

On GNU/Linux, the result is an executable program called hello which can be run:

 $ ghdl -r hello_world

or directly:

 $ ./hello_world

On Windows, no file is created. The simulation is launched using this command:

 > ghdl -r hello_world

The result of the simulation appears on the screen:

 Hello world!

Saving the source code for the hello_world command to the file hello.vhdl and executing the commands:

david_koontz@Macbook: ghdl -a hello.vhdl

david_koontz@Macbook: ghdl -e hello_world

david_koontz@Macbook: ghdl -r hello_world

Yields:

Hello world!

on standard output (the TTY session in your terminal window).

You'll end up with a work-obj93.cf library configuration file in the current working directory and no other output files. You'll also want to understand the implications of the -r run command (section 3.1.3), with no optional secondary unit passed on the command line VHDL defaults to the last compiled architecture.

Obtaining Tony Bybell's gtkwave gtkwave.app, the documentation is found in /Applications/gtkwave.app/Contents/Resources/doc, both a source .odt file and a PDF file. (You can select an application in the Applications folder and 'Show Package Contents' to navigate to the doc directory).

There's a waveform format unique to ghdl called ghw, which can be invoked with the run command option '--wave=.ghw'. See ghdl manual 4.1 Simulation options. Also see the vcd options in that directory should you choose to use VCD instead.

You should also limit the run time duration with a guard timer should your test bench provide a free running clock. VHDL will only stop executing when either ther are no more scheduled signal updates or execution time maxes out. This is a run command option along the lines of '--stop-time=587200ns'.

The OS X gtkwave.app is sensitive to two file types with extensions .ghw and .gtkw, the first the ghdl waveform dump file, the second gtkwave's configuration file with an OS X suffix allowing invocation of gtkwave by clicking on the gtkw file. The configuration file has to be saved after setting up your wave form display in gtkwave before it exists. See the gtkwave manual. A ghw file can be clicked on and gtkwave has a set of rules used to search for the applicable gtkw file.

There are a couple of advantages to using the ghw file format. The automatic invocation of the gtkwave app by clicking on files is one. Another is that ghdl saves all signal transactions to it's ghw dump file. You can always select more in gtkwave to display more information. While this can be a disadvantage in large models the ghw format allows any type or subtype enumeration literal display.

Joining the GHDL discuss list and posting a question is a good way to attract ghdl expertise attention. (And yes the certificate for gna.org is expired or otherwise invalid). Tony Bybell provides an email contact on the gtkwave web page but exigencies of paid employment limit his availability.

---

Elaborating the use of ghdl and gtkwave with an example.

The original poster asked for some real examples with command line values. There's a however poor GHDL/GTKWave Tutorial (PDF, 234 KB) that contains an example and used VCD.

I'll list the command lines for a GHDL Waveform format version:

david_koontz@Macbook: ghdl -a CarryRipple.vhd

david_koontz@Macbook: ghdl -a CarryRipple_tb.vhd

david_koontz@Macbook: ghdl -e carryRipple_tb

david_koontz@Macbook: ghdl -r carryRipple_tb --wave=carryRipple_tb.ghw

invoking gtkwave.app can either be done by clicking on the resulting carryRipple_tb.ghw or by using OS X's open command:

david_koontz@Macbook: open -a gtkwave carryRipple_tb.ghw

Gtkwave's SST window (upper left) will display top, expand by clicking the + box. Do the same for the revealed carryripple_tb. Click a. In the signals window select a[3:0] and hit the insert button. Repeat for b.

In the SST window select U0 and then in the signals window select cin hit the insert button then the same for cout.

In the SST window select s, and in the signals window select s[3:0] and hit insert.

And yes getting the source for the two VHDL files from the 'tutorial' was painful. I didn't do it.

You might also note the assignment of 'X' to Cin at 60 ns in the gtkwave display, I did it to show the last values assigned in the testbench.

I wouldn't claim it's a good tutorial, but you're getting what you paid for here. Doing better would have been a bigger ask.

The test bench (carryRipple_tb.vhd) provides stimulous to drive the model (CarryRipple.vhd) during simulation. The model quits executing after the last signal event so no stop time need be passed to the run command ( e.g. --stop-time=587200ns).

There's also a five part GHDL/GTKWave Tutorial on Youtube by Chad Kersey. The resolution isn't so good and it's Linux centric. Part 0 is about installing the two tools. The only real difference in my example is using the ghw waveform format. Most browsers will allow you to see the gtkwave window shot below at full size.

added

There's a recent answer showing a demonstration with a Toggle Flip Flop, showing an error in the original VHDL code, and three possible fixes. It uses configuration declarations to run the various fixed versions. See how to avoid delay in the output of simple process statement in VHDL.

Quodlibet

And a check shows that the gtkwave.app also claims the file extension .vcd on OS X for Vector Change Dump waveform dump files. – Quodlibet

Thanks! But could you add some more examples on how to actually run a ghdl program and display the waves with gtkwave? I mean like some command line input, that would be great and help me get going! – Halbeib

Ask and you shall receive, although I didn't type in the code from the example I found and it's a pain to extract from the PDF. See the answer at 'Elaborating the use of ghdl and gtkwave with an example.' And yes it's 7 degrees C and raining. And, Oh the tree in the SST window will be shown differently for a ghw waveform file versus a VCD file. Don't forget to write the save file after you've inserted all your signals in the waveform. I'd encourage both reading the manual for gtkwave as well as experimenting. – Quodlibet

Hey, thanks again! However, I still have problems. Let me tell you what I am doing: – Halbeib

Hey, thanks again! Here it goes: First, I just have my .vhd file, called my file.vhd. Then I run ghdl -a myfile.vhd , which creates a work-obj93.cf file. Then I run ghdl -e myfile, which does nothing. Finally I run ghdl -r myfile --wave=myfile.ghw, which creates a file called myfile.ghw. After that I double click on that file and gtkwave opens. The problem is, however, that nothing shows up. In the title of the gtkwave it just says GTKWave - [no file loaded]. – Halbeib

'no file loaded' will be displayed for a dumpfile with no contents. (Try touch foo.ghw, click on foo.ghw in Finder). This would reflect your model not executing (generating signal updates) or a problem working in the terminal window. Also once you get a display of your waveform dump file name gtkwave needs to be initialized to display wave forms. You select the portions of the design you want to look at in the SST window, and select actual signals to display in the waveform window in the signals window by using the insert button. – Quodlibet

Transactions on variables won't show up in a waveform dump file. Variable assignment is immediate and doesn't consume model simulation time. Try opening another question with your file.vhd explicitly included (show the code). – Quodlibet

Answer 2

A New Mac OS X gcc version of GHDL

There's a new version of ghdl available from ghdl-updates / Builds / ghdl-0.31 / OSX, a gcc version that includes the mcode verison.

It's only known to run on OS X 10.9 but I think it would run OS X 10.8 if Xcode and it's command line tools were installed - the gcc version currently depends on /usr/bin/as and /usr/bin/ld, which are part of the essentials package installing OS X 10.9 and available by installing Xcode command line tools on OS X 10.8.

Once this version of ghdl is installed, in a terminal you can

info ghdl

Scroll down to Starting with GHDL, hitting carriage return. Scroll down to The hello world program (carriage return), A full adder (carriage return), or Starting with a design (carriage return). The first one is a VHDL hello world program, the second one is a one bit adder with a test bench. The Starting with a design leads you to a download link and directions for a DLX processor simulation.

I'm planning to develop a 10.6 - 10.9 gcc version of ghdl that doesn't depend on Xcode for 10.6 - 10.8, and runs on 10.9. It'll likely be version 0.32 of ghdl.

Tony Bybell's gtkwave.app runs on OS X 10.6 - 10.9 and is available along with it's manual from the GTKWave SourceForge page. The latest version of the application can be downloaded from this link on Sourceforge - gtkwave.zip.

There are several ghdl/gtkwave tutorials available on YouTube, although none are OS X specific, try googling.

ghdl has it's own gtkwave format, GHW which is VHDL friendly and allows you to peer into complex composite types. ghdl-0.33 will likely include support for Tony Bybell's FSB format as well.

The more adventuresome can build ghdl from scratch on OS X, see Instructions for building ghdl-0.31 with gcc4.8.2 on OS X 10.9. Building with gcc4.9.1 would require the ghdl-0.32 release available from the Mercurial archive found here. When released version ghdl-0.32 binaries will also be available from Sourceforge.

The Sourceforge site ghdl-updates is the location for on going ghdl development activity by the author of ghdl, Tristan Gingold.

In addition to joining the ghdl discussion list or perusing it's archives you can file bug reports on the ghdl-updates Tickets page, where you view both open and closed issues.

The development future for ghdl is bright. Future releases are expected to focus on IEEE Std 1076-2008 compliance for the near future. There's also development toward using ghdl as an llvm front end as well as a purely interpretive version to supplant ghdl-mcode.

It's possible with binary releases of ghdl and gtkwave to separate user from developer.

Quodlibet

Answer 3

I use UMHDL on my MacOS High Sierra and it works like a charm.

Was tricky to bind GHDL and GTKWave to UMHDL although but i got it.

Furst

Answer 4

I don't know if this is exactly relevant to this discussion. However, I am excited that I managed to install GHDL on my Mac, El Capitan today. I downloaded the latest GHDL version from ghdl.free.fr for mac and everything installed okay. I did get a message saying that the object files were a newer format or something along those lines. Still, my vhdl code compiled.

I did have an issue trying to compile a test bench for said vhdl code. When I compiled them separately I got error messages. When I compiled them together, that is

ghdl -a code.vhdl code_tb.vhdl

everything worked as you would expect it to.

ghdl -e code_tb 

worked and so did

ghdl -r code_tb --vcd=code.vcd 

So maybe there was an issue with how the vhdl was compiled. In my case, unlike in Ubuntu, I had to analyze code.vhdl and code_tb.vhdl together. Perhaps this may be useful to future readers.

Rumen