[llvm-commits] CVS: llvm/runtime/GCCLibraries/crtend/Exception.cpp Exception.h Makefile README.txt SJLJ-Exception.cpp SJLJ-Exception.h comp_genericeh.lst comp_main.lst comp_sjljeh.lst crtend.c
Reid Spencer
reid at x10sys.com
Thu Nov 16 19:33:05 PST 2006
Changes in directory llvm/runtime/GCCLibraries/crtend:
Exception.cpp updated: 1.3 -> 1.4
Exception.h updated: 1.11 -> 1.12
Makefile updated: 1.35 -> 1.36
README.txt updated: 1.3 -> 1.4
SJLJ-Exception.cpp updated: 1.6 -> 1.7
SJLJ-Exception.h updated: 1.6 -> 1.7
comp_genericeh.lst updated: 1.2 -> 1.3
comp_main.lst updated: 1.2 -> 1.3
comp_sjljeh.lst updated: 1.2 -> 1.3
crtend.c updated: 1.7 -> 1.8
---
Log message:
Undo removal of the runtime libraries. While this may have been a bit
premature, these libraries will be going away for the 2.0 release. Other
arrangements for profiling, gc, etc. should be made in the next few months.
---
Diffs of the changes: (+484 -0)
Exception.cpp | 54 +++++++++++++++++++
Exception.h | 71 +++++++++++++++++++++++++
Makefile | 83 ++++++++++++++++++++++++++++++
README.txt | 15 +++++
SJLJ-Exception.cpp | 146 +++++++++++++++++++++++++++++++++++++++++++++++++++++
SJLJ-Exception.h | 80 +++++++++++++++++++++++++++++
comp_genericeh.lst | 9 +++
comp_main.lst | 3 +
comp_sjljeh.lst | 7 ++
crtend.c | 16 +++++
10 files changed, 484 insertions(+)
Index: llvm/runtime/GCCLibraries/crtend/Exception.cpp
diff -u /dev/null llvm/runtime/GCCLibraries/crtend/Exception.cpp:1.4
--- /dev/null Thu Nov 16 21:32:43 2006
+++ llvm/runtime/GCCLibraries/crtend/Exception.cpp Thu Nov 16 21:32:33 2006
@@ -0,0 +1,54 @@
+//===- Exception.cpp - Generic language-independent exceptions ------------===//
+//
+// This file defines the the shared data structures used by all language
+// specific exception handling runtime libraries.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Exception.h"
+
+// Thread local state for exception handling. FIXME: This should really be made
+// thread-local!
+
+// UncaughtExceptionStack - The stack of exceptions currently being thrown.
+static llvm_exception *UncaughtExceptionStack = 0;
+
+// __llvm_eh_has_uncaught_exception - This is used to implement
+// std::uncaught_exception.
+//
+bool __llvm_eh_has_uncaught_exception() throw() {
+ return UncaughtExceptionStack != 0;
+}
+
+// __llvm_eh_current_uncaught_exception - This function checks to see if the
+// current uncaught exception is of the specified language type. If so, it
+// returns a pointer to the exception area data.
+//
+void *__llvm_eh_current_uncaught_exception_type(unsigned HandlerType) throw() {
+ if (UncaughtExceptionStack->ExceptionType == HandlerType)
+ return UncaughtExceptionStack+1;
+ return 0;
+}
+
+// __llvm_eh_add_uncaught_exception - This adds the specified exception to the
+// top of the uncaught exception stack. The exception should not already be on
+// the stack!
+void __llvm_eh_add_uncaught_exception(llvm_exception *E) throw() {
+ E->Next = UncaughtExceptionStack;
+ UncaughtExceptionStack = E;
+}
+
+
+// __llvm_eh_get_uncaught_exception - Returns the current uncaught exception.
+// There must be an uncaught exception for this to work!
+llvm_exception *__llvm_eh_get_uncaught_exception() throw() {
+ return UncaughtExceptionStack;
+}
+
+// __llvm_eh_pop_from_uncaught_stack - Remove the current uncaught exception
+// from the top of the stack.
+llvm_exception *__llvm_eh_pop_from_uncaught_stack() throw() {
+ llvm_exception *E = __llvm_eh_get_uncaught_exception();
+ UncaughtExceptionStack = E->Next;
+ return E;
+}
Index: llvm/runtime/GCCLibraries/crtend/Exception.h
diff -u /dev/null llvm/runtime/GCCLibraries/crtend/Exception.h:1.12
--- /dev/null Thu Nov 16 21:33:05 2006
+++ llvm/runtime/GCCLibraries/crtend/Exception.h Thu Nov 16 21:32:33 2006
@@ -0,0 +1,71 @@
+//===- Exception.h - Generic language-independent exceptions ----*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the the shared data structures used by all language
+// specific exception handling runtime libraries.
+//
+// NOTE NOTE NOTE: A copy of this file lives in llvmgcc/libstdc++-v3/libsupc++/
+// Any modifications to this file must keep it in sync!
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef EXCEPTION_H
+#define EXCEPTION_H
+
+struct llvm_exception {
+ // ExceptionDestructor - This call-back function is used to destroy the
+ // current exception, without requiring the caller to know what the concrete
+ // exception type is.
+ //
+ void (*ExceptionDestructor)(llvm_exception *);
+
+ // ExceptionType - This field identifies what runtime library this exception
+ // came from. Currently defined values are:
+ // 0 - Error
+ // 1 - longjmp exception (see longjmp-exception.c)
+ // 2 - C++ exception (see c++-exception.c)
+ //
+ unsigned ExceptionType;
+
+ // Next - This points to the next exception in the current stack.
+ llvm_exception *Next;
+
+ // HandlerCount - This is a count of the number of handlers which have
+ // currently caught this exception. If the handler is caught and this number
+ // falls to zero, the exception is destroyed.
+ //
+ unsigned HandlerCount;
+
+ // isRethrown - This field is set on an exception if it has been 'throw;'n.
+ // This is needed because the exception might exit through a number of the
+ // end_catch statements matching the number of begin_catch statements that
+ // have been processed. When this happens, the exception should become
+ // uncaught, not dead.
+ //
+ int isRethrown;
+};
+
+enum {
+ ErrorException = 0,
+ SJLJException = 1,
+ CXXException = 2
+};
+
+// Language independent exception handling API...
+//
+extern "C" {
+ bool __llvm_eh_has_uncaught_exception() throw();
+ void *__llvm_eh_current_uncaught_exception_type(unsigned HandlerType) throw();
+ void __llvm_eh_add_uncaught_exception(llvm_exception *E) throw();
+
+ llvm_exception *__llvm_eh_get_uncaught_exception() throw();
+ llvm_exception *__llvm_eh_pop_from_uncaught_stack() throw();
+}
+
+#endif
Index: llvm/runtime/GCCLibraries/crtend/Makefile
diff -u /dev/null llvm/runtime/GCCLibraries/crtend/Makefile:1.36
--- /dev/null Thu Nov 16 21:33:05 2006
+++ llvm/runtime/GCCLibraries/crtend/Makefile Thu Nov 16 21:32:33 2006
@@ -0,0 +1,83 @@
+##===- runtime/GCCLibraries/crtend/Makefile ----------------*- Makefile -*-===##
+#
+# The LLVM Compiler Infrastructure
+#
+# This file was developed by the LLVM research group and is distributed under
+# the University of Illinois Open Source License. See LICENSE.TXT for details.
+#
+##===----------------------------------------------------------------------===##
+#
+# This directory contains the C and C++ runtime libraries for the LLVM GCC
+# front-ends. See the README.txt file for more details.
+#
+# Since this archive has strange requirements, we use some custom rules for
+# building it.
+#
+##===----------------------------------------------------------------------===##
+
+LEVEL = ../../..
+DONT_BUILD_RELINKED = 1
+LIBRARYNAME = crtend
+BYTECODE_DESTINATION = $(CFERuntimeLibDir)
+
+MainSrc := crtend.c
+GenericEHSrc := Exception.cpp
+SJLJEHSrc := SJLJ-Exception.cpp
+
+EXTRA_DIST := $(MainSrc) $(GenericEHSrc) $(SJLJEHSrc) \
+ comp_main.lst comp_genericeh.lst comp_sjljeh.lst
+
+include $(LEVEL)/Makefile.common
+
+MainObj := $(ObjDir)/crtend.bc
+GenericEHObj := $(ObjDir)/Exception.bc
+SJLJEHObj := $(ObjDir)/SJLJ-Exception.bc
+
+# __main and ctor/dtor support component
+$(ObjDir)/comp_main.bc: $(MainObj)
+ $(Echo) Linking $(notdir $@) component...
+ $(Verb) $(GCCLD) -link-as-library \
+ -internalize-public-api-file=$(PROJ_SRC_DIR)/comp_main.lst \
+ $(MainObj) -o $@
+
+# Generic exception handling support runtime.
+$(ObjDir)/comp_genericeh.bc: $(GenericEHObj)
+ $(Echo) Linking $(notdir $@) component...
+ $(Verb) $(GCCLD) -link-as-library \
+ -internalize-public-api-file=$(PROJ_SRC_DIR)/comp_genericeh.lst \
+ $(GenericEHObj) -o $@
+
+# setjmp/longjmp exception handling support runtime.
+$(ObjDir)/comp_sjljeh.bc: $(SJLJEHObj)
+ $(Echo) Linking $(notdir $@) component...
+ $(Verb) $(GCCLD) -link-as-library \
+ -internalize-public-api-file=$(PROJ_SRC_DIR)/comp_sjljeh.lst \
+ $(SJLJEHObj) -o $@
+
+SYMBOLHACKEDOBJS := $(ObjDir)/comp_main.bc $(ObjDir)/comp_genericeh.bc \
+ $(ObjDir)/comp_sjljeh.bc
+
+all-local:: $(LibName.BCA)
+
+ifdef BYTECODE_DESTINATION
+BytecodeDestDir := $(BYTECODE_DESTINATION)
+else
+BytecodeDestDir := $(PROJ_libdir)
+endif
+
+DestBytecodeLib = $(BytecodeDestDir)/lib$(LIBRARYNAME).a
+install-bytecode-local:: $(DestBytecodeLib)
+install-local:: $(DestBytecodeLib)
+
+$(LibName.BCA): $(SYMBOLHACKEDOBJS) $(LibDir)/.dir $(LLVMToolDir)/llvm-ar
+ $(Echo) Building $(BuildMode) Bytecode Archive $(notdir $@)
+ $(Verb) $(RM) -f $@
+ $(Verb) $(LArchive) $@ $(SYMBOLHACKEDOBJS)
+
+$(DestBytecodeLib): $(BytecodeDestDir) $(LibName.BCA)
+ $(Echo) Installing $(BuildMode) Bytecode Archive $(DestBytecodeLib)
+ $(Verb) $(DataInstall) $(LibName.BCA) $(DestBytecodeLib)
+
+uninstall-local::
+ $(Echo) Uninstalling $(BuildMode) Bytecode Archive $(DestBytecodeLib)
+ -$(Verb) $(RM) -f $(DestBytecodeLib)
Index: llvm/runtime/GCCLibraries/crtend/README.txt
diff -u /dev/null llvm/runtime/GCCLibraries/crtend/README.txt:1.4
--- /dev/null Thu Nov 16 21:33:05 2006
+++ llvm/runtime/GCCLibraries/crtend/README.txt Thu Nov 16 21:32:33 2006
@@ -0,0 +1,15 @@
+This directory contains the C and C++ runtime libraries for the LLVM GCC
+front-ends. It is composed of four distinct pieces:
+
+1. __main: now dead, but provided for compatibility.
+
+2. Generic EH support routines. This is used by C/C++ programs that use
+ setjmp/longjmp, and by C++ programs that make use of exceptions.
+
+3. setjmp/longjmp EH support. This is used by C/C++ programs that call SJLJ.
+
+4. C++ exception handling runtime support.
+
+These four components are compiled together into an archive file, so that
+applications using a subset of the four do not pull in unnecessary code and
+dependencies.
Index: llvm/runtime/GCCLibraries/crtend/SJLJ-Exception.cpp
diff -u /dev/null llvm/runtime/GCCLibraries/crtend/SJLJ-Exception.cpp:1.7
--- /dev/null Thu Nov 16 21:33:05 2006
+++ llvm/runtime/GCCLibraries/crtend/SJLJ-Exception.cpp Thu Nov 16 21:32:33 2006
@@ -0,0 +1,146 @@
+//===- SJLJ-Exception.cpp - SetJmp/LongJmp Exception Handling -------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the API used by the Setjmp/Longjmp exception handling
+// runtime library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "SJLJ-Exception.h"
+#include <cstdlib>
+#include <cassert>
+
+// Assert should only be used for debugging the runtime library. Enabling it in
+// CVS will break some platforms!
+#undef assert
+#define assert(X)
+
+// get_sjlj_exception - Adjust the llvm_exception pointer to be an appropriate
+// llvm_sjlj_exception pointer.
+inline llvm_sjlj_exception *get_sjlj_exception(llvm_exception *E) {
+ assert(E->ExceptionType == SJLJException);
+ return (llvm_sjlj_exception*)(E+1) - 1;
+}
+
+// SetJmpMapEntry - One entry in a linked list of setjmps for the current
+// function.
+struct SetJmpMapEntry {
+ void *JmpBuf;
+ unsigned SetJmpID;
+ SetJmpMapEntry *Next;
+};
+
+// SJLJDestructor - This function is used to free the exception when
+// language-indent code needs to destroy the exception without knowing exactly
+// what type it is.
+static void SJLJDestructor(llvm_exception *E) {
+ free(get_sjlj_exception(E));
+}
+
+
+// __llvm_sjljeh_throw_longjmp - This function creates the longjmp exception and
+// returns. It takes care of mapping the longjmp value from 0 -> 1 as
+// appropriate. The caller should immediately call llvm.unwind after this
+// function call.
+void __llvm_sjljeh_throw_longjmp(void *JmpBuffer, int Val) throw() {
+ llvm_sjlj_exception *E =
+ (llvm_sjlj_exception *)malloc(sizeof(llvm_sjlj_exception));
+ E->BaseException.ExceptionDestructor = SJLJDestructor;
+ E->BaseException.ExceptionType = SJLJException;
+ E->BaseException.HandlerCount = 0;
+ E->BaseException.isRethrown = 0;
+ E->JmpBuffer = JmpBuffer;
+ E->LongJmpValue = Val ? Val : 1;
+
+ __llvm_eh_add_uncaught_exception(&E->BaseException);
+}
+
+// __llvm_sjljeh_init_setjmpmap - This funciton initializes the pointer provided
+// to an empty setjmp map, and should be called on entry to a function which
+// calls setjmp.
+void __llvm_sjljeh_init_setjmpmap(void **SetJmpMap) throw() {
+ *SetJmpMap = 0;
+}
+
+// __llvm_sjljeh_destroy_setjmpmap - This function frees all memory associated
+// with the specified setjmpmap structure. It should be called on all exits
+// (returns or unwinds) from the function which calls ...init_setjmpmap.
+void __llvm_sjljeh_destroy_setjmpmap(void **SetJmpMap) throw() {
+ SetJmpMapEntry *Next;
+ for (SetJmpMapEntry *SJE = *(SetJmpMapEntry**)SetJmpMap; SJE; SJE = Next) {
+ Next = SJE->Next;
+ free(SJE);
+ }
+}
+
+// __llvm_sjljeh_add_setjmp_to_map - This function adds or updates an entry to
+// the map, to indicate which setjmp should be returned to if a longjmp happens.
+void __llvm_sjljeh_add_setjmp_to_map(void **SetJmpMap, void *JmpBuf,
+ unsigned SetJmpID) throw() {
+ SetJmpMapEntry **SJE = (SetJmpMapEntry**)SetJmpMap;
+
+ // Scan for a pre-existing entry...
+ for (; *SJE; SJE = &(*SJE)->Next)
+ if ((*SJE)->JmpBuf == JmpBuf) {
+ (*SJE)->SetJmpID = SetJmpID;
+ return;
+ }
+
+ // No prexisting entry found, append to the end of the list...
+ SetJmpMapEntry *New = (SetJmpMapEntry *)malloc(sizeof(SetJmpMapEntry));
+ *SJE = New;
+ New->JmpBuf = JmpBuf;
+ New->SetJmpID = SetJmpID;
+ New->Next = 0;
+}
+
+// __llvm_sjljeh_is_longjmp_exception - This function returns true if the
+// current uncaught exception is a longjmp exception. This is the first step of
+// catching a sjlj exception.
+bool __llvm_sjljeh_is_longjmp_exception() throw() {
+ return __llvm_eh_current_uncaught_exception_type(SJLJException) != 0;
+}
+
+// __llvm_sjljeh_get_longjmp_value - This function returns the value that the
+// setjmp call should "return". This requires that the current uncaught
+// exception be a sjlj exception, though it does not require the exception to be
+// caught by this function.
+int __llvm_sjljeh_get_longjmp_value() throw() {
+ llvm_sjlj_exception *E =
+ get_sjlj_exception(__llvm_eh_get_uncaught_exception());
+ return E->LongJmpValue;
+}
+
+// __llvm_sjljeh_try_catching_longjmp_exception - This function checks to see if
+// the current uncaught longjmp exception matches any of the setjmps collected
+// in the setjmpmap structure. If so, it catches and destroys the exception,
+// returning the index of the setjmp which caught the exception. If not, it
+// leaves the exception uncaught and returns a value of ~0.
+unsigned __llvm_sjljeh_try_catching_longjmp_exception(void **SetJmpMap) throw(){
+ llvm_sjlj_exception *E =
+ get_sjlj_exception(__llvm_eh_get_uncaught_exception());
+
+ // Scan for a matching entry in the SetJmpMap...
+ SetJmpMapEntry *SJE = *(SetJmpMapEntry**)SetJmpMap;
+ for (; SJE; SJE = SJE->Next)
+ if (SJE->JmpBuf == E->JmpBuffer) {
+ // "Catch" and destroy the exception...
+ __llvm_eh_pop_from_uncaught_stack();
+
+ // We know it's a longjmp exception, so we can just free it instead of
+ // calling the destructor.
+ free(E);
+
+ // Return the setjmp ID which we should branch to...
+ return SJE->SetJmpID;
+ }
+
+ // No setjmp in this function catches the exception!
+ return ~0;
+}
Index: llvm/runtime/GCCLibraries/crtend/SJLJ-Exception.h
diff -u /dev/null llvm/runtime/GCCLibraries/crtend/SJLJ-Exception.h:1.7
--- /dev/null Thu Nov 16 21:33:05 2006
+++ llvm/runtime/GCCLibraries/crtend/SJLJ-Exception.h Thu Nov 16 21:32:33 2006
@@ -0,0 +1,80 @@
+//===- SJLJ-Exception.h - SetJmp/LongJmp Exception Handling -----*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the data structures and API used by the Setjmp/Longjmp
+// exception handling runtime library.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SJLJ_EXCEPTION_H
+#define SJLJ_EXCEPTION_H
+
+#include "Exception.h"
+
+struct llvm_sjlj_exception {
+ // JmpBuffer - This is the buffer which was longjmp'd with.
+ //
+ void *JmpBuffer;
+
+ // LongJmpValue - The value passed into longjmp, which the corresponding
+ // setjmp should return. Note that this value will never be equal to 0.
+ //
+ int LongJmpValue;
+
+ // BaseException - The language independent portion of the exception state.
+ // This is at the end of the record so that we can add additional members to
+ // this structure without breaking binary compatibility.
+ //
+ llvm_exception BaseException;
+};
+
+extern "C" {
+ // __llvm_sjljeh_throw_longjmp - This function creates the longjmp exception
+ // and returns. It takes care of mapping the longjmp value from 0 -> 1 as
+ // appropriate. The caller should immediately call llvm.unwind after this
+ // function call.
+ void __llvm_sjljeh_throw_longjmp(void *JmpBuffer, int Val) throw();
+
+ // __llvm_sjljeh_init_setjmpmap - This funciton initializes the pointer
+ // provided to an empty setjmp map, and should be called on entry to a
+ // function which calls setjmp.
+ void __llvm_sjljeh_init_setjmpmap(void **SetJmpMap) throw();
+
+ // __llvm_sjljeh_destroy_setjmpmap - This function frees all memory associated
+ // with the specified setjmpmap structure. It should be called on all exits
+ // (returns or unwinds) from the function which calls ...init_setjmpmap.
+ void __llvm_sjljeh_destroy_setjmpmap(void **SetJmpMap) throw();
+
+ // __llvm_sjljeh_add_setjmp_to_map - This function adds or updates an entry to
+ // the map, to indicate which setjmp should be returned to if a longjmp
+ // happens.
+ void __llvm_sjljeh_add_setjmp_to_map(void **SetJmpMap, void *JmpBuf,
+ unsigned SetJmpID) throw();
+
+ // __llvm_sjljeh_is_longjmp_exception - This function returns true if the
+ // current uncaught exception is a longjmp exception. This is the first step
+ // of catching a sjlj exception.
+ bool __llvm_sjljeh_is_longjmp_exception() throw();
+
+ // __llvm_sjljeh_get_longjmp_value - This function returns the value that the
+ // setjmp call should "return". This requires that the current uncaught
+ // exception be a sjlj exception, though it does not require the exception to
+ // be caught by this function.
+ int __llvm_sjljeh_get_longjmp_value() throw();
+
+ // __llvm_sjljeh_try_catching_longjmp_exception - This function checks to see
+ // if the current uncaught longjmp exception matches any of the setjmps
+ // collected in the setjmpmap structure. If so, it catches and destroys the
+ // exception, returning the index of the setjmp which caught the exception.
+ // If not, it leaves the exception uncaught and returns a value of ~0.
+ unsigned __llvm_sjljeh_try_catching_longjmp_exception(void **SetJmpMap)
+ throw();
+}
+
+#endif
Index: llvm/runtime/GCCLibraries/crtend/comp_genericeh.lst
diff -u /dev/null llvm/runtime/GCCLibraries/crtend/comp_genericeh.lst:1.3
--- /dev/null Thu Nov 16 21:33:05 2006
+++ llvm/runtime/GCCLibraries/crtend/comp_genericeh.lst Thu Nov 16 21:32:33 2006
@@ -0,0 +1,9 @@
+__main
+llvm.global_ctors
+llvm.global_dtors
+
+__llvm_eh_has_uncaught_exception
+__llvm_eh_current_uncaught_exception_type
+__llvm_eh_add_uncaught_exception
+__llvm_eh_get_uncaught_exception
+__llvm_eh_pop_from_uncaught_stack
Index: llvm/runtime/GCCLibraries/crtend/comp_main.lst
diff -u /dev/null llvm/runtime/GCCLibraries/crtend/comp_main.lst:1.3
--- /dev/null Thu Nov 16 21:33:05 2006
+++ llvm/runtime/GCCLibraries/crtend/comp_main.lst Thu Nov 16 21:32:33 2006
@@ -0,0 +1,3 @@
+__main
+llvm.global_ctors
+llvm.global_dtors
Index: llvm/runtime/GCCLibraries/crtend/comp_sjljeh.lst
diff -u /dev/null llvm/runtime/GCCLibraries/crtend/comp_sjljeh.lst:1.3
--- /dev/null Thu Nov 16 21:33:05 2006
+++ llvm/runtime/GCCLibraries/crtend/comp_sjljeh.lst Thu Nov 16 21:32:33 2006
@@ -0,0 +1,7 @@
+__llvm_sjljeh_throw_longjmp
+__llvm_sjljeh_init_setjmpmap
+__llvm_sjljeh_destroy_setjmpmap
+__llvm_sjljeh_add_setjmp_to_map
+__llvm_sjljeh_is_longjmp_exception
+__llvm_sjljeh_get_longjmp_value
+__llvm_sjljeh_try_catching_longjmp_exception
Index: llvm/runtime/GCCLibraries/crtend/crtend.c
diff -u /dev/null llvm/runtime/GCCLibraries/crtend/crtend.c:1.8
--- /dev/null Thu Nov 16 21:33:05 2006
+++ llvm/runtime/GCCLibraries/crtend/crtend.c Thu Nov 16 21:32:33 2006
@@ -0,0 +1,16 @@
+/*===- crtend.c - Initialization code for programs ------------------------===*\
+ *
+ * The LLVM Compiler Infrastructure
+ *
+ * This file was developed by the LLVM research group and is distributed under
+ * the University of Illinois Open Source License. See LICENSE.TXT for details.
+ *
+ *===----------------------------------------------------------------------===*
+ *
+ * This file defines the __main function, which we preserve for backwards
+ * compatibility.
+ *
+\*===----------------------------------------------------------------------===*/
+
+void __main(void) {
+}
More information about the llvm-commits
mailing list