Gpc February 2013

gpc@gnu.de

5 participants
4 discussions

GPC with gcc-4.[23]
by Waldek Hebisch 18 Apr '13

18 Apr '13

I did some work on updating gpc to newer gcc versions. You can find it at GitHub: https://github.com/hebisch/gpc This is experimental work. 4.2 and 4.3 ports (on "master" Git branch) are basically in "works for my purpose" state: on my machine compiler builds and passes test suite with small (but nonzero) number of failures. On 4.5.1 there is initial port to gcc-4.[45] -- this one is broken from user point of view and may be of some use only for people who want to seriously work on the compiler. Note that this is _not_ a release. There are relatively easy to fix but non working things (in particular some features of Makefiles are broken). Testing was limited to running testsute just for one configuration. I estimate that fixing easily fixable stuff and polishing things would take me about a week -- unfortunately I am busy with other things. So I decided to make the code available "as is". If there will be bug reports, I will look at them and there is reasonable chance that I will fix them. But otherwise I do not plan to work on gpc in near future. If you want to try the code note that there are changes to build process, look at toplevel README file. -- Waldek Hebisch hebisch(a)math.uni.wroc.pl

4 15

Re: GPC compiler crash
by Garth Fletcher 19 Feb '13

19 Feb '13

Just to clarify the differences a bit. Space for a global variable is allocated when the program starts, essentially from the "heap" - which is the collection of available memory. Space for variables allocated by New() or NewPtr() are also allocated from the heap. These allocations can be released by using Dispose. For example: type myDataType = array... {defines the size of the structure} in the main program var myData : myDataType; {allocates a global structure in the heap} however, within a procedure or function procedure myProc; var localdata : myDataType; {allocates a LOCAL structure in the Stack} The reasoning is simple - the structure is local to that procedure or function, so the intent is to allocate it only as long as the procedure is executing. The Stack was a reasonable way to handle such local structures so that exiting the procedure, unstacks anything that was placed on it when the procedure is called and thus releases that allocated memory. This is OK only as long as the structures are small... The right way to handle local large structures is to explicitly allocate them upon entry to the procedure and then DEallocate them before exiting the procedure. For example: type myDataTypePtr : ^myDataType; procedure myProc; var localdataP : myDataTypePtr; {allocates a POINTER (4 or 8 bytes) on the stack} begin localdataP := NewPtr(sizeOf(myDataType)); {this allocates the structure on the heap, with localdataP} { pointing to that allocated space} {use the structure via localdataP^ } dispose(localdataP); {release the allocated memory} end; There is another gotcha - the difference between passing arguments "by reference" versus "by value". The former uses the VAR prefix to indicate that the procedure will have direct access to the actual data structure. The latter indicates that the called procedure will be given a copy of the original structure, i.e., a LOCAL copy. procedure myCalledProc (VAR byRef : myDataType; byVal : myDataType); "VAR byRef" specifies a POINTER to the original data to be passed on the Stack. The compiler takes care of converting any access to byRef within the procedure into a byRef^ and also of creating the pointer. "byVal" specifies a LOCAL COPY of the data structure to be passed on the Stack, which causes overflow if the copy is too big In other words, calling myCalledProc (myData, myData) creates a pointer to myData and passes that on the stack as byRef it also creates a complete copy of myData and passes that on the Stack as byVal. For big structures the difference is huge... I hope the above clarifies more than it confuses... -- Garth Fletcher

4 5

Re: GPC compiler crash
by Prof A Olowofoyeku (The African Chief) 19 Feb '13

19 Feb '13

Thomas Schneider wrote: >When I set it to 2003001 it compiles but gives a segmention fault even >though it's global. Maybe there's a limitation to allocating that >way? > >Then I switched dataprism to be a pointer using 'dataprism: >^trisquare;' as you suggested and changed the calls to be 'dataprism^' >(a rather cute trick!) and ... it compiles but still gives me a >segmentation fault! Actually, I was able to reproduce this crash. It happened at the point of "dispose (dataprism)". I changed the memory allocation/deallocation calls, and all works well (with "trimax=8006000"): procedure themain(var da: text); var dataprism: ^trisquare; (* the data structure for diana *) begin getmem (dataprism, sizeof (trisquare)); writeln(output,' trimdiana -gpc bug',version:4:2); writeprism(da, dataprism^); freemem (dataprism, sizeof (trisquare)); end; begin writeln ('sizeof trisquare=', sizeof (trisquare) div 1024 div 1024, 'mb'); themain(da); end. Best regards, The Chief -------- Prof. Abimbola A. Olowofoyeku (The African Chief) web: http://www.greatchief.plus.com/

3 5

GPC compiler crash
by Thomas Schneider 19 Feb '13

19 Feb '13

Folks: I discovered a program that crashes the GPC compiler, attached. Regards, Tom Thomas D. Schneider, Ph.D. Senior Investigator National Institutes of Health National Cancer Institute Frederick National Laboratory for Cancer Research Gene Regulation and Chromosome Biology Laboratory Molecular Information Theory Group Frederick, Maryland 21702-1201 schneidt(a)mail.nih.gov http://alum.mit.edu/www/toms

4 15

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

2000

1999

1998

1997

1996

1995

Gpc February 2013