--- llvm-2.4.orig/debian/llvm.binfmt +++ llvm-2.4/debian/llvm.binfmt @@ -0,0 +1,3 @@ +package llvm +interpreter /usr/bin/lli +magic llvc --- llvm-2.4.orig/debian/changelog +++ llvm-2.4/debian/changelog @@ -0,0 +1,329 @@ +llvm (2.4-1~exp1ubuntu2) jaunty; urgency=low + + * Fix problem with static initialization order (Robert Schuster). + + -- Matthias Klose Wed, 28 Jan 2009 11:49:15 +0100 + +llvm (2.4-1~exp1ubuntu1) jaunty; urgency=low + + * Fix build failure on armel. ARM EABI doesn't have __register_frame. + + -- Matthias Klose Tue, 20 Jan 2009 16:07:54 +0100 + +llvm (2.4-1~exp1) experimental; urgency=low + + * Backport from mainline: + - 0007-Separate-alpha-asmprinter.-This-should-unbreak-nativ.patch. + - 0008-Separate-sparc-asmprinter.-This-should-unbreak-the-n.patch. + * debian/debhelper.in/llvm-dev.install: Also install configure, + config.status and autoconf/ in /usr/lib/llvm/build, will be required + to build clang. + * debian/debhelper.in/llvm.postinst, debian/debhelper.in/llvm.prerm: + Remove full path for update-binfmts. + + -- Arthur Loiret Mon, 24 Nov 2008 20:39:24 +0000 + +llvm (2.4-1~exp0) experimental; urgency=low + + * New upstream release. Closes: #505394 + - Update patches. + * debian/rules: + - Support DEB_BUILD_OPTIONS=parallel=n. + - Depect cpu number and run parallel build by default. + * debian/rules.d/binary.mk: Remove extra license file. + * debian/rules.d/unpack.mk: Really unpatch sources on clean. + * debian/control: Bump Standards-Version to 3.8.0. + * Merge changes between versions 2.2-9 and 2.2-12. + + -- Arthur Loiret Sat, 22 Nov 2008 10:43:59 +0000 + +llvm (2.3-1~exp0) experimental; urgency=low + + * New upstream release. Closes: #489255 + - Update patches. + * debian/debhelper.in/llvm.install: No more config files. + + -- Arthur Loiret Tue, 08 Jul 2008 18:42:51 +0000 + +llvm (2.2-12) unstable; urgency=low + + * 4 revisions to fix debian/control, how lame am I… + Properly update debian/control.in/llvm-examples. + + -- Pierre Habouzit Mon, 13 Oct 2008 10:02:55 +0200 + +llvm (2.2-11) unstable; urgency=low + + * +~ sorts before +bX which defeats its purpose. Use +c~ to be sorted + _after_ binNMUs. + + -- Pierre Habouzit Sun, 12 Oct 2008 18:49:45 +0200 + +llvm (2.2-10) unstable; urgency=high + + * New upload to fix previous borked one. + + -- Pierre Habouzit Sun, 05 Oct 2008 16:19:21 +0200 + +llvm (2.2-9) unstable; urgency=high + + * Make llvm bin-NMU friendly (Closes: #499469). + + -- Pierre Habouzit Sun, 05 Oct 2008 09:37:52 +0200 + +llvm (2.2-8) unstable; urgency=high + + * Run testsuite on kfreebsd-i386 and kfreebsd-amd64 as well. + * Don't append LLVM_DEBIAN_INFO to llvm-config. Closes: #481967 + + -- Arthur Loiret Sat, 28 Jun 2008 16:11:48 +0000 + +llvm (2.2-7) unstable; urgency=high + + * Fix i386-only FTBFS due to missing #include (Closes: 474863). + + -- Pierre Habouzit Sun, 20 Apr 2008 21:40:59 +0200 + +llvm (2.2-6) unstable; urgency=low + + [ Arthur Loiret ] + * Don't build llvm-stub: Closes: #468339 + - patches/0007-Disable-llvm-stub.patch: Add. + - debhelper.in/llvm.links: Update. + * Run the testsuite on amd64 i386 ia64 powerpc s390 sparc only. + + [ Pierre Habouzit ] + * Update patches/0006-Build-with-g-4.3.patch with missing hunk. + (Closes: 417382). + + -- Pierre Habouzit Sun, 06 Apr 2008 00:33:49 +0200 + +llvm (2.2-5) unstable; urgency=low + + * brown paper bag bug, fix llvm-examples.links reordering arguments + (Closes: 470409). + + -- Pierre Habouzit Tue, 11 Mar 2008 10:03:09 +0100 + +llvm (2.2-4) unstable; urgency=low + + [ Pierre Habouzit ] + * debian/control: + + Missing Provides: llvm-libs in llvm-dev Package. + * patches/0005-Build-LLVM-with-O2.patch: build llvm with -O2 to ease + buildd's life. + * Install Makefile.{common,config,rules} in /usr/lib/llvm/build. + * Add links to the Makefiles from llvm-examples (Closes: 469531). + * Rework dependency chains: + + llvm-example depends llvm-dev. + + llvm-dev depends llvm. + + llvm depends nothing, but recommends llvm-dev. + * patches/0006-Build-with-g-4.3.patch: add patch to build with g++-4.3 + (Closes: 417382). + + [ Arthur Loiret ] + * Use logwatch script from gcc to prevent testsuite timeouts. + + -- Pierre Habouzit Mon, 10 Mar 2008 13:22:45 +0100 + +llvm (2.2-3) unstable; urgency=low + + [ Arthur Loiret ] + * 0004-Fix-TOOLDIR-path-for-gccas-and-gccld.patch: Add. Closes: #468341 + * debian/debhelper.in/llvm-doc.install: don't install html.tar.gz, already + in untared html dir. Closes: #468338 + * Rename llvm-libs to llvm-dev and include headers in it. Closes: #468344 + + [ Pierre Habouzit ] + * Fix postinst/prerm binfmts registration for chroots. + + -- Pierre Habouzit Mon, 03 Mar 2008 01:21:00 +0100 + +llvm (2.2-2) unstable; urgency=low + + [ Arthur Loiret ] + * Don't Build-Depends on graphviz, not needed. + * Run testsuite by default. + * 0001-Update-configure-script-for-kfreebsd-gnu-and-hurd.patch: New, + fix FTBFS on kfreebsd-gnu and hurd. + * 0002-Fix-llvm-config-script.patch: New, fix lib and include paths. + * 0003-Debian-version-info-and-bugreport.patch: New, mention Debian revision + in --version, update bugreport contact (set to pkg-llvm mailling list). + + -- Pierre Habouzit Fri, 22 Feb 2008 14:04:39 +0100 + +llvm (2.2-1) unstable; urgency=low + + [ Pierre Habouzit ] + * New upstream release. + * debian/debhelper.in/llvm-examples.examples: add missing file so that + llvm-examples isn't empty. + * debian/debhelper.in/llvm.{preinst,postinst}: use binfmt-support to + register llvm.binfmts properly. + + [ Arthur Loiret ] + * debian/debhelper.in/llvm.install: Remove libs, + * debian/rules.d/build.mk: Remove extra-license-file. + + -- Pierre Habouzit Tue, 12 Feb 2008 11:11:34 +0100 + +llvm (2.1.99-20080209-2) experimental; urgency=low + + * Reinstate lost crhpath to remove unsafe rpath. + + -- Pierre Habouzit Sun, 10 Feb 2008 02:35:19 +0100 + +llvm (2.1.99-20080209-1) experimental; urgency=low + + [ Arthur Loiret ] + * New Maintainers. Closes: #451106, #451384, #449355 + * New upstream release, new build system (again). + * debian/control.in/llvm-gcc: + + Update llvm-gcc description. Closes: #441382 + * debian/copyright: Update. + + [ Pierre Habouzit ] + * debian/control.in/source, debian/control: + + add Vcs-* headers. + * Bump compat to 6. + + -- Arthur Loiret Thu, 07 Feb 2008 15:22:43 +0100 + +llvm (2.1-0~exp1) experimental; urgency=low + + [ Arthur Loiret ] + * Initial llvm2 upload, the packaging is not over yet and we need to test a + few things before uploading it to unstable. Closes will be added then. + * Remove dpatch from build-depends, not used anymore. + * New build system. + + [ Pierre Habouzit ] + * debian/control: + + Remove version for doxygen build-depends as it's not even in oldstable. + + Bump Standards-Version to 3.7.3. + + Add Homepage field. + + -- Pierre Habouzit Mon, 07 Jan 2008 15:09:16 +0100 + +llvm (1.8b-1) unstable; urgency=low + + * Closes: bug#356095: missing llvmc from package (over-zealous cleanup + was removing it) + * Replace entire C front-end (CFE)with latest from CVS (as recommended by + upstream); this will get re-synced with the 1.9 release. + * Re-enable amd64 build. + * Closes: bug#380151 -- FTBFS on ia64 and amd64; new CFE fixes ia64, + but amd64 is hacked back in and not officially supported upstream. + * Closes: bug#389300 -- ia64/unstable FTBFS: compile errors (duplicate) + * Closes: bug#394883 -- ia64/unstable FTBFS: compile errors (duplicate) + + -- Al Stone Mon, 23 Oct 2006 12:53:33 -0600 + +llvm (1.8a-1) unstable; urgency=low + + * Upgrade to latest upstream. + * Closes: bug#385767 -- New upstream release + * Closes: bug#382897 -- Please stop Build-Depending on automake (patch + was wrong, dependency is actually on 1.9, not 1.4) + * Makefile used 'tar xvzf' which was far too noisy; using 'tar xzf' now. + * Closes: bug#380150 -- claims front-end is based on GCC 3.4 but it's 4.0.1 + now; fixed the control file to reflect the proper version. + * Closes: bug#390289 -- problem with update-binfmts when purging packagei + llvm; update-binfmts was being invoked with the wrong arguments + + -- Al Stone Sat, 21 Oct 2006 12:27:09 -0600 + +llvm (1.7-3) unstable; urgency=low + + * Closes: bug#376138 -- llvm: postinst failure in update-binfmts + * Closes: bug#373655 -- amd64 FTBS; this is _not_ a fully supported + architecture; the C backend is the only backend available, iff one + uses an older gcc frontend. Waiting for upstream or helping them + are the best options. + + -- Al Stone Tue, 11 Jul 2006 08:33:48 -0600 + +llvm (1.7-2) unstable; urgency=low + + * Closes: bug#374615: llvm-doc: do not ship doxygen.tar.gz and html.tar.gz + * Closes: bug#373655: amd64/unstable FTBFS -- Unsuported LLVM Target + x86_64-unknown-linux-gnu; this is not yet a supported architecture + for this package and should not have been included. + + -- Al Stone Mon, 26 Jun 2006 08:43:40 -0600 + +llvm (1.7-1) unstable; urgency=low + + * New upstream source (1.7) + * Add alpha architecture, be nicer to sparc + * Closes: bug#370161 -- FTBS due to doxygen bug in older versions (patch + from NMU was not used in order to keep dependencies straightforward) -- + bug #345952 closed from doxygen NMU. + * Closes: bug#357015 -- bashism in /etc/init.d/llvm, by removing the use + is the /etc/init.d script and instead using update-binfmts(8). + * Closes: bug#357016 -- please consider replacing /etc/init.d/llvm with + update-binfmts(8) + + -- Al Stone Tue, 13 Jun 2006 18:11:22 -0600 + +llvm (1.6-1.1) unstable; urgency=high + + * Non-maintainer upload. + * Build-depend on fixed doxygen (>= 1.4.6-2.1); fixes FTBFS. + (Closes: #357722) + + -- Steinar H. Gunderson Sat, 3 Jun 2006 13:52:35 +0200 + +llvm (1.6-1) unstable; urgency=low + + * Closes: bug#339768 -- new upstream version + * Closes: bug#332517 -- FTBS on s390 (it's not a supported architecture) + + -- Al Stone Sun, 1 Jan 2006 15:23:30 -0700 + +llvm (1.5-1) unstable; urgency=low + + * Updated to latest upstream (1.5) + * Removed restriction requiring gcc 3.3 on i386 (no longer needed). + * Updated to latest standards version + * Removed dependency on pax (no longer needed) + * NB: this version was not released into the wild due to my inability to + get it done in a reasonable amount of time + + -- Al Stone Sat, 10 Sep 2005 17:30:42 -0600 + +llvm (1.5-0b) unstable; urgency=low + + * Forced dependency on GCC 3.4; LLVM really does prefer it. + * Updated 1.5cvs bits. + + -- Al Stone Wed, 25 May 2005 14:01:21 -0700 + +llvm (1.5-0a) unstable; urgency=low + + * Start preparing for the 1.5 release. + + -- Al Stone Fri, 20 May 2005 17:39:53 -0700 + +llvm (1.4-3) unstable; urgency=low + + * Closes: bug#304035 -- upstream renamed 'extract' to 'llvm-extract' to + remove conflict with /usr/bin/extract from package extract. + * Closes: bug#308694 -- missing depends for texinfo and graphviz + + -- Al Stone Thu, 19 May 2005 16:47:33 -0600 + +llvm (1.4-2) unstable; urgency=low + + * An older version of llvmc was inadvertently used; now fixed. + + -- Al Stone Fri, 11 Mar 2005 17:04:30 -0700 + +llvm (1.4-1) unstable; urgency=low + + * Initial Release. + * Closes: bug#239415 -- ITP for LLVM (Low-Level Virtual Machine) compiler + for C/C++ + + -- Al Stone Thu, 10 Mar 2005 07:31:10 -0700 + --- llvm-2.4.orig/debian/rules +++ llvm-2.4/debian/rules @@ -0,0 +1,67 @@ +#!/usr/bin/make -f +# +# Copyright (C) 2008 Arthur Loiret +# +# This program is free software. It comes without any warranty, to +# the extent permitted by applicable law. You can redistribute it +# and/or modify it under the terms of the Do What The Fuck You Want +# To Public License, Version 2, as published by Sam Hocevar. See +# http://sam.zoy.org/wtfpl/COPYING for more details. + + +include debian/rules.d/vars.mk + +# run testsuite +with_check := no +ifneq (,$(filter $(DEB_HOST_ARCH),amd64 i386 ia64 powerpc s390 sparc kfreebsd-i386 kfreebsd-amd64)) + with_check := yes +endif + +BUILDDEPS := +ifeq (llvm,$(PKGSOURCE)) +# tarballs := llvm because tarballs in the tarball are bad, not mad. + builds := llvm-tools llvm-all + packages := llvm llvm-dev llvm-doc llvm-examples +endif +ifeq (llvm-snapshot,$(PKGSOURCE)) + PF := /usr/lib/llvm-snapshot + build := llvm-tools llvm-all + packages := llvm-snapshot +endif +ifneq (,$(filter llvm-gcc-%,$(PKGSOURCE))) + BUILDDEPS := llvm, llvm-dev + tarballs := gcc + builds := llvm-gcc + packages := llvm-gcc + with_check := no +endif + +confargs := \ + --host=$(DEB_HOST_GNU_TYPE) --build=$(DEB_BUILD_GNU_TYPE) +confargs_llvm := $(confargs) +confargs_gcc := $(confargs) + +confargs_llvm += \ + --prefix=$(PF) + +confargs_gcc += \ + --prefix=$(PF)/gcc-$(gcc_version) \ + --enable-languages=c,c++ --program-prefix=llvm- \ + --enable-llvm=/usr/lib/llvm \ + --enable-threads --disable-nls --disable-shared \ + --disable-multilib + +llvm_MAKEOPTS := DebianOpts="-DLLVM_DEBIAN_INFO='\" (Debian $(VERSION))\"'" + +include debian/rules.d/control.mk +include debian/rules.d/unpack.mk +include debian/rules.d/build.mk +include debian/rules.d/check.mk +include debian/rules.d/binary.mk + +clean: + $(RM) log-* missing + $(RM) -r $(llvm_buildir) $(gcc_buildir) + $(RM) -r $(llvm_srcdir) $(gcc_srcdir) + +.PHONY: clean --- llvm-2.4.orig/debian/copyright +++ llvm-2.4/debian/copyright @@ -0,0 +1,89 @@ +This package was debianized by Arthur Loiret on +Sun, 10 Nov 2007 12:32:05 +0200. + +It was downloaded from http://llvm.org/releases/download.html + + + DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + Version 2, December 2004 + + Copyright (C) 2004 Sam Hocevar + 14 rue de Plaisance, 75014 Paris, France + Everyone is permitted to copy and distribute verbatim or modified + copies of this license document, and changing it is allowed as long + as the name is changed. + + DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. You just DO WHAT THE FUCK YOU WANT TO. + +============================================================================== +LLVM Release License +============================================================================== +University of Illinois/NCSA +Open Source License + +Copyright (c) 2003-2007 University of Illinois at Urbana-Champaign. +All rights reserved. + +Developed by: + + LLVM Team + + University of Illinois at Urbana-Champaign + + http://llvm.org + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal with +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimers. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimers in the + documentation and/or other materials provided with the distribution. + + * Neither the names of the LLVM Team, University of Illinois at + Urbana-Champaign, nor the names of its contributors may be used to + endorse or promote products derived from this Software without specific + prior written permission. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE +SOFTWARE. + +============================================================================== +Copyrights and Licenses for Third Party Software Distributed with LLVM: +============================================================================== +The LLVM software contains code written by third parties. Such software will +have its own individual LICENSE.TXT file in the directory in which it appears. +This file will describe the copyrights, license, and restrictions which apply +to that code. + +The disclaimer of warranty in the University of Illinois Open Source License +applies to all code in the LLVM Distribution, and nothing in any of the +other licenses gives permission to use the names of the LLVM Team or the +University of Illinois to endorse or promote products derived from this +Software. + +The following pieces of software have additional or alternate copyrights, +licenses, and/or restrictions: + +Program Directory +------- --------- +System Library llvm/lib/System +Compiler Driver llvm/tools/llvmc +Autoconf llvm/autoconf + llvm/projects/ModuleMaker/autoconf + llvm/projects/sample/autoconf + --- llvm-2.4.orig/debian/compat +++ llvm-2.4/debian/compat @@ -0,0 +1 @@ +6 --- llvm-2.4.orig/debian/logwatch.sh +++ llvm-2.4/debian/logwatch.sh @@ -0,0 +1,104 @@ +#! /bin/sh + +# script to trick the build daemons and output something, if there is +# still test/build activity + +# $1: primary file to watch. if there is activity on this file, we do nothing +# $2+: files to watch to look for activity despite no output in $1 +# if the files are modified or are newly created, then the message +# is printed on stdout. +# if nothing is modified, don't output anything (so the buildd timeout +# hits). + +pidfile=logwatch.pid +timeout=3600 +message='\nlogwatch still running\n' + +usage() +{ + echo >&2 "usage: `basename $0` [-p ] [-t ] [-m ]" + echo >&2 " [ ...]" + exit 1 +} + +while [ $# -gt 0 ]; do + case $1 in + -p) + pidfile=$2 + shift + shift + ;; + -t) + timeout=$2 + shift + shift + ;; + -m) + message="$2" + shift + shift + ;; + -*) + usage + ;; + *) + break + esac +done + +[ $# -gt 0 ] || usage + +logfile="$1" +shift +otherlogs="$@" + +cleanup() +{ + rm -f $pidfile + exit 0 +} + +#trap cleanup 0 1 3 15 + +echo $$ > $pidfile + +update() +{ + _logvar=$1 + _othervar=$2 + + # logfile may not exist yet + if [ -r $logfile ]; then + _logtail="`tail -10 $logfile | md5sum` $f" + else + _logtail="does not exist: $logfile" + fi + eval $_logvar="'$_logtail'" + + _othertails='' + for f in $otherlogs; do + if [ -r $f ]; then + _othertails="$_othertails `tail -10 $f | md5sum` $f" + else + _othertails="$_othertails does not exist: $f" + fi + done + eval $_othervar="'$_othertails'" +} + +update logtail othertails +while true; do + sleep $timeout + update newlogtail newothertails + if [ "$logtail" != "$newlogtail" ]; then + # there is still action in the primary logfile. do nothing. + logtail="$newlogtail" + elif [ "$othertails" != "$newothertails" ]; then + # there is still action in the other log files, so print the message + /bin/echo -e $message + othertails="$newothertails" + else + # nothing changed in the other log files. maybe a timeout ... + : + fi +done --- llvm-2.4.orig/debian/control +++ llvm-2.4/debian/control @@ -0,0 +1,91 @@ +Source: llvm +Section: devel +Priority: optional +Maintainer: LLVM Packaging Team +Uploaders: Arthur Loiret , Pierre Habouzit +Build-Depends: debhelper (>= 6.0.0), flex, bison, dejagnu, tcl8.4, expect, + autoconf, automake1.9, perl, libtool, doxygen, chrpath, texinfo, + sharutils +Standards-Version: 3.8.0 +Homepage: http://www.llvm.org/ +Vcs-Git: git://git.debian.org/git/pkg-llvm/llvm.git +Vcs-Browser: http://git.debian.org/?p=pkg-llvm/llvm.git;a=summary + +Package: llvm +Architecture: any +Suggests: llvm-doc +Depends: binfmt-support, ${shlibs:Depends}, ${misc:Depends} +Recommends: llvm-dev +Description: Low-Level Virtual Machine (LLVM) compiler for C/C++ + The Low-Level Virtual Machine (LLVM) is a collection of libraries and + tools that make it easy to build compilers, optimizers, Just-In-Time + code generators, and many other compiler-related programs. LLVM + uses a single, language-independent virtual instruction set both + as an offline code representation (to communicate code between + compiler phases and to run-time systems) and as the compiler internal + representation (to analyze and transform programs). This persistent + code representation allows a common set of sophisticated compiler + techniques to be applied at compile-time, link-time, install-time, + run-time, or "idle-time" (between program runs). + . + The strengths of the LLVM infrastructure are its extremely + simple design (which makes it easy to understand and use), + source-language independence, powerful mid-level optimizer, automated + compiler debugging support, extensibility, and its stability and + reliability. LLVM is currently being used to host a wide variety of + academic research projects and commercial projects. LLVM includes C + and C++ front-ends (based on GCC 4.0.1), a front-end for a Forth-like + language (Stacker), a young scheme front-end, and Java support is + in development. LLVM can generate code for X86, SparcV9, PowerPC, + or it can emit C code. + +Package: llvm-dev +Architecture: any +Depends: ${shlibs:Depends}, ${misc:Depends}, llvm (>= ${binary:Version}) +Provides: llvm-libs +Conflicts: llvm-libs +Replaces: llvm-libs, llvm (<< 2.2-3) +Description: common libraries and headers for LLVM compiler for C/C++ + The Low-Level Virtual Machine (LLVM) is a collection of libraries and + tools that make it easy to build compilers, optimizers, Just-In-Time + code generators, and many other compiler-related programs. + . + This package provides the libraries and headers to develop applications + using llvm. + +Package: llvm-doc +Section: doc +Architecture: all +Description: documentation for LLVM (Low-Level Virtual Machine) compiler + The Low-Level Virtual Machine (LLVM) is a collection of libraries and + tools that make it easy to build compilers, optimizers, Just-In-Time + code generators, and many other compiler-related programs. LLVM + uses a single, language-independent virtual instruction set both + as an offline code representation (to communicate code between + compiler phases and to run-time systems) and as the compiler internal + representation (to analyze and transform programs). This persistent + code representation allows a common set of sophisticated compiler + techniques to be applied at compile-time, link-time, install-time, + run-time, or "idle-time" (between program runs). + . + This package contains all documentation (extensive). + +Package: llvm-examples +Section: doc +Architecture: all +Depends: llvm-dev (>= ${source:Version}), llvm-dev (<< ${source:Version}+c~) +Description: examples using LLVM (Low-Level Virtual Machine) compiler + The Low-Level Virtual Machine (LLVM) is a collection of libraries and + tools that make it easy to build compilers, optimizers, Just-In-Time + code generators, and many other compiler-related programs. LLVM + uses a single, language-independent virtual instruction set both + as an offline code representation (to communicate code between + compiler phases and to run-time systems) and as the compiler internal + representation (to analyze and transform programs). This persistent + code representation allows a common set of sophisticated compiler + techniques to be applied at compile-time, link-time, install-time, + run-time, or "idle-time" (between program runs). + . + This package contains examples for using LLVM, both in developing + extensions to LLVM and in using it to compile code. + --- llvm-2.4.orig/debian/control.in/llvm-examples +++ llvm-2.4/debian/control.in/llvm-examples @@ -0,0 +1,19 @@ +Package: llvm-examples +Section: doc +Architecture: all +Depends: llvm-dev (>= ${source:Version}), llvm-dev (<< ${source:Version}+c~) +Description: examples using LLVM (Low-Level Virtual Machine) compiler + The Low-Level Virtual Machine (LLVM) is a collection of libraries and + tools that make it easy to build compilers, optimizers, Just-In-Time + code generators, and many other compiler-related programs. LLVM + uses a single, language-independent virtual instruction set both + as an offline code representation (to communicate code between + compiler phases and to run-time systems) and as the compiler internal + representation (to analyze and transform programs). This persistent + code representation allows a common set of sophisticated compiler + techniques to be applied at compile-time, link-time, install-time, + run-time, or "idle-time" (between program runs). + . + This package contains examples for using LLVM, both in developing + extensions to LLVM and in using it to compile code. + --- llvm-2.4.orig/debian/control.in/source +++ llvm-2.4/debian/control.in/source @@ -0,0 +1,13 @@ +Source: @PKGSOURCE@ +Section: devel +Priority: optional +Maintainer: LLVM Packaging Team +Uploaders: Arthur Loiret , Pierre Habouzit +Build-Depends: debhelper (>= 6.0.0), flex, bison, dejagnu, tcl8.4, expect, + autoconf, automake1.9, perl, libtool, doxygen, chrpath, texinfo, + sharutils @BUILDDEPS@ +Standards-Version: 3.8.0 +Homepage: http://www.llvm.org/ +Vcs-Git: git://git.debian.org/git/pkg-llvm/llvm.git +Vcs-Browser: http://git.debian.org/?p=pkg-llvm/llvm.git;a=summary + --- llvm-2.4.orig/debian/control.in/llvm +++ llvm-2.4/debian/control.in/llvm @@ -0,0 +1,28 @@ +Package: llvm +Architecture: any +Suggests: llvm-doc +Depends: binfmt-support, ${shlibs:Depends}, ${misc:Depends} +Recommends: llvm-dev +Description: Low-Level Virtual Machine (LLVM) compiler for C/C++ + The Low-Level Virtual Machine (LLVM) is a collection of libraries and + tools that make it easy to build compilers, optimizers, Just-In-Time + code generators, and many other compiler-related programs. LLVM + uses a single, language-independent virtual instruction set both + as an offline code representation (to communicate code between + compiler phases and to run-time systems) and as the compiler internal + representation (to analyze and transform programs). This persistent + code representation allows a common set of sophisticated compiler + techniques to be applied at compile-time, link-time, install-time, + run-time, or "idle-time" (between program runs). + . + The strengths of the LLVM infrastructure are its extremely + simple design (which makes it easy to understand and use), + source-language independence, powerful mid-level optimizer, automated + compiler debugging support, extensibility, and its stability and + reliability. LLVM is currently being used to host a wide variety of + academic research projects and commercial projects. LLVM includes C + and C++ front-ends (based on GCC 4.0.1), a front-end for a Forth-like + language (Stacker), a young scheme front-end, and Java support is + in development. LLVM can generate code for X86, SparcV9, PowerPC, + or it can emit C code. + --- llvm-2.4.orig/debian/control.in/llvm-dev +++ llvm-2.4/debian/control.in/llvm-dev @@ -0,0 +1,14 @@ +Package: llvm-dev +Architecture: any +Depends: ${shlibs:Depends}, ${misc:Depends}, llvm (>= ${binary:Version}) +Provides: llvm-libs +Conflicts: llvm-libs +Replaces: llvm-libs, llvm (<< 2.2-3) +Description: common libraries and headers for LLVM compiler for C/C++ + The Low-Level Virtual Machine (LLVM) is a collection of libraries and + tools that make it easy to build compilers, optimizers, Just-In-Time + code generators, and many other compiler-related programs. + . + This package provides the libraries and headers to develop applications + using llvm. + --- llvm-2.4.orig/debian/control.in/llvm-gcc +++ llvm-2.4/debian/control.in/llvm-gcc @@ -0,0 +1,15 @@ +Package: llvm-gcc +Architecture: any +Depends: llvm-dev (>= 2.2-3), llvm (>= 2.2-3), ${shlibs:Depends}, ${misc:Depends} +Provides: llvm-cfe +Suggests: gcc-4.2-doc +Description: C front end for LLVM C/C++ compiler + The Low-Level Virtual Machine (LLVM) is a collection of libraries and + tools that make it easy to build compilers, optimizers, Just-In-Time + code generators, and many other compiler-related programs. + . + This is only a utility package that contains the C/C++ front-end + used by the compiler, and was created in order to reduce the overall + size of the compiler package itself. Please install the 'llvm' + package to install the actual compiler. + --- llvm-2.4.orig/debian/control.in/llvm-doc +++ llvm-2.4/debian/control.in/llvm-doc @@ -0,0 +1,17 @@ +Package: llvm-doc +Section: doc +Architecture: all +Description: documentation for LLVM (Low-Level Virtual Machine) compiler + The Low-Level Virtual Machine (LLVM) is a collection of libraries and + tools that make it easy to build compilers, optimizers, Just-In-Time + code generators, and many other compiler-related programs. LLVM + uses a single, language-independent virtual instruction set both + as an offline code representation (to communicate code between + compiler phases and to run-time systems) and as the compiler internal + representation (to analyze and transform programs). This persistent + code representation allows a common set of sophisticated compiler + techniques to be applied at compile-time, link-time, install-time, + run-time, or "idle-time" (between program runs). + . + This package contains all documentation (extensive). + --- llvm-2.4.orig/debian/rules.d/build.mk +++ llvm-2.4/debian/rules.d/build.mk @@ -0,0 +1,61 @@ +# Copyright (C) 2008 Arthur Loiret +# +# This program is free software. It comes without any warranty, to +# the extent permitted by applicable law. You can redistribute it +# and/or modify it under the terms of the Do What The Fuck You Want +# To Public License, Version 2, as published by Sam Hocevar. See +# http://sam.zoy.org/wtfpl/COPYING for more details. + + +configure: $(configure-stamp) +$(configure-stamp): $(addprefix $(configure-stamp)-,$(builds)) + touch $@ + +build: $(build-stamp) +$(build-stamp): $(addprefix $(build-stamp)-,$(builds)) + touch $@ + +install: $(install-stamp) +$(install-stamp): $(addprefix $(install-stamp)-,$(builds)) + +clean: clean-common +clean-common: + dh_testdir + dh_testroot + dh_clean + $(RM) -r $(stampdir) + +.PHONY: configure build install clean clean-% + + +$(addprefix $(configure-stamp)-llvm-,tools all): $(configure-stamp)-llvm +$(configure-stamp)-llvm: $(unpack-stamp) $(patch-stamp) $(mkdir-stamp)-$(llvm_buildir) + cd $(llvm_buildir) && \ + ../configure $(confargs_llvm) + touch $@ + +$(build-stamp)-llvm-tools: $(configure-stamp)-llvm + $(MAKE) -C $(llvm_buildir) $(llvm_MAKEOPTS) tools-only VERBOSE=1 + touch $@ +$(build-stamp)-llvm-all: $(configure-stamp)-llvm + $(MAKE) -C $(llvm_buildir) $(llvm_MAKEOPTS) VERBOSE=1 + touch $@ + +$(install-stamp)-llvm-%: $(build-stamp)-llvm-% $(install-stamp)-llvm + touch $@ +$(install-stamp)-llvm: + $(MAKE) -C $(llvm_buildir) install DESTDIR=$(D)/debian/tmp + for i in $(D)/debian/tmp/usr/lib/llvm/bin/*; do \ + chrpath -d $$i; done + +$(configure-stamp)-llvm-gcc: $(unpack-stamp) $(patch-stamp) $(mkdir-stamp)-$(gcc_buildir) + cd $(gcc_buildir) && \ + ../$(gcc_srcdir)/configure $(confargs_gcc) + touch $@ +$(build-stamp)-llvm-gcc: $(configure-stamp)-llvm-gcc + $(MAKE) -C $(gcc_buildir) $(gcc_MAKEOPTS) + touch $@ +$(install-stamp)-llvm-gcc: $(build-stamp)-llvm-gcc + $(MAKE) -C $(gcc_buildir) install DESTDIR=$(D)/debian/tmp + touch $@ + --- llvm-2.4.orig/debian/rules.d/unpack.mk +++ llvm-2.4/debian/rules.d/unpack.mk @@ -0,0 +1,46 @@ +# Copyright (C) 2008 Arthur Loiret +# +# This program is free software. It comes without any warranty, to +# the extent permitted by applicable law. You can redistribute it +# and/or modify it under the terms of the Do What The Fuck You Want +# To Public License, Version 2, as published by Sam Hocevar. See +# http://sam.zoy.org/wtfpl/COPYING for more details. + + +unpack: $(unpack-stamp) +$(unpack-stamp): $(addprefix $(unpack-stamp)-,$(tarballs)) + mkdir -p $(@D) + touch $@ + +$(unpack-stamp)-%: + -mkdir $(stampdir) 2>/dev/null + $(RM) -r $($*_srcdir) + case $($*_tarball) in \ + *.bz2) tar -x --bzip2 -f $($*_tarpath);; \ + *.gz) tar -x --gzip -f $($*_tarpath);; \ + *.lzma) lzcat $($*_tarpath) | tar -x -f -;; \ + *) false;; \ + esac + touch $@ + +$(mkdir-stamp)-%: + $(RM) -r $* + mkdir -p $* + touch $@ + +patch: $(patch-stamp) +$(patch-stamp): $(unpack-stamp) + set -e; test -e $(patch-stamp) || \ + for i in `ls -1 debian/patches/*.patch || :`; do patch -p1 <$$i > /dev/null; done + touch $@ + +unpatch: +ifeq (,$(tarball)) + set -e; ! test -e $(patch-stamp) || \ + for i in `ls -1r debian/patches/*.patch || :`; do patch -p1 -R <$$i > /dev/null; done +endif + $(RM) -f $(patch-stamp) + +clean: unpatch + +.PHONY: unpack patch unpatch --- llvm-2.4.orig/debian/rules.d/binary.mk +++ llvm-2.4/debian/rules.d/binary.mk @@ -0,0 +1,51 @@ +# Copyright (C) 2008 Arthur Loiret +# +# This program is free software. It comes without any warranty, to +# the extent permitted by applicable law. You can redistribute it +# and/or modify it under the terms of the Do What The Fuck You Want +# To Public License, Version 2, as published by Sam Hocevar. See +# http://sam.zoy.org/wtfpl/COPYING for more details. + + +check := $(if $(findstring yes,$(with_check)),$(check-stamp),) +binary binary-indep binary-arch: $(build-stamp) $(check) $(install-stamp) +binary-arch: $(addprefix $(binary-stamp)-,$(packages_arch)) +binary-indep: $(addprefix $(binary-stamp)-,$(packages_indep)) +binary: binary-arch binary-indep + dh_install --list-missing 2>&1 + +debhelper-%: + $(foreach f,$(notdir $(wildcard debian/debhelper.in/$*.*)),\ + sed -e "s;@PF@;$(PF);g" \ + -e "s;@GCC_VERSION@;$(GCC_VERSION);g" \ + -e "s;@LLVM_VERSION@;$(LLVM_VERSION);g" \ + debian/debhelper.in/$f > debian/$f &&) : + +clean: clean-debhelper +clean-debhelper: clean-common + $(RM) $(addprefix debian/,$(notdir $(wildcard debian/debhelper.in/*))) + +$(binary-stamp)-%: debhelper-% + @echo Building package: $* + dh_testdir + dh_testroot + dh_installchangelogs -p$* + dh_installdocs -p$* + dh_installexamples -p$* + dh_installman -p$* + dh_installmime -p$* + dh_install -p$* + -find $(D)/debian/$* -type f -name "LICENSE.TXT" | xargs rm -f + -chmod 644 $(D)/debian/$*/usr/lib/llvm/build/Makefile* + dh_link -p$* + dh_strip -p$* + dh_compress -p$* + dh_fixperms -p$* + dh_installdeb -p$* + dh_shlibdeps -p$* + dh_gencontrol -p$* + dh_md5sums -p$* + dh_builddeb -p$* + touch $@ + +.PHONY: binary binary-arch binary-indep debhelper-% --- llvm-2.4.orig/debian/rules.d/check.mk +++ llvm-2.4/debian/rules.d/check.mk @@ -0,0 +1,30 @@ +# Copyright (C) 2008 Arthur Loiret +# +# This program is free software. It comes without any warranty, to +# the extent permitted by applicable law. You can redistribute it +# and/or modify it under the terms of the Do What The Fuck You Want +# To Public License, Version 2, as published by Sam Hocevar. See +# http://sam.zoy.org/wtfpl/COPYING for more details. + + +ifeq ($(PKGSOURCE),llvm) + check_dir := $(llvm_buildir) +endif +ifneq (,$(filter llvm-gcc-%,$(PKGSOURCE))) + check_dir := $(gcc_buildir) +endif + +check: $(check-stamp) +$(check-stamp): + chmod +x debian/logwatch.sh + -debian/logwatch.sh -t 900 -p debian/logwatch.pid \ + -m '\ntestsuite still running ...\n' \ + debian/log-check \ + & + @echo BEGIN-testsuite + -$(MAKE) -C $(check_dir) check 2>&1 | tee debian/log-check + @echo END-testsuite + touch $@ + + +.PHONY: check --- llvm-2.4.orig/debian/rules.d/control.mk +++ llvm-2.4/debian/rules.d/control.mk @@ -0,0 +1,23 @@ +# Copyright (C) 2008 Arthur Loiret +# +# This program is free software. It comes without any warranty, to +# the extent permitted by applicable law. You can redistribute it +# and/or modify it under the terms of the Do What The Fuck You Want +# To Public License, Version 2, as published by Sam Hocevar. See +# http://sam.zoy.org/wtfpl/COPYING for more details. + + +ifneq (,$(strip $(BUILDDEPS))) + BUILDDEPS:=, $(BUILDDEPS) +endif + +debian/control: + @echo Regenerating control file... + sed -e "s/@PKGSOURCE@/$(PKGSOURCE)/g" \ + -e "s/ *@BUILDDEPS@/$(BUILDDEPS)/g" \ + $@.in/source $(addprefix $@.in/,$(packages)) > $@ + +control: debian/control +clean: control + +.PHONY: control debian/control --- llvm-2.4.orig/debian/rules.d/vars.mk +++ llvm-2.4/debian/rules.d/vars.mk @@ -0,0 +1,51 @@ +# Copyright (C) 2008 Arthur Loiret +# +# This program is free software. It comes without any warranty, to +# the extent permitted by applicable law. You can redistribute it +# and/or modify it under the terms of the Do What The Fuck You Want +# To Public License, Version 2, as published by Sam Hocevar. See +# http://sam.zoy.org/wtfpl/COPYING for more details. + + +DISTRIBUTION := $(shell dpkg-parsechangelog | grep ^Distribution | sed -e 's/^Distribution: //') +PKGSOURCE := $(shell dpkg-parsechangelog | grep ^Source | sed -e 's/^Source: //') +VERSION := $(shell dpkg-parsechangelog | grep ^Version | sed -e 's/^Version: //') +PF := /usr/lib/llvm +D := $(CURDIR) + +$(foreach x,$(shell dpkg-architecture | sed -e 's/=/?=/'),$(eval $x)) + +ifneq (,$(filter parallel=%,$(DEB_BUILD_OPTIONS))) + NJOBS := $(patsubst parallel=%,%,$(filter parallel=%,$(DEB_BUILD_OPTIONS))) +else + NCPUS := $(shell getconf _NPROCESSORS_ONLN 2>/dev/null || echo 1) + NJOBS := $(shell if test $(NCPUS) -gt 1; then echo `expr $(NCPUS) + 1`; \ + else echo $(NCPUS); fi) +endif +MAKE := $(MAKE) -j$(NJOBS) + +llvm_buildir := build-llvm + +gcc_tarpath := $(firstword $(wildcard $(D)/llvm-gcc4*.tar.* \ + /usr/src/llvm/llvm-gcc4*.tar.*)) +gcc_tarball := $(notdir $(gcc_tarpath)) +gcc_srcdir := $(subst -dfsg,,$(subst .tar$(suffix $(gcc_tarball)),,$(gcc_tarball))) +gcc_version := $(shell echo $(gcc_tarball) | sed -r 's/llvm-gcc(4[0-9\.]+).*/\1/') +gcc_buildir := build-gcc + + +stampdir := debian/stamps +control-stamp := $(stampdir)/control-stamp +mkdir-stamp := $(stampdir)/mkdir-stamp +unpack-stamp := $(stampdir)/unpack-stamp +patch-stamp := $(stampdir)/patch-stamp +configure-stamp := $(stampdir)/configure-stamp +build-stamp := $(stampdir)/build-stamp +check-stamp := $(stampdir)/check-stamp +install-stamp := $(stampdir)/install-stamp +binary-stamp := $(stampdir)/binary-stamp + + +packages_indep := $(strip $(shell dh_listpackages -i)) +packages_all := $(strip $(shell dh_listpackages -s)) +packages_arch := $(filter-out $(packages_indep),$(packages_all)) --- llvm-2.4.orig/debian/debhelper.in/llvm.prerm +++ llvm-2.4/debian/debhelper.in/llvm.prerm @@ -0,0 +1,11 @@ +#!/bin/sh -e + +if test "$1" = "remove"; then + if test -x /usr/sbin/update-binfmts; then + update-binfmts --package llvm \ + --remove llvm /usr/bin/lli || true + fi +fi + +#DEBHELPER# + --- llvm-2.4.orig/debian/debhelper.in/llvm-examples.examples +++ llvm-2.4/debian/debhelper.in/llvm-examples.examples @@ -0,0 +1 @@ +examples/* --- llvm-2.4.orig/debian/debhelper.in/llvm-doc.install +++ llvm-2.4/debian/debhelper.in/llvm-doc.install @@ -0,0 +1,2 @@ +debian/tmp/@PF@/docs/llvm/html usr/share/doc/llvm-doc/ +debian/tmp/@PF@/docs/llvm/ps usr/share/doc/llvm-doc/ --- llvm-2.4.orig/debian/debhelper.in/llvm-doc.dirs +++ llvm-2.4/debian/debhelper.in/llvm-doc.dirs @@ -0,0 +1 @@ +usr/share/doc/llvm-doc --- llvm-2.4.orig/debian/debhelper.in/llvm.links +++ llvm-2.4/debian/debhelper.in/llvm.links @@ -0,0 +1,21 @@ +@PF@/bin/bugpoint usr/bin/bugpoint +@PF@/bin/llc usr/bin/llc +@PF@/bin/llvm-as usr/bin/llvm-as +@PF@/bin/llvm-db usr/bin/llvm-db +@PF@/bin/llvm-ld usr/bin/llvm-ld +@PF@/bin/llvm-prof usr/bin/llvm-prof +@PF@/bin/llvm-upgrade usr/bin/llvm-upgrade +@PF@/bin/opt usr/bin/opt +@PF@/bin/gccas usr/bin/gccas +@PF@/bin/lli usr/bin/lli +@PF@/bin/llvm-bcanalyzer usr/bin/llvm-bcanalyzer +@PF@/bin/llvm-dis usr/bin/llvm-dis +@PF@/bin/llvm-link usr/bin/llvm-link +@PF@/bin/llvm-ranlib usr/bin/llvm-ranlib +@PF@/bin/llvm2cpp usr/bin/llvm2cpp +@PF@/bin/gccld usr/bin/gccld +@PF@/bin/llvm-ar usr/bin/llvm-ar +@PF@/bin/llvm-config usr/bin/llvm-config +@PF@/bin/llvm-extract usr/bin/llvm-extract +@PF@/bin/llvm-nm usr/bin/llvm-nm +@PF@/bin/llvmc usr/bin/llvmc --- llvm-2.4.orig/debian/debhelper.in/llvm.postinst +++ llvm-2.4/debian/debhelper.in/llvm.postinst @@ -0,0 +1,9 @@ +#!/bin/sh -e + +if test "$1" = "configure"; then + if test -x /usr/sbin/update-binfmts; then + update-binfmts --import llvm.binfmt || true + fi +fi + +#DEBHELPER# --- llvm-2.4.orig/debian/debhelper.in/llvm-examples.dirs +++ llvm-2.4/debian/debhelper.in/llvm-examples.dirs @@ -0,0 +1 @@ +usr/share/doc/llvm-examples --- llvm-2.4.orig/debian/debhelper.in/llvm-dev.dirs +++ llvm-2.4/debian/debhelper.in/llvm-dev.dirs @@ -0,0 +1,2 @@ +@PF@/lib +@PF@/build --- llvm-2.4.orig/debian/debhelper.in/llvm-dev.install +++ llvm-2.4/debian/debhelper.in/llvm-dev.install @@ -0,0 +1,9 @@ +debian/tmp/@PF@/lib/* @PF@/lib/ +debian/tmp/@PF@/include/* usr/include/ + +build-llvm/Makefile.common @PF@/build/ +build-llvm/Makefile.config @PF@/build/ +build-llvm/config.status @PF@/build/ +Makefile.rules @PF@/build/ +configure @PF@/build/ +autoconf/ @PF@/build/ --- llvm-2.4.orig/debian/debhelper.in/llvm-examples.links +++ llvm-2.4/debian/debhelper.in/llvm-examples.links @@ -0,0 +1,3 @@ +@PF@/build/Makefile.common usr/share/doc/llvm-examples/Makefile.common +@PF@/build/Makefile.config usr/share/doc/llvm-examples/Makefile.config +@PF@/build/Makefile.rules usr/share/doc/llvm-examples/Makefile.rules --- llvm-2.4.orig/debian/debhelper.in/llvm.dirs +++ llvm-2.4/debian/debhelper.in/llvm.dirs @@ -0,0 +1,6 @@ +@PF@/bin +usr/bin +usr/include +usr/share/man/man1 +etc/llvm +usr/share/binfmts --- llvm-2.4.orig/debian/debhelper.in/llvm.install +++ llvm-2.4/debian/debhelper.in/llvm.install @@ -0,0 +1,3 @@ +debian/tmp/@PF@/bin/* @PF@/bin/ +debian/tmp/@PF@/share/man/man1/* usr/share/man/man1/ +debian/llvm.binfmt usr/share/binfmts/ --- llvm-2.4.orig/debian/patches/0006-Build-LLVM-with-O2.patch +++ llvm-2.4/debian/patches/0006-Build-LLVM-with-O2.patch @@ -0,0 +1,32 @@ +From eeb69168b6f35d2aa60082c67f14523083eff27b Mon Sep 17 00:00:00 2001 +From: Arthur Loiret +Date: Fri, 21 Nov 2008 00:38:46 +0100 +Subject: [PATCH] Build LLVM with -O2. + +-O3 is too long for most buildds, and brings little performance. + +Signed-off-by: Pierre Habouzit +--- + Makefile.rules | 6 +----- + 1 files changed, 1 insertions(+), 5 deletions(-) + +diff --git a/Makefile.rules b/Makefile.rules +index 8c24964..09e6cdc 100644 +--- a/Makefile.rules ++++ b/Makefile.rules +@@ -207,11 +207,7 @@ endif + CPP.Defines := + # OPTIMIZE_OPTION - The optimization level option we want to build LLVM with + # this can be overridden on the make command line. +-ifneq ($(OS),MingW) +- OPTIMIZE_OPTION := -O3 +-else +- OPTIMIZE_OPTION := -O2 +-endif ++OPTIMIZE_OPTION := -O2 + + ifdef ENABLE_PROFILING + BuildMode := Profile +-- +1.5.6.5 + --- llvm-2.4.orig/debian/patches/0002-Fix-llvm-config-script.patch +++ llvm-2.4/debian/patches/0002-Fix-llvm-config-script.patch @@ -0,0 +1,40 @@ +From 147ed615cf60147a259eed57d4ef6506a0695a3c Mon Sep 17 00:00:00 2001 +From: Arthur Loiret +Date: Sun, 29 Jun 2008 09:31:55 +0000 +Subject: [PATCH] Fix llvm config script. + +Signed-off-by: Arthur Loiret +--- + tools/llvm-config/llvm-config.in.in | 9 ++++++--- + 1 files changed, 6 insertions(+), 3 deletions(-) + +diff --git a/tools/llvm-config/llvm-config.in.in b/tools/llvm-config/llvm-config.in.in +index 36b5112..738fb69 100644 +--- a/tools/llvm-config/llvm-config.in.in ++++ b/tools/llvm-config/llvm-config.in.in +@@ -89,8 +89,11 @@ if ($ABS_RUN_DIR eq $ABS_OBJ_ROOT) { + $INCLUDEDIR = "$LLVM_SRC_ROOT/include"; + } else { + # If installed, ignore the prefix the tree was configured with, use the +- # current prefix. +- $PREFIX = $ABS_RUN_DIR; ++ # Debian dirs. ++ $PREFIX = "/usr/lib/llvm"; ++ $INCLUDEDIR = "/usr/include/llvm"; ++ $LIBDIR = "/usr/lib/llvm/lib"; ++ $BINDIR = "/usr/bin"; + } + + sub usage; +@@ -167,7 +170,7 @@ if (@components == 0) { + # Handle any arguments which require building our dependency graph. + if ($want_libs || $want_libnames || $want_libfiles) { + my @libs = expand_dependencies(@components); +- print join(' ', fix_library_names(@libs)), "\n" if ($want_libs); ++ print join(' ', fix_library_names(@libs)), " -L$LIBDIR\n" if ($want_libs); + print join(' ', @libs), "\n" if ($want_libnames); + print join(' ', fix_library_files(@libs)), "\n" if ($want_libfiles); + } +-- +1.5.6.5 + --- llvm-2.4.orig/debian/patches/0005-Disable-llvm-stub.patch +++ llvm-2.4/debian/patches/0005-Disable-llvm-stub.patch @@ -0,0 +1,26 @@ +From 5d6a668557cd8b809af7774e05dc68ca672464cd Mon Sep 17 00:00:00 2001 +From: Arthur Loiret +Date: Sun, 29 Jun 2008 09:34:03 +0000 +Subject: [PATCH] Disable llvm-stub. + +Signed-off-by: Arthur Loiret +--- + tools/Makefile | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/tools/Makefile b/tools/Makefile +index 30da522..8d1fb3d 100644 +--- a/tools/Makefile ++++ b/tools/Makefile +@@ -16,7 +16,7 @@ PARALLEL_DIRS := llvm-config \ + llc llvm-ranlib llvm-ar llvm-nm \ + llvm-ld llvm-prof llvm-link \ + lli gccas gccld llvm-extract llvm-db \ +- bugpoint llvm-bcanalyzer llvm-stub llvmc2 ++ bugpoint llvm-bcanalyzer llvmc2 + + + include $(LEVEL)/Makefile.config +-- +1.5.6.5 + --- llvm-2.4.orig/debian/patches/0007-Separate-alpha-asmprinter.-This-should-unbreak-nativ.patch +++ llvm-2.4/debian/patches/0007-Separate-alpha-asmprinter.-This-should-unbreak-nativ.patch @@ -0,0 +1,677 @@ +From 8ae78f5bedde5e0c51967104ed34ac5d50525778 Mon Sep 17 00:00:00 2001 +From: asl +Date: Tue, 11 Nov 2008 16:42:17 +0000 +Subject: [PATCH] Separate alpha asmprinter. This should unbreak native build. + +git-svn-id: http://llvm.org/svn/llvm-project/llvm/trunk@59046 91177308-0d34-0410-b5e6-96231b3b80d8 +--- + lib/Target/Alpha/AlphaAsmPrinter.cpp | 294 ----------------------- + lib/Target/Alpha/AsmPrinter/AlphaAsmPrinter.cpp | 294 +++++++++++++++++++++++ + lib/Target/Alpha/AsmPrinter/CMakeLists.txt | 9 + + lib/Target/Alpha/AsmPrinter/Makefile | 15 ++ + lib/Target/Alpha/Makefile | 4 +- + 5 files changed, 321 insertions(+), 295 deletions(-) + delete mode 100644 lib/Target/Alpha/AlphaAsmPrinter.cpp + create mode 100644 lib/Target/Alpha/AsmPrinter/AlphaAsmPrinter.cpp + create mode 100644 lib/Target/Alpha/AsmPrinter/CMakeLists.txt + create mode 100644 lib/Target/Alpha/AsmPrinter/Makefile + +diff --git a/lib/Target/Alpha/AlphaAsmPrinter.cpp b/lib/Target/Alpha/AlphaAsmPrinter.cpp +deleted file mode 100644 +index 5fb6918..0000000 +--- a/lib/Target/Alpha/AlphaAsmPrinter.cpp ++++ /dev/null +@@ -1,294 +0,0 @@ +-//===-- AlphaAsmPrinter.cpp - Alpha LLVM assembly writer ------------------===// +-// +-// The LLVM Compiler Infrastructure +-// +-// This file is distributed under the University of Illinois Open Source +-// License. See LICENSE.TXT for details. +-// +-//===----------------------------------------------------------------------===// +-// +-// This file contains a printer that converts from our internal representation +-// of machine-dependent LLVM code to GAS-format Alpha assembly language. +-// +-//===----------------------------------------------------------------------===// +- +-#define DEBUG_TYPE "asm-printer" +-#include "Alpha.h" +-#include "AlphaInstrInfo.h" +-#include "AlphaTargetMachine.h" +-#include "llvm/Module.h" +-#include "llvm/Type.h" +-#include "llvm/Assembly/Writer.h" +-#include "llvm/CodeGen/AsmPrinter.h" +-#include "llvm/Target/TargetAsmInfo.h" +-#include "llvm/Target/TargetMachine.h" +-#include "llvm/Support/Compiler.h" +-#include "llvm/Support/Mangler.h" +-#include "llvm/Support/raw_ostream.h" +-#include "llvm/ADT/Statistic.h" +-using namespace llvm; +- +-STATISTIC(EmittedInsts, "Number of machine instrs printed"); +- +-namespace { +- struct VISIBILITY_HIDDEN AlphaAsmPrinter : public AsmPrinter { +- +- /// Unique incrementer for label values for referencing Global values. +- /// +- +- AlphaAsmPrinter(raw_ostream &o, TargetMachine &tm, const TargetAsmInfo *T) +- : AsmPrinter(o, tm, T) { +- } +- +- virtual const char *getPassName() const { +- return "Alpha Assembly Printer"; +- } +- bool printInstruction(const MachineInstr *MI); +- void printOp(const MachineOperand &MO, bool IsCallOp = false); +- void printOperand(const MachineInstr *MI, int opNum); +- void printBaseOffsetPair (const MachineInstr *MI, int i, bool brackets=true); +- void printModuleLevelGV(const GlobalVariable* GVar); +- bool runOnMachineFunction(MachineFunction &F); +- bool doInitialization(Module &M); +- bool doFinalization(Module &M); +- +- bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, +- unsigned AsmVariant, const char *ExtraCode); +- bool PrintAsmMemoryOperand(const MachineInstr *MI, +- unsigned OpNo, +- unsigned AsmVariant, +- const char *ExtraCode); +- }; +-} // end of anonymous namespace +- +-/// createAlphaCodePrinterPass - Returns a pass that prints the Alpha +-/// assembly code for a MachineFunction to the given output stream, +-/// using the given target machine description. This should work +-/// regardless of whether the function is in SSA form. +-/// +-FunctionPass *llvm::createAlphaCodePrinterPass(raw_ostream &o, +- TargetMachine &tm) { +- return new AlphaAsmPrinter(o, tm, tm.getTargetAsmInfo()); +-} +- +-#include "AlphaGenAsmWriter.inc" +- +-void AlphaAsmPrinter::printOperand(const MachineInstr *MI, int opNum) +-{ +- const MachineOperand &MO = MI->getOperand(opNum); +- if (MO.getType() == MachineOperand::MO_Register) { +- assert(TargetRegisterInfo::isPhysicalRegister(MO.getReg()) && +- "Not physreg??"); +- O << TM.getRegisterInfo()->get(MO.getReg()).AsmName; +- } else if (MO.isImm()) { +- O << MO.getImm(); +- assert(MO.getImm() < (1 << 30)); +- } else { +- printOp(MO); +- } +-} +- +- +-void AlphaAsmPrinter::printOp(const MachineOperand &MO, bool IsCallOp) { +- const TargetRegisterInfo &RI = *TM.getRegisterInfo(); +- +- switch (MO.getType()) { +- case MachineOperand::MO_Register: +- O << RI.get(MO.getReg()).AsmName; +- return; +- +- case MachineOperand::MO_Immediate: +- cerr << "printOp() does not handle immediate values\n"; +- abort(); +- return; +- +- case MachineOperand::MO_MachineBasicBlock: +- printBasicBlockLabel(MO.getMBB()); +- return; +- +- case MachineOperand::MO_ConstantPoolIndex: +- O << TAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << "_" +- << MO.getIndex(); +- return; +- +- case MachineOperand::MO_ExternalSymbol: +- O << MO.getSymbolName(); +- return; +- +- case MachineOperand::MO_GlobalAddress: { +- GlobalValue *GV = MO.getGlobal(); +- O << Mang->getValueName(GV); +- if (GV->isDeclaration() && GV->hasExternalWeakLinkage()) +- ExtWeakSymbols.insert(GV); +- return; +- } +- +- case MachineOperand::MO_JumpTableIndex: +- O << TAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber() +- << '_' << MO.getIndex(); +- return; +- +- default: +- O << ""; +- return; +- } +-} +- +-/// runOnMachineFunction - This uses the printMachineInstruction() +-/// method to print assembly for each instruction. +-/// +-bool AlphaAsmPrinter::runOnMachineFunction(MachineFunction &MF) { +- SetupMachineFunction(MF); +- O << "\n\n"; +- +- // Print out constants referenced by the function +- EmitConstantPool(MF.getConstantPool()); +- +- // Print out jump tables referenced by the function +- EmitJumpTableInfo(MF.getJumpTableInfo(), MF); +- +- // Print out labels for the function. +- const Function *F = MF.getFunction(); +- SwitchToSection(TAI->SectionForGlobal(F)); +- +- EmitAlignment(4, F); +- switch (F->getLinkage()) { +- default: assert(0 && "Unknown linkage type!"); +- case Function::InternalLinkage: // Symbols default to internal. +- break; +- case Function::ExternalLinkage: +- O << "\t.globl " << CurrentFnName << "\n"; +- break; +- case Function::WeakLinkage: +- case Function::LinkOnceLinkage: +- O << TAI->getWeakRefDirective() << CurrentFnName << "\n"; +- break; +- } +- +- printVisibility(CurrentFnName, F->getVisibility()); +- +- O << "\t.ent " << CurrentFnName << "\n"; +- +- O << CurrentFnName << ":\n"; +- +- // Print out code for the function. +- for (MachineFunction::const_iterator I = MF.begin(), E = MF.end(); +- I != E; ++I) { +- if (I != MF.begin()) { +- printBasicBlockLabel(I, true, true); +- O << '\n'; +- } +- for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end(); +- II != E; ++II) { +- // Print the assembly for the instruction. +- ++EmittedInsts; +- if (!printInstruction(II)) { +- assert(0 && "Unhandled instruction in asm writer!"); +- abort(); +- } +- } +- } +- +- O << "\t.end " << CurrentFnName << "\n"; +- +- // We didn't modify anything. +- return false; +-} +- +-bool AlphaAsmPrinter::doInitialization(Module &M) +-{ +- if(TM.getSubtarget().hasCT()) +- O << "\t.arch ev6\n"; //This might need to be ev67, so leave this test here +- else +- O << "\t.arch ev6\n"; +- O << "\t.set noat\n"; +- return AsmPrinter::doInitialization(M); +-} +- +-void AlphaAsmPrinter::printModuleLevelGV(const GlobalVariable* GVar) { +- const TargetData *TD = TM.getTargetData(); +- +- if (!GVar->hasInitializer()) return; // External global require no code +- +- // Check to see if this is a special global used by LLVM, if so, emit it. +- if (EmitSpecialLLVMGlobal(GVar)) +- return; +- +- std::string name = Mang->getValueName(GVar); +- Constant *C = GVar->getInitializer(); +- unsigned Size = TD->getABITypeSize(C->getType()); +- unsigned Align = TD->getPreferredAlignmentLog(GVar); +- +- // 0: Switch to section +- SwitchToSection(TAI->SectionForGlobal(GVar)); +- +- // 1: Check visibility +- printVisibility(name, GVar->getVisibility()); +- +- // 2: Kind +- switch (GVar->getLinkage()) { +- case GlobalValue::LinkOnceLinkage: +- case GlobalValue::WeakLinkage: +- case GlobalValue::CommonLinkage: +- O << TAI->getWeakRefDirective() << name << '\n'; +- break; +- case GlobalValue::AppendingLinkage: +- case GlobalValue::ExternalLinkage: +- O << TAI->getGlobalDirective() << name << "\n"; +- break; +- case GlobalValue::InternalLinkage: +- break; +- default: +- assert(0 && "Unknown linkage type!"); +- cerr << "Unknown linkage type!\n"; +- abort(); +- } +- +- // 3: Type, Size, Align +- if (TAI->hasDotTypeDotSizeDirective()) { +- O << "\t.type\t" << name << ", @object\n"; +- O << "\t.size\t" << name << ", " << Size << "\n"; +- } +- +- EmitAlignment(Align, GVar); +- +- O << name << ":\n"; +- +- // If the initializer is a extern weak symbol, remember to emit the weak +- // reference! +- if (const GlobalValue *GV = dyn_cast(C)) +- if (GV->hasExternalWeakLinkage()) +- ExtWeakSymbols.insert(GV); +- +- EmitGlobalConstant(C); +- O << '\n'; +-} +- +-bool AlphaAsmPrinter::doFinalization(Module &M) { +- for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); +- I != E; ++I) +- printModuleLevelGV(I); +- +- return AsmPrinter::doFinalization(M); +-} +- +-/// PrintAsmOperand - Print out an operand for an inline asm expression. +-/// +-bool AlphaAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, +- unsigned AsmVariant, +- const char *ExtraCode) { +- printOperand(MI, OpNo); +- return false; +-} +- +-bool AlphaAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, +- unsigned OpNo, +- unsigned AsmVariant, +- const char *ExtraCode) { +- if (ExtraCode && ExtraCode[0]) +- return true; // Unknown modifier. +- O << "0("; +- printOperand(MI, OpNo); +- O << ")"; +- return false; +-} +diff --git a/lib/Target/Alpha/AsmPrinter/AlphaAsmPrinter.cpp b/lib/Target/Alpha/AsmPrinter/AlphaAsmPrinter.cpp +new file mode 100644 +index 0000000..5fb6918 +--- /dev/null ++++ b/lib/Target/Alpha/AsmPrinter/AlphaAsmPrinter.cpp +@@ -0,0 +1,294 @@ ++//===-- AlphaAsmPrinter.cpp - Alpha LLVM assembly writer ------------------===// ++// ++// The LLVM Compiler Infrastructure ++// ++// This file is distributed under the University of Illinois Open Source ++// License. See LICENSE.TXT for details. ++// ++//===----------------------------------------------------------------------===// ++// ++// This file contains a printer that converts from our internal representation ++// of machine-dependent LLVM code to GAS-format Alpha assembly language. ++// ++//===----------------------------------------------------------------------===// ++ ++#define DEBUG_TYPE "asm-printer" ++#include "Alpha.h" ++#include "AlphaInstrInfo.h" ++#include "AlphaTargetMachine.h" ++#include "llvm/Module.h" ++#include "llvm/Type.h" ++#include "llvm/Assembly/Writer.h" ++#include "llvm/CodeGen/AsmPrinter.h" ++#include "llvm/Target/TargetAsmInfo.h" ++#include "llvm/Target/TargetMachine.h" ++#include "llvm/Support/Compiler.h" ++#include "llvm/Support/Mangler.h" ++#include "llvm/Support/raw_ostream.h" ++#include "llvm/ADT/Statistic.h" ++using namespace llvm; ++ ++STATISTIC(EmittedInsts, "Number of machine instrs printed"); ++ ++namespace { ++ struct VISIBILITY_HIDDEN AlphaAsmPrinter : public AsmPrinter { ++ ++ /// Unique incrementer for label values for referencing Global values. ++ /// ++ ++ AlphaAsmPrinter(raw_ostream &o, TargetMachine &tm, const TargetAsmInfo *T) ++ : AsmPrinter(o, tm, T) { ++ } ++ ++ virtual const char *getPassName() const { ++ return "Alpha Assembly Printer"; ++ } ++ bool printInstruction(const MachineInstr *MI); ++ void printOp(const MachineOperand &MO, bool IsCallOp = false); ++ void printOperand(const MachineInstr *MI, int opNum); ++ void printBaseOffsetPair (const MachineInstr *MI, int i, bool brackets=true); ++ void printModuleLevelGV(const GlobalVariable* GVar); ++ bool runOnMachineFunction(MachineFunction &F); ++ bool doInitialization(Module &M); ++ bool doFinalization(Module &M); ++ ++ bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, ++ unsigned AsmVariant, const char *ExtraCode); ++ bool PrintAsmMemoryOperand(const MachineInstr *MI, ++ unsigned OpNo, ++ unsigned AsmVariant, ++ const char *ExtraCode); ++ }; ++} // end of anonymous namespace ++ ++/// createAlphaCodePrinterPass - Returns a pass that prints the Alpha ++/// assembly code for a MachineFunction to the given output stream, ++/// using the given target machine description. This should work ++/// regardless of whether the function is in SSA form. ++/// ++FunctionPass *llvm::createAlphaCodePrinterPass(raw_ostream &o, ++ TargetMachine &tm) { ++ return new AlphaAsmPrinter(o, tm, tm.getTargetAsmInfo()); ++} ++ ++#include "AlphaGenAsmWriter.inc" ++ ++void AlphaAsmPrinter::printOperand(const MachineInstr *MI, int opNum) ++{ ++ const MachineOperand &MO = MI->getOperand(opNum); ++ if (MO.getType() == MachineOperand::MO_Register) { ++ assert(TargetRegisterInfo::isPhysicalRegister(MO.getReg()) && ++ "Not physreg??"); ++ O << TM.getRegisterInfo()->get(MO.getReg()).AsmName; ++ } else if (MO.isImm()) { ++ O << MO.getImm(); ++ assert(MO.getImm() < (1 << 30)); ++ } else { ++ printOp(MO); ++ } ++} ++ ++ ++void AlphaAsmPrinter::printOp(const MachineOperand &MO, bool IsCallOp) { ++ const TargetRegisterInfo &RI = *TM.getRegisterInfo(); ++ ++ switch (MO.getType()) { ++ case MachineOperand::MO_Register: ++ O << RI.get(MO.getReg()).AsmName; ++ return; ++ ++ case MachineOperand::MO_Immediate: ++ cerr << "printOp() does not handle immediate values\n"; ++ abort(); ++ return; ++ ++ case MachineOperand::MO_MachineBasicBlock: ++ printBasicBlockLabel(MO.getMBB()); ++ return; ++ ++ case MachineOperand::MO_ConstantPoolIndex: ++ O << TAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << "_" ++ << MO.getIndex(); ++ return; ++ ++ case MachineOperand::MO_ExternalSymbol: ++ O << MO.getSymbolName(); ++ return; ++ ++ case MachineOperand::MO_GlobalAddress: { ++ GlobalValue *GV = MO.getGlobal(); ++ O << Mang->getValueName(GV); ++ if (GV->isDeclaration() && GV->hasExternalWeakLinkage()) ++ ExtWeakSymbols.insert(GV); ++ return; ++ } ++ ++ case MachineOperand::MO_JumpTableIndex: ++ O << TAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber() ++ << '_' << MO.getIndex(); ++ return; ++ ++ default: ++ O << ""; ++ return; ++ } ++} ++ ++/// runOnMachineFunction - This uses the printMachineInstruction() ++/// method to print assembly for each instruction. ++/// ++bool AlphaAsmPrinter::runOnMachineFunction(MachineFunction &MF) { ++ SetupMachineFunction(MF); ++ O << "\n\n"; ++ ++ // Print out constants referenced by the function ++ EmitConstantPool(MF.getConstantPool()); ++ ++ // Print out jump tables referenced by the function ++ EmitJumpTableInfo(MF.getJumpTableInfo(), MF); ++ ++ // Print out labels for the function. ++ const Function *F = MF.getFunction(); ++ SwitchToSection(TAI->SectionForGlobal(F)); ++ ++ EmitAlignment(4, F); ++ switch (F->getLinkage()) { ++ default: assert(0 && "Unknown linkage type!"); ++ case Function::InternalLinkage: // Symbols default to internal. ++ break; ++ case Function::ExternalLinkage: ++ O << "\t.globl " << CurrentFnName << "\n"; ++ break; ++ case Function::WeakLinkage: ++ case Function::LinkOnceLinkage: ++ O << TAI->getWeakRefDirective() << CurrentFnName << "\n"; ++ break; ++ } ++ ++ printVisibility(CurrentFnName, F->getVisibility()); ++ ++ O << "\t.ent " << CurrentFnName << "\n"; ++ ++ O << CurrentFnName << ":\n"; ++ ++ // Print out code for the function. ++ for (MachineFunction::const_iterator I = MF.begin(), E = MF.end(); ++ I != E; ++I) { ++ if (I != MF.begin()) { ++ printBasicBlockLabel(I, true, true); ++ O << '\n'; ++ } ++ for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end(); ++ II != E; ++II) { ++ // Print the assembly for the instruction. ++ ++EmittedInsts; ++ if (!printInstruction(II)) { ++ assert(0 && "Unhandled instruction in asm writer!"); ++ abort(); ++ } ++ } ++ } ++ ++ O << "\t.end " << CurrentFnName << "\n"; ++ ++ // We didn't modify anything. ++ return false; ++} ++ ++bool AlphaAsmPrinter::doInitialization(Module &M) ++{ ++ if(TM.getSubtarget().hasCT()) ++ O << "\t.arch ev6\n"; //This might need to be ev67, so leave this test here ++ else ++ O << "\t.arch ev6\n"; ++ O << "\t.set noat\n"; ++ return AsmPrinter::doInitialization(M); ++} ++ ++void AlphaAsmPrinter::printModuleLevelGV(const GlobalVariable* GVar) { ++ const TargetData *TD = TM.getTargetData(); ++ ++ if (!GVar->hasInitializer()) return; // External global require no code ++ ++ // Check to see if this is a special global used by LLVM, if so, emit it. ++ if (EmitSpecialLLVMGlobal(GVar)) ++ return; ++ ++ std::string name = Mang->getValueName(GVar); ++ Constant *C = GVar->getInitializer(); ++ unsigned Size = TD->getABITypeSize(C->getType()); ++ unsigned Align = TD->getPreferredAlignmentLog(GVar); ++ ++ // 0: Switch to section ++ SwitchToSection(TAI->SectionForGlobal(GVar)); ++ ++ // 1: Check visibility ++ printVisibility(name, GVar->getVisibility()); ++ ++ // 2: Kind ++ switch (GVar->getLinkage()) { ++ case GlobalValue::LinkOnceLinkage: ++ case GlobalValue::WeakLinkage: ++ case GlobalValue::CommonLinkage: ++ O << TAI->getWeakRefDirective() << name << '\n'; ++ break; ++ case GlobalValue::AppendingLinkage: ++ case GlobalValue::ExternalLinkage: ++ O << TAI->getGlobalDirective() << name << "\n"; ++ break; ++ case GlobalValue::InternalLinkage: ++ break; ++ default: ++ assert(0 && "Unknown linkage type!"); ++ cerr << "Unknown linkage type!\n"; ++ abort(); ++ } ++ ++ // 3: Type, Size, Align ++ if (TAI->hasDotTypeDotSizeDirective()) { ++ O << "\t.type\t" << name << ", @object\n"; ++ O << "\t.size\t" << name << ", " << Size << "\n"; ++ } ++ ++ EmitAlignment(Align, GVar); ++ ++ O << name << ":\n"; ++ ++ // If the initializer is a extern weak symbol, remember to emit the weak ++ // reference! ++ if (const GlobalValue *GV = dyn_cast(C)) ++ if (GV->hasExternalWeakLinkage()) ++ ExtWeakSymbols.insert(GV); ++ ++ EmitGlobalConstant(C); ++ O << '\n'; ++} ++ ++bool AlphaAsmPrinter::doFinalization(Module &M) { ++ for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); ++ I != E; ++I) ++ printModuleLevelGV(I); ++ ++ return AsmPrinter::doFinalization(M); ++} ++ ++/// PrintAsmOperand - Print out an operand for an inline asm expression. ++/// ++bool AlphaAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, ++ unsigned AsmVariant, ++ const char *ExtraCode) { ++ printOperand(MI, OpNo); ++ return false; ++} ++ ++bool AlphaAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, ++ unsigned OpNo, ++ unsigned AsmVariant, ++ const char *ExtraCode) { ++ if (ExtraCode && ExtraCode[0]) ++ return true; // Unknown modifier. ++ O << "0("; ++ printOperand(MI, OpNo); ++ O << ")"; ++ return false; ++} +diff --git a/lib/Target/Alpha/AsmPrinter/CMakeLists.txt b/lib/Target/Alpha/AsmPrinter/CMakeLists.txt +new file mode 100644 +index 0000000..b62a7f6 +--- /dev/null ++++ b/lib/Target/Alpha/AsmPrinter/CMakeLists.txt +@@ -0,0 +1,9 @@ ++include_directories( ${CMAKE_CURRENT_BINARY_DIR}/.. ${CMAKE_CURRENT_SOURCE_DIR}/.. ) ++ ++add_partially_linked_object(LLVMAlphaAsmPrinter ++ AlphaAsmPrinter.cpp ++ ) ++ ++target_name_of_partially_linked_object(LLVMAlphaCodeGen n) ++ ++add_dependencies(LLVMAlphaAsmPrinter ${n}) +diff --git a/lib/Target/Alpha/AsmPrinter/Makefile b/lib/Target/Alpha/AsmPrinter/Makefile +new file mode 100644 +index 0000000..532a3f9 +--- /dev/null ++++ b/lib/Target/Alpha/AsmPrinter/Makefile +@@ -0,0 +1,15 @@ ++##===- lib/Target/Alpha/Makefile ---------------------------*- Makefile -*-===## ++# ++# The LLVM Compiler Infrastructure ++# ++# This file is distributed under the University of Illinois Open Source ++# License. See LICENSE.TXT for details. ++# ++##===----------------------------------------------------------------------===## ++LEVEL = ../../../.. ++LIBRARYNAME = LLVMAlphaAsmPrinter ++ ++# Hack: we need to include 'main' alpha target directory to grab private headers ++CPPFLAGS = -I$(PROJ_OBJ_DIR)/.. -I$(PROJ_SRC_DIR)/.. ++ ++include $(LEVEL)/Makefile.common +diff --git a/lib/Target/Alpha/Makefile b/lib/Target/Alpha/Makefile +index cc427d6..14c91f4 100644 +--- a/lib/Target/Alpha/Makefile ++++ b/lib/Target/Alpha/Makefile +@@ -7,7 +7,7 @@ + # + ##===----------------------------------------------------------------------===## + LEVEL = ../../.. +-LIBRARYNAME = LLVMAlpha ++LIBRARYNAME = LLVMAlphaCodeGen + TARGET = Alpha + + # Make sure that tblgen is run, first thing. +@@ -17,4 +17,6 @@ BUILT_SOURCES = AlphaGenRegisterInfo.h.inc AlphaGenRegisterNames.inc \ + AlphaGenAsmWriter.inc AlphaGenDAGISel.inc \ + AlphaGenSubtarget.inc + ++DIRS = AsmPrinter ++ + include $(LEVEL)/Makefile.common +-- +1.5.6.5 + --- llvm-2.4.orig/debian/patches/0008-Separate-sparc-asmprinter.-This-should-unbreak-the-n.patch +++ llvm-2.4/debian/patches/0008-Separate-sparc-asmprinter.-This-should-unbreak-the-n.patch @@ -0,0 +1,708 @@ +From 6083791b36faf9db4a241a7ddd390b1a7decaa67 Mon Sep 17 00:00:00 2001 +From: asl +Date: Tue, 11 Nov 2008 16:42:57 +0000 +Subject: [PATCH] Separate sparc asmprinter. This should unbreak the native build + +git-svn-id: http://llvm.org/svn/llvm-project/llvm/trunk@59047 91177308-0d34-0410-b5e6-96231b3b80d8 +--- + lib/Target/Sparc/AsmPrinter/CMakeLists.txt | 9 + + lib/Target/Sparc/AsmPrinter/Makefile | 15 ++ + lib/Target/Sparc/AsmPrinter/SparcAsmPrinter.cpp | 309 +++++++++++++++++++++++ + lib/Target/Sparc/Makefile | 4 +- + lib/Target/Sparc/SparcAsmPrinter.cpp | 309 ----------------------- + 5 files changed, 336 insertions(+), 310 deletions(-) + create mode 100644 lib/Target/Sparc/AsmPrinter/CMakeLists.txt + create mode 100644 lib/Target/Sparc/AsmPrinter/Makefile + create mode 100644 lib/Target/Sparc/AsmPrinter/SparcAsmPrinter.cpp + delete mode 100644 lib/Target/Sparc/SparcAsmPrinter.cpp + +diff --git a/lib/Target/Sparc/AsmPrinter/CMakeLists.txt b/lib/Target/Sparc/AsmPrinter/CMakeLists.txt +new file mode 100644 +index 0000000..394b4cd +--- /dev/null ++++ b/lib/Target/Sparc/AsmPrinter/CMakeLists.txt +@@ -0,0 +1,9 @@ ++include_directories( ${CMAKE_CURRENT_BINARY_DIR}/.. ${CMAKE_CURRENT_SOURCE_DIR}/.. ) ++ ++add_partially_linked_object(LLVMSparcAsmPrinter ++ SparcAsmPrinter.cpp ++ ) ++ ++target_name_of_partially_linked_object(LLVMSparcCodeGen n) ++ ++add_dependencies(LLVMSparcAsmPrinter ${n}) +diff --git a/lib/Target/Sparc/AsmPrinter/Makefile b/lib/Target/Sparc/AsmPrinter/Makefile +new file mode 100644 +index 0000000..e71527d +--- /dev/null ++++ b/lib/Target/Sparc/AsmPrinter/Makefile +@@ -0,0 +1,15 @@ ++##===- lib/Target/Sparc/Makefile ---------------------------*- Makefile -*-===## ++# ++# The LLVM Compiler Infrastructure ++# ++# This file is distributed under the University of Illinois Open Source ++# License. See LICENSE.TXT for details. ++# ++##===----------------------------------------------------------------------===## ++LEVEL = ../../../.. ++LIBRARYNAME = LLVMSparcAsmPrinter ++ ++# Hack: we need to include 'main' Sparc target directory to grab private headers ++CPPFLAGS = -I$(PROJ_OBJ_DIR)/.. -I$(PROJ_SRC_DIR)/.. ++ ++include $(LEVEL)/Makefile.common +diff --git a/lib/Target/Sparc/AsmPrinter/SparcAsmPrinter.cpp b/lib/Target/Sparc/AsmPrinter/SparcAsmPrinter.cpp +new file mode 100644 +index 0000000..f6e3f66 +--- /dev/null ++++ b/lib/Target/Sparc/AsmPrinter/SparcAsmPrinter.cpp +@@ -0,0 +1,309 @@ ++//===-- SparcAsmPrinter.cpp - Sparc LLVM assembly writer ------------------===// ++// ++// The LLVM Compiler Infrastructure ++// ++// This file is distributed under the University of Illinois Open Source ++// License. See LICENSE.TXT for details. ++// ++//===----------------------------------------------------------------------===// ++// ++// This file contains a printer that converts from our internal representation ++// of machine-dependent LLVM code to GAS-format SPARC assembly language. ++// ++//===----------------------------------------------------------------------===// ++ ++#define DEBUG_TYPE "asm-printer" ++#include "Sparc.h" ++#include "SparcInstrInfo.h" ++#include "llvm/Constants.h" ++#include "llvm/DerivedTypes.h" ++#include "llvm/Module.h" ++#include "llvm/CodeGen/AsmPrinter.h" ++#include "llvm/CodeGen/MachineFunctionPass.h" ++#include "llvm/CodeGen/MachineConstantPool.h" ++#include "llvm/CodeGen/MachineInstr.h" ++#include "llvm/Target/TargetAsmInfo.h" ++#include "llvm/Target/TargetData.h" ++#include "llvm/Target/TargetMachine.h" ++#include "llvm/Support/Mangler.h" ++#include "llvm/Support/raw_ostream.h" ++#include "llvm/ADT/Statistic.h" ++#include "llvm/ADT/StringExtras.h" ++#include "llvm/Support/CommandLine.h" ++#include "llvm/Support/MathExtras.h" ++#include ++#include ++#include ++using namespace llvm; ++ ++STATISTIC(EmittedInsts, "Number of machine instrs printed"); ++ ++namespace { ++ struct VISIBILITY_HIDDEN SparcAsmPrinter : public AsmPrinter { ++ SparcAsmPrinter(raw_ostream &O, TargetMachine &TM, const TargetAsmInfo *T) ++ : AsmPrinter(O, TM, T) { ++ } ++ ++ /// We name each basic block in a Function with a unique number, so ++ /// that we can consistently refer to them later. This is cleared ++ /// at the beginning of each call to runOnMachineFunction(). ++ /// ++ typedef std::map ValueMapTy; ++ ValueMapTy NumberForBB; ++ ++ virtual const char *getPassName() const { ++ return "Sparc Assembly Printer"; ++ } ++ ++ void printModuleLevelGV(const GlobalVariable* GVar); ++ void printOperand(const MachineInstr *MI, int opNum); ++ void printMemOperand(const MachineInstr *MI, int opNum, ++ const char *Modifier = 0); ++ void printCCOperand(const MachineInstr *MI, int opNum); ++ ++ bool printInstruction(const MachineInstr *MI); // autogenerated. ++ bool runOnMachineFunction(MachineFunction &F); ++ bool doInitialization(Module &M); ++ bool doFinalization(Module &M); ++ }; ++} // end of anonymous namespace ++ ++#include "SparcGenAsmWriter.inc" ++ ++/// createSparcCodePrinterPass - Returns a pass that prints the SPARC ++/// assembly code for a MachineFunction to the given output stream, ++/// using the given target machine description. This should work ++/// regardless of whether the function is in SSA form. ++/// ++FunctionPass *llvm::createSparcCodePrinterPass(raw_ostream &o, ++ TargetMachine &tm) { ++ return new SparcAsmPrinter(o, tm, tm.getTargetAsmInfo()); ++} ++ ++/// runOnMachineFunction - This uses the printInstruction() ++/// method to print assembly for each instruction. ++/// ++bool SparcAsmPrinter::runOnMachineFunction(MachineFunction &MF) { ++ SetupMachineFunction(MF); ++ ++ // Print out constants referenced by the function ++ EmitConstantPool(MF.getConstantPool()); ++ ++ // BBNumber is used here so that a given Printer will never give two ++ // BBs the same name. (If you have a better way, please let me know!) ++ static unsigned BBNumber = 0; ++ ++ O << "\n\n"; ++ // What's my mangled name? ++ CurrentFnName = Mang->getValueName(MF.getFunction()); ++ ++ // Print out the label for the function. ++ const Function *F = MF.getFunction(); ++ SwitchToSection(TAI->SectionForGlobal(F)); ++ EmitAlignment(4, F); ++ O << "\t.globl\t" << CurrentFnName << '\n'; ++ ++ printVisibility(CurrentFnName, F->getVisibility()); ++ ++ O << "\t.type\t" << CurrentFnName << ", #function\n"; ++ O << CurrentFnName << ":\n"; ++ ++ // Number each basic block so that we can consistently refer to them ++ // in PC-relative references. ++ // FIXME: Why not use the MBB numbers? ++ NumberForBB.clear(); ++ for (MachineFunction::const_iterator I = MF.begin(), E = MF.end(); ++ I != E; ++I) { ++ NumberForBB[I->getBasicBlock()] = BBNumber++; ++ } ++ ++ // Print out code for the function. ++ for (MachineFunction::const_iterator I = MF.begin(), E = MF.end(); ++ I != E; ++I) { ++ // Print a label for the basic block. ++ if (I != MF.begin()) { ++ printBasicBlockLabel(I, true, true); ++ O << '\n'; ++ } ++ for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end(); ++ II != E; ++II) { ++ // Print the assembly for the instruction. ++ printInstruction(II); ++ ++EmittedInsts; ++ } ++ } ++ ++ // We didn't modify anything. ++ return false; ++} ++ ++void SparcAsmPrinter::printOperand(const MachineInstr *MI, int opNum) { ++ const MachineOperand &MO = MI->getOperand (opNum); ++ const TargetRegisterInfo &RI = *TM.getRegisterInfo(); ++ bool CloseParen = false; ++ if (MI->getOpcode() == SP::SETHIi && !MO.isReg() && !MO.isImm()) { ++ O << "%hi("; ++ CloseParen = true; ++ } else if ((MI->getOpcode() == SP::ORri || MI->getOpcode() == SP::ADDri) && ++ !MO.isReg() && !MO.isImm()) { ++ O << "%lo("; ++ CloseParen = true; ++ } ++ switch (MO.getType()) { ++ case MachineOperand::MO_Register: ++ if (TargetRegisterInfo::isPhysicalRegister(MO.getReg())) ++ O << "%" << LowercaseString (RI.get(MO.getReg()).AsmName); ++ else ++ O << "%reg" << MO.getReg(); ++ break; ++ ++ case MachineOperand::MO_Immediate: ++ O << (int)MO.getImm(); ++ break; ++ case MachineOperand::MO_MachineBasicBlock: ++ printBasicBlockLabel(MO.getMBB()); ++ return; ++ case MachineOperand::MO_GlobalAddress: ++ O << Mang->getValueName(MO.getGlobal()); ++ break; ++ case MachineOperand::MO_ExternalSymbol: ++ O << MO.getSymbolName(); ++ break; ++ case MachineOperand::MO_ConstantPoolIndex: ++ O << TAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << "_" ++ << MO.getIndex(); ++ break; ++ default: ++ O << ""; abort (); break; ++ } ++ if (CloseParen) O << ")"; ++} ++ ++void SparcAsmPrinter::printMemOperand(const MachineInstr *MI, int opNum, ++ const char *Modifier) { ++ printOperand(MI, opNum); ++ ++ // If this is an ADD operand, emit it like normal operands. ++ if (Modifier && !strcmp(Modifier, "arith")) { ++ O << ", "; ++ printOperand(MI, opNum+1); ++ return; ++ } ++ ++ if (MI->getOperand(opNum+1).isReg() && ++ MI->getOperand(opNum+1).getReg() == SP::G0) ++ return; // don't print "+%g0" ++ if (MI->getOperand(opNum+1).isImm() && ++ MI->getOperand(opNum+1).getImm() == 0) ++ return; // don't print "+0" ++ ++ O << "+"; ++ if (MI->getOperand(opNum+1).isGlobal() || ++ MI->getOperand(opNum+1).isCPI()) { ++ O << "%lo("; ++ printOperand(MI, opNum+1); ++ O << ")"; ++ } else { ++ printOperand(MI, opNum+1); ++ } ++} ++ ++void SparcAsmPrinter::printCCOperand(const MachineInstr *MI, int opNum) { ++ int CC = (int)MI->getOperand(opNum).getImm(); ++ O << SPARCCondCodeToString((SPCC::CondCodes)CC); ++} ++ ++ ++ ++bool SparcAsmPrinter::doInitialization(Module &M) { ++ Mang = new Mangler(M); ++ return false; // success ++} ++ ++bool SparcAsmPrinter::doFinalization(Module &M) { ++ // Print out module-level global variables here. ++ for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); ++ I != E; ++I) ++ printModuleLevelGV(I); ++ ++ O << '\n'; ++ ++ return AsmPrinter::doFinalization(M); ++} ++ ++void SparcAsmPrinter::printModuleLevelGV(const GlobalVariable* GVar) { ++ const TargetData *TD = TM.getTargetData(); ++ ++ if (!GVar->hasInitializer()) ++ return; // External global require no code ++ ++ // Check to see if this is a special global used by LLVM, if so, emit it. ++ if (EmitSpecialLLVMGlobal(GVar)) ++ return; ++ ++ O << "\n\n"; ++ std::string name = Mang->getValueName(GVar); ++ Constant *C = GVar->getInitializer(); ++ unsigned Size = TD->getABITypeSize(C->getType()); ++ unsigned Align = TD->getPreferredAlignment(GVar); ++ ++ printVisibility(name, GVar->getVisibility()); ++ ++ SwitchToSection(TAI->SectionForGlobal(GVar)); ++ ++ if (C->isNullValue() && !GVar->hasSection()) { ++ if (!GVar->isThreadLocal() && ++ (GVar->hasInternalLinkage() || GVar->mayBeOverridden())) { ++ if (Size == 0) Size = 1; // .comm Foo, 0 is undefined, avoid it. ++ ++ if (GVar->hasInternalLinkage()) ++ O << "\t.local " << name << '\n'; ++ ++ O << TAI->getCOMMDirective() << name << ',' << Size; ++ if (TAI->getCOMMDirectiveTakesAlignment()) ++ O << ',' << (1 << Align); ++ ++ O << '\n'; ++ return; ++ } ++ } ++ ++ switch (GVar->getLinkage()) { ++ case GlobalValue::CommonLinkage: ++ case GlobalValue::LinkOnceLinkage: ++ case GlobalValue::WeakLinkage: // FIXME: Verify correct for weak. ++ // Nonnull linkonce -> weak ++ O << "\t.weak " << name << '\n'; ++ break; ++ case GlobalValue::AppendingLinkage: ++ // FIXME: appending linkage variables should go into a section of ++ // their name or something. For now, just emit them as external. ++ case GlobalValue::ExternalLinkage: ++ // If external or appending, declare as a global symbol ++ O << TAI->getGlobalDirective() << name << '\n'; ++ // FALL THROUGH ++ case GlobalValue::InternalLinkage: ++ break; ++ case GlobalValue::GhostLinkage: ++ cerr << "Should not have any unmaterialized functions!\n"; ++ abort(); ++ case GlobalValue::DLLImportLinkage: ++ cerr << "DLLImport linkage is not supported by this target!\n"; ++ abort(); ++ case GlobalValue::DLLExportLinkage: ++ cerr << "DLLExport linkage is not supported by this target!\n"; ++ abort(); ++ default: ++ assert(0 && "Unknown linkage type!"); ++ } ++ ++ EmitAlignment(Align, GVar); ++ ++ if (TAI->hasDotTypeDotSizeDirective()) { ++ O << "\t.type " << name << ",#object\n"; ++ O << "\t.size " << name << ',' << Size << '\n'; ++ } ++ ++ O << name << ":\n"; ++ EmitGlobalConstant(C); ++} +diff --git a/lib/Target/Sparc/Makefile b/lib/Target/Sparc/Makefile +index 69a4cf2..876eb40 100644 +--- a/lib/Target/Sparc/Makefile ++++ b/lib/Target/Sparc/Makefile +@@ -7,7 +7,7 @@ + # + ##===----------------------------------------------------------------------===## + LEVEL = ../../.. +-LIBRARYNAME = LLVMSparc ++LIBRARYNAME = LLVMSparcCodeGen + TARGET = Sparc + + # Make sure that tblgen is run, first thing. +@@ -16,5 +16,7 @@ BUILT_SOURCES = SparcGenRegisterInfo.h.inc SparcGenRegisterNames.inc \ + SparcGenInstrInfo.inc SparcGenAsmWriter.inc \ + SparcGenDAGISel.inc SparcGenSubtarget.inc SparcGenCallingConv.inc + ++DIRS = AsmPrinter ++ + include $(LEVEL)/Makefile.common + +diff --git a/lib/Target/Sparc/SparcAsmPrinter.cpp b/lib/Target/Sparc/SparcAsmPrinter.cpp +deleted file mode 100644 +index f6e3f66..0000000 +--- a/lib/Target/Sparc/SparcAsmPrinter.cpp ++++ /dev/null +@@ -1,309 +0,0 @@ +-//===-- SparcAsmPrinter.cpp - Sparc LLVM assembly writer ------------------===// +-// +-// The LLVM Compiler Infrastructure +-// +-// This file is distributed under the University of Illinois Open Source +-// License. See LICENSE.TXT for details. +-// +-//===----------------------------------------------------------------------===// +-// +-// This file contains a printer that converts from our internal representation +-// of machine-dependent LLVM code to GAS-format SPARC assembly language. +-// +-//===----------------------------------------------------------------------===// +- +-#define DEBUG_TYPE "asm-printer" +-#include "Sparc.h" +-#include "SparcInstrInfo.h" +-#include "llvm/Constants.h" +-#include "llvm/DerivedTypes.h" +-#include "llvm/Module.h" +-#include "llvm/CodeGen/AsmPrinter.h" +-#include "llvm/CodeGen/MachineFunctionPass.h" +-#include "llvm/CodeGen/MachineConstantPool.h" +-#include "llvm/CodeGen/MachineInstr.h" +-#include "llvm/Target/TargetAsmInfo.h" +-#include "llvm/Target/TargetData.h" +-#include "llvm/Target/TargetMachine.h" +-#include "llvm/Support/Mangler.h" +-#include "llvm/Support/raw_ostream.h" +-#include "llvm/ADT/Statistic.h" +-#include "llvm/ADT/StringExtras.h" +-#include "llvm/Support/CommandLine.h" +-#include "llvm/Support/MathExtras.h" +-#include +-#include +-#include +-using namespace llvm; +- +-STATISTIC(EmittedInsts, "Number of machine instrs printed"); +- +-namespace { +- struct VISIBILITY_HIDDEN SparcAsmPrinter : public AsmPrinter { +- SparcAsmPrinter(raw_ostream &O, TargetMachine &TM, const TargetAsmInfo *T) +- : AsmPrinter(O, TM, T) { +- } +- +- /// We name each basic block in a Function with a unique number, so +- /// that we can consistently refer to them later. This is cleared +- /// at the beginning of each call to runOnMachineFunction(). +- /// +- typedef std::map ValueMapTy; +- ValueMapTy NumberForBB; +- +- virtual const char *getPassName() const { +- return "Sparc Assembly Printer"; +- } +- +- void printModuleLevelGV(const GlobalVariable* GVar); +- void printOperand(const MachineInstr *MI, int opNum); +- void printMemOperand(const MachineInstr *MI, int opNum, +- const char *Modifier = 0); +- void printCCOperand(const MachineInstr *MI, int opNum); +- +- bool printInstruction(const MachineInstr *MI); // autogenerated. +- bool runOnMachineFunction(MachineFunction &F); +- bool doInitialization(Module &M); +- bool doFinalization(Module &M); +- }; +-} // end of anonymous namespace +- +-#include "SparcGenAsmWriter.inc" +- +-/// createSparcCodePrinterPass - Returns a pass that prints the SPARC +-/// assembly code for a MachineFunction to the given output stream, +-/// using the given target machine description. This should work +-/// regardless of whether the function is in SSA form. +-/// +-FunctionPass *llvm::createSparcCodePrinterPass(raw_ostream &o, +- TargetMachine &tm) { +- return new SparcAsmPrinter(o, tm, tm.getTargetAsmInfo()); +-} +- +-/// runOnMachineFunction - This uses the printInstruction() +-/// method to print assembly for each instruction. +-/// +-bool SparcAsmPrinter::runOnMachineFunction(MachineFunction &MF) { +- SetupMachineFunction(MF); +- +- // Print out constants referenced by the function +- EmitConstantPool(MF.getConstantPool()); +- +- // BBNumber is used here so that a given Printer will never give two +- // BBs the same name. (If you have a better way, please let me know!) +- static unsigned BBNumber = 0; +- +- O << "\n\n"; +- // What's my mangled name? +- CurrentFnName = Mang->getValueName(MF.getFunction()); +- +- // Print out the label for the function. +- const Function *F = MF.getFunction(); +- SwitchToSection(TAI->SectionForGlobal(F)); +- EmitAlignment(4, F); +- O << "\t.globl\t" << CurrentFnName << '\n'; +- +- printVisibility(CurrentFnName, F->getVisibility()); +- +- O << "\t.type\t" << CurrentFnName << ", #function\n"; +- O << CurrentFnName << ":\n"; +- +- // Number each basic block so that we can consistently refer to them +- // in PC-relative references. +- // FIXME: Why not use the MBB numbers? +- NumberForBB.clear(); +- for (MachineFunction::const_iterator I = MF.begin(), E = MF.end(); +- I != E; ++I) { +- NumberForBB[I->getBasicBlock()] = BBNumber++; +- } +- +- // Print out code for the function. +- for (MachineFunction::const_iterator I = MF.begin(), E = MF.end(); +- I != E; ++I) { +- // Print a label for the basic block. +- if (I != MF.begin()) { +- printBasicBlockLabel(I, true, true); +- O << '\n'; +- } +- for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end(); +- II != E; ++II) { +- // Print the assembly for the instruction. +- printInstruction(II); +- ++EmittedInsts; +- } +- } +- +- // We didn't modify anything. +- return false; +-} +- +-void SparcAsmPrinter::printOperand(const MachineInstr *MI, int opNum) { +- const MachineOperand &MO = MI->getOperand (opNum); +- const TargetRegisterInfo &RI = *TM.getRegisterInfo(); +- bool CloseParen = false; +- if (MI->getOpcode() == SP::SETHIi && !MO.isReg() && !MO.isImm()) { +- O << "%hi("; +- CloseParen = true; +- } else if ((MI->getOpcode() == SP::ORri || MI->getOpcode() == SP::ADDri) && +- !MO.isReg() && !MO.isImm()) { +- O << "%lo("; +- CloseParen = true; +- } +- switch (MO.getType()) { +- case MachineOperand::MO_Register: +- if (TargetRegisterInfo::isPhysicalRegister(MO.getReg())) +- O << "%" << LowercaseString (RI.get(MO.getReg()).AsmName); +- else +- O << "%reg" << MO.getReg(); +- break; +- +- case MachineOperand::MO_Immediate: +- O << (int)MO.getImm(); +- break; +- case MachineOperand::MO_MachineBasicBlock: +- printBasicBlockLabel(MO.getMBB()); +- return; +- case MachineOperand::MO_GlobalAddress: +- O << Mang->getValueName(MO.getGlobal()); +- break; +- case MachineOperand::MO_ExternalSymbol: +- O << MO.getSymbolName(); +- break; +- case MachineOperand::MO_ConstantPoolIndex: +- O << TAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << "_" +- << MO.getIndex(); +- break; +- default: +- O << ""; abort (); break; +- } +- if (CloseParen) O << ")"; +-} +- +-void SparcAsmPrinter::printMemOperand(const MachineInstr *MI, int opNum, +- const char *Modifier) { +- printOperand(MI, opNum); +- +- // If this is an ADD operand, emit it like normal operands. +- if (Modifier && !strcmp(Modifier, "arith")) { +- O << ", "; +- printOperand(MI, opNum+1); +- return; +- } +- +- if (MI->getOperand(opNum+1).isReg() && +- MI->getOperand(opNum+1).getReg() == SP::G0) +- return; // don't print "+%g0" +- if (MI->getOperand(opNum+1).isImm() && +- MI->getOperand(opNum+1).getImm() == 0) +- return; // don't print "+0" +- +- O << "+"; +- if (MI->getOperand(opNum+1).isGlobal() || +- MI->getOperand(opNum+1).isCPI()) { +- O << "%lo("; +- printOperand(MI, opNum+1); +- O << ")"; +- } else { +- printOperand(MI, opNum+1); +- } +-} +- +-void SparcAsmPrinter::printCCOperand(const MachineInstr *MI, int opNum) { +- int CC = (int)MI->getOperand(opNum).getImm(); +- O << SPARCCondCodeToString((SPCC::CondCodes)CC); +-} +- +- +- +-bool SparcAsmPrinter::doInitialization(Module &M) { +- Mang = new Mangler(M); +- return false; // success +-} +- +-bool SparcAsmPrinter::doFinalization(Module &M) { +- // Print out module-level global variables here. +- for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); +- I != E; ++I) +- printModuleLevelGV(I); +- +- O << '\n'; +- +- return AsmPrinter::doFinalization(M); +-} +- +-void SparcAsmPrinter::printModuleLevelGV(const GlobalVariable* GVar) { +- const TargetData *TD = TM.getTargetData(); +- +- if (!GVar->hasInitializer()) +- return; // External global require no code +- +- // Check to see if this is a special global used by LLVM, if so, emit it. +- if (EmitSpecialLLVMGlobal(GVar)) +- return; +- +- O << "\n\n"; +- std::string name = Mang->getValueName(GVar); +- Constant *C = GVar->getInitializer(); +- unsigned Size = TD->getABITypeSize(C->getType()); +- unsigned Align = TD->getPreferredAlignment(GVar); +- +- printVisibility(name, GVar->getVisibility()); +- +- SwitchToSection(TAI->SectionForGlobal(GVar)); +- +- if (C->isNullValue() && !GVar->hasSection()) { +- if (!GVar->isThreadLocal() && +- (GVar->hasInternalLinkage() || GVar->mayBeOverridden())) { +- if (Size == 0) Size = 1; // .comm Foo, 0 is undefined, avoid it. +- +- if (GVar->hasInternalLinkage()) +- O << "\t.local " << name << '\n'; +- +- O << TAI->getCOMMDirective() << name << ',' << Size; +- if (TAI->getCOMMDirectiveTakesAlignment()) +- O << ',' << (1 << Align); +- +- O << '\n'; +- return; +- } +- } +- +- switch (GVar->getLinkage()) { +- case GlobalValue::CommonLinkage: +- case GlobalValue::LinkOnceLinkage: +- case GlobalValue::WeakLinkage: // FIXME: Verify correct for weak. +- // Nonnull linkonce -> weak +- O << "\t.weak " << name << '\n'; +- break; +- case GlobalValue::AppendingLinkage: +- // FIXME: appending linkage variables should go into a section of +- // their name or something. For now, just emit them as external. +- case GlobalValue::ExternalLinkage: +- // If external or appending, declare as a global symbol +- O << TAI->getGlobalDirective() << name << '\n'; +- // FALL THROUGH +- case GlobalValue::InternalLinkage: +- break; +- case GlobalValue::GhostLinkage: +- cerr << "Should not have any unmaterialized functions!\n"; +- abort(); +- case GlobalValue::DLLImportLinkage: +- cerr << "DLLImport linkage is not supported by this target!\n"; +- abort(); +- case GlobalValue::DLLExportLinkage: +- cerr << "DLLExport linkage is not supported by this target!\n"; +- abort(); +- default: +- assert(0 && "Unknown linkage type!"); +- } +- +- EmitAlignment(Align, GVar); +- +- if (TAI->hasDotTypeDotSizeDirective()) { +- O << "\t.type " << name << ",#object\n"; +- O << "\t.size " << name << ',' << Size << '\n'; +- } +- +- O << name << ":\n"; +- EmitGlobalConstant(C); +-} +-- +1.5.6.5 + --- llvm-2.4.orig/debian/patches/0003-Debian-version-info-and-bugreport.patch +++ llvm-2.4/debian/patches/0003-Debian-version-info-and-bugreport.patch @@ -0,0 +1,55 @@ +From e3ab3c64af5717f3c7c311942151bba46bd3e0c6 Mon Sep 17 00:00:00 2001 +From: Arthur Loiret +Date: Sun, 29 Jun 2008 09:32:59 +0000 +Subject: [PATCH] Debian version info and bugreport. + +Signed-off-by: Arthur Loiret +--- + Makefile.rules | 2 +- + configure | 2 +- + lib/Support/CommandLine.cpp | 3 +++ + 3 files changed, 5 insertions(+), 2 deletions(-) + +diff --git a/Makefile.rules b/Makefile.rules +index 0074560..8c24964 100644 +--- a/Makefile.rules ++++ b/Makefile.rules +@@ -489,7 +489,7 @@ CPP.Flags += $(sort -I$(PROJ_OBJ_DIR) -I$(PROJ_SRC_DIR) \ + $(patsubst %,-I%/include,\ + $(PROJ_OBJ_ROOT) $(PROJ_SRC_ROOT) \ + $(LLVM_OBJ_ROOT) $(LLVM_SRC_ROOT))) \ +- $(CPP.BaseFlags) ++ $(CPP.BaseFlags) $(DebianOpts) + + ifeq ($(BUILD_COMPONENT), 1) + Compile.C = $(BUILD_CC) $(CPP.Flags) $(C.Flags) $(CompileCommonOpts) -c +diff --git a/configure b/configure +index 1b7dda8..9a47191 100755 +--- a/configure ++++ b/configure +@@ -717,7 +717,7 @@ PACKAGE_NAME='llvm' + PACKAGE_TARNAME='-llvm-' + PACKAGE_VERSION='2.4' + PACKAGE_STRING='llvm 2.4' +-PACKAGE_BUGREPORT='llvmbugs@cs.uiuc.edu' ++PACKAGE_BUGREPORT='pkg-llvm-team@lists.alioth.debian.org' + + ac_unique_file="lib/VMCore/Module.cpp" + # Factoring default headers for most tests. +diff --git a/lib/Support/CommandLine.cpp b/lib/Support/CommandLine.cpp +index 571b033..d12461e 100644 +--- a/lib/Support/CommandLine.cpp ++++ b/lib/Support/CommandLine.cpp +@@ -1087,6 +1087,9 @@ public: + #ifdef LLVM_VERSION_INFO + cout << LLVM_VERSION_INFO; + #endif ++#ifdef LLVM_DEBIAN_INFO ++ cout << LLVM_DEBIAN_INFO; ++#endif + cout << "\n "; + #ifndef __OPTIMIZE__ + cout << "DEBUG build"; +-- +1.5.6.5 + --- llvm-2.4.orig/debian/patches/0004-Fix-TOOLDIR-path-for-gccas-and-gccld.patch +++ llvm-2.4/debian/patches/0004-Fix-TOOLDIR-path-for-gccas-and-gccld.patch @@ -0,0 +1,70 @@ +From f018aba7231c546ba0b3f597f3b895cc0ef5bc79 Mon Sep 17 00:00:00 2001 +From: Arthur Loiret +Date: Sun, 29 Jun 2008 09:33:25 +0000 +Subject: [PATCH] Fix TOOLDIR path for gccas and gccld. + +Signed-off-by: Arthur Loiret +--- + tools/gccas/Makefile | 7 +++++-- + tools/gccld/Makefile | 7 +++++-- + 2 files changed, 10 insertions(+), 4 deletions(-) + +diff --git a/tools/gccas/Makefile b/tools/gccas/Makefile +index ff84d96..f77e61b 100644 +--- a/tools/gccas/Makefile ++++ b/tools/gccas/Makefile +@@ -10,18 +10,21 @@ LEVEL = ../.. + + include $(LEVEL)/Makefile.common + ++# Debian install path ++TOOLDIR = /usr/lib/llvm/bin ++ + install-local:: $(PROJ_bindir)/gccas + + $(PROJ_bindir)/gccas : gccas.sh Makefile + $(Echo) Installing gccas shell script. +- $(Verb) sed "s#@TOOLDIR@#$(PROJ_bindir)#" $< > $@ ++ $(Verb) sed "s#@TOOLDIR@#$(TOOLDIR)#" $< > $@ + $(Verb) chmod 0755 $@ + + all-local:: $(ToolDir)/gccas + + $(ToolDir)/gccas : gccas.sh Makefile + $(Echo) Making $(ToolDir)/gccas shell script. +- $(Verb) sed "s#@TOOLDIR@#$(ToolDir)#" $< > $@ ++ $(Verb) sed "s#@TOOLDIR@#$(TOOLDIR)#" $< > $@ + $(Verb) chmod 0755 $@ + + clean-local:: +diff --git a/tools/gccld/Makefile b/tools/gccld/Makefile +index b2d3f73..8a1a4e7 100644 +--- a/tools/gccld/Makefile ++++ b/tools/gccld/Makefile +@@ -11,18 +11,21 @@ LEVEL = ../.. + + include $(LEVEL)/Makefile.common + ++# Debian install path ++TOOLDIR = /usr/lib/llvm/bin ++ + install-local:: $(PROJ_bindir)/gccld + + $(PROJ_bindir)/gccld : gccld.sh Makefile + $(Echo) Installing gccld shell script. +- $(Verb) sed "s#@TOOLDIR@#$(PROJ_bindir)#" $< > $@ ++ $(Verb) sed "s#@TOOLDIR@#$(TOOLDIR)#" $< > $@ + $(Verb) chmod 0755 $@ + + all-local:: $(ToolDir)/gccld + + $(ToolDir)/gccld : gccld.sh Makefile + $(Echo) Making $(ToolDir)/gccld shell script. +- $(Verb) sed "s#@TOOLDIR@#$(ToolDir)#" $< > $@ ++ $(Verb) sed "s#@TOOLDIR@#$(TOOLDIR)#" $< > $@ + $(Verb) chmod 0755 $@ + + clean-local:: +-- +1.5.6.5 + --- llvm-2.4.orig/debian/patches/0001-Update-configure-script-for-kfreebsd-gnu-and-hurd.patch +++ llvm-2.4/debian/patches/0001-Update-configure-script-for-kfreebsd-gnu-and-hurd.patch @@ -0,0 +1,38 @@ +From d10a9e6a5313664022c3757662f990438fb20ce5 Mon Sep 17 00:00:00 2001 +From: Arthur Loiret +Date: Sun, 29 Jun 2008 09:31:16 +0000 +Subject: [PATCH] Update configure script for kfreebsd-gnu and hurd. + +Signed-off-by: Arthur Loiret +--- + configure | 7 ++++++- + 1 files changed, 6 insertions(+), 1 deletions(-) + +diff --git a/configure b/configure +index 3857423..1b7dda8 100755 +--- a/configure ++++ b/configure +@@ -2274,7 +2274,7 @@ else + llvm_cv_no_link_all_option="-Wl,-noall_load" + llvm_cv_os_type="Darwin" + llvm_cv_platform_type="Unix" ;; +- *-*-freebsd*) ++ *-*-freebsd* | *-*-kfreebsd-gnu) + llvm_cv_link_all_option="-Wl,--whole-archive" + llvm_cv_no_link_all_option="-Wl,--no-whole-archive" + llvm_cv_os_type="FreeBSD" +@@ -2309,6 +2309,11 @@ else + llvm_cv_no_link_all_option="-Wl,--no-whole-archive" + llvm_cv_os_type="Linux" + llvm_cv_platform_type="Unix" ;; ++ *-*-gnu*) ++ llvm_cv_link_all_option="-Wl,--whole-archive" ++ llvm_cv_no_link_all_option="-Wl,--no-whole-archive" ++ llvm_cv_os_type="GNU" ++ llvm_cv_platform_type="Unix" ;; + *-*-solaris*) + llvm_cv_link_all_option="-Wl,-z,allextract" + llvm_cv_no_link_all_option="-Wl,-z,defaultextract" +-- +1.5.6.5 + --- llvm-2.4.orig/debian/patches/0009-armeabi-no-register-frame.patch +++ llvm-2.4/debian/patches/0009-armeabi-no-register-frame.patch @@ -0,0 +1,20 @@ +--- ./lib/ExecutionEngine/JIT/JIT.cpp~ 2008-09-24 18:25:55.000000000 +0200 ++++ ./lib/ExecutionEngine/JIT/JIT.cpp 2009-01-20 15:54:29.000000000 +0100 +@@ -65,7 +65,7 @@ + } + + +-#if defined (__GNUC__) ++#if defined (__GNUC__) && !defined(__ARM_EABI__) + + // libgcc defines the __register_frame function to dynamically register new + // dwarf frames for exception handling. This functionality is not portable +@@ -225,7 +225,7 @@ + } + + // Register routine for informing unwinding runtime about new EH frames +-#if defined(__GNUC__) ++#if defined(__GNUC__) && !defined(__ARM_EABI__) + #if defined(__APPLE__) + struct LibgccObjectInfo* LOI = (struct LibgccObjectInfo*) + _keymgr_get_and_lock_processwide_ptr(KEYMGR_GCC3_DW2_OBJ_LIST); --- llvm-2.4.orig/debian/patches/0009-fix-static-initialization.patch +++ llvm-2.4/debian/patches/0009-fix-static-initialization.patch @@ -0,0 +1,60 @@ +Index: llvm-2.4/include/llvm/System/DynamicLibrary.h +=================================================================== +--- llvm-2.4.orig/include/llvm/System/DynamicLibrary.h 2008-05-06 03:32:53.000000000 +0200 ++++ llvm-2.4/include/llvm/System/DynamicLibrary.h 2009-01-24 11:24:12.000000000 +0100 +@@ -16,6 +16,7 @@ + + #include "llvm/System/Path.h" + #include ++#include + + namespace llvm { + namespace sys { +@@ -90,6 +91,10 @@ + DynamicLibrary(const DynamicLibrary&); ///< Do not implement + DynamicLibrary& operator=(const DynamicLibrary&); ///< Do not implement + /// @} ++ ++ private: ++ static std::map &g_symbols(); ++ + }; + + } // End sys namespace +Index: llvm-2.4/lib/System/DynamicLibrary.cpp +=================================================================== +--- llvm-2.4.orig/lib/System/DynamicLibrary.cpp 2008-07-10 02:52:20.000000000 +0200 ++++ llvm-2.4/lib/System/DynamicLibrary.cpp 2009-01-24 11:27:42.000000000 +0100 +@@ -14,14 +14,18 @@ + #include "llvm/System/DynamicLibrary.h" + #include "llvm/Config/config.h" + #include +-#include + + // Collection of symbol name/value pairs to be searched prior to any libraries. +-static std::map g_symbols; ++std::map &llvm::sys::DynamicLibrary::g_symbols() { ++ static std::map *symbols ++ = new std::map(); ++ ++ return *symbols; ++} + + void llvm::sys::DynamicLibrary::AddSymbol(const char* symbolName, + void *symbolValue) { +- g_symbols[symbolName] = symbolValue; ++ g_symbols()[symbolName] = symbolValue; + } + + // It is not possible to use ltdl.c on VC++ builds as the terms of its LGPL +@@ -75,8 +79,8 @@ + // check_ltdl_initialization(); + + // First check symbols added via AddSymbol(). +- std::map::iterator I = g_symbols.find(symbolName); +- if (I != g_symbols.end()) ++ std::map::iterator I = g_symbols().find(symbolName); ++ if (I != g_symbols().end()) + return I->second; + + // Now search the libraries. --- llvm-2.4.orig/lib/AsmParser/llvmAsmParser.cpp.cvs +++ llvm-2.4/lib/AsmParser/llvmAsmParser.cpp.cvs @@ -394,7 +394,7 @@ /* Copy the first part of user declarations. */ -#line 14 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 14 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" #include "ParserInternals.h" #include "llvm/CallingConv.h" @@ -1375,7 +1375,7 @@ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED typedef union YYSTYPE -#line 974 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 974 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { llvm::Module *ModuleVal; llvm::Function *FunctionVal; @@ -3661,152 +3661,152 @@ switch (yyn) { case 29: -#line 1146 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1146 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.IPredicate) = ICmpInst::ICMP_EQ; ;} break; case 30: -#line 1146 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1146 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.IPredicate) = ICmpInst::ICMP_NE; ;} break; case 31: -#line 1147 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1147 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.IPredicate) = ICmpInst::ICMP_SLT; ;} break; case 32: -#line 1147 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1147 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.IPredicate) = ICmpInst::ICMP_SGT; ;} break; case 33: -#line 1148 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1148 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.IPredicate) = ICmpInst::ICMP_SLE; ;} break; case 34: -#line 1148 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1148 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.IPredicate) = ICmpInst::ICMP_SGE; ;} break; case 35: -#line 1149 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1149 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.IPredicate) = ICmpInst::ICMP_ULT; ;} break; case 36: -#line 1149 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1149 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.IPredicate) = ICmpInst::ICMP_UGT; ;} break; case 37: -#line 1150 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1150 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.IPredicate) = ICmpInst::ICMP_ULE; ;} break; case 38: -#line 1150 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1150 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.IPredicate) = ICmpInst::ICMP_UGE; ;} break; case 39: -#line 1154 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1154 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FPredicate) = FCmpInst::FCMP_OEQ; ;} break; case 40: -#line 1154 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1154 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FPredicate) = FCmpInst::FCMP_ONE; ;} break; case 41: -#line 1155 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1155 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FPredicate) = FCmpInst::FCMP_OLT; ;} break; case 42: -#line 1155 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1155 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FPredicate) = FCmpInst::FCMP_OGT; ;} break; case 43: -#line 1156 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1156 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FPredicate) = FCmpInst::FCMP_OLE; ;} break; case 44: -#line 1156 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1156 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FPredicate) = FCmpInst::FCMP_OGE; ;} break; case 45: -#line 1157 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1157 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FPredicate) = FCmpInst::FCMP_ORD; ;} break; case 46: -#line 1157 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1157 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FPredicate) = FCmpInst::FCMP_UNO; ;} break; case 47: -#line 1158 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1158 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FPredicate) = FCmpInst::FCMP_UEQ; ;} break; case 48: -#line 1158 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1158 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FPredicate) = FCmpInst::FCMP_UNE; ;} break; case 49: -#line 1159 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1159 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FPredicate) = FCmpInst::FCMP_ULT; ;} break; case 50: -#line 1159 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1159 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FPredicate) = FCmpInst::FCMP_UGT; ;} break; case 51: -#line 1160 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1160 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FPredicate) = FCmpInst::FCMP_ULE; ;} break; case 52: -#line 1160 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1160 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FPredicate) = FCmpInst::FCMP_UGE; ;} break; case 53: -#line 1161 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1161 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FPredicate) = FCmpInst::FCMP_TRUE; ;} break; case 54: -#line 1162 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1162 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FPredicate) = FCmpInst::FCMP_FALSE; ;} break; case 65: -#line 1171 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1171 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.StrVal) = 0; ;} break; case 66: -#line 1173 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1173 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.UIntVal)=(yyvsp[(3) - (4)].UInt64Val); ;} break; case 67: -#line 1174 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1174 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.UIntVal)=0; ;} break; case 68: -#line 1178 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1178 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.StrVal) = (yyvsp[(1) - (2)].StrVal); CHECK_FOR_ERROR @@ -3814,7 +3814,7 @@ break; case 69: -#line 1182 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1182 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.StrVal) = 0; CHECK_FOR_ERROR @@ -3822,7 +3822,7 @@ break; case 70: -#line 1187 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1187 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.UIntVal) = (yyvsp[(1) - (2)].UIntVal); CHECK_FOR_ERROR @@ -3830,7 +3830,7 @@ break; case 74: -#line 1196 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1196 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.StrVal) = 0; CHECK_FOR_ERROR @@ -3838,7 +3838,7 @@ break; case 75: -#line 1201 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1201 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.StrVal) = (yyvsp[(1) - (2)].StrVal); CHECK_FOR_ERROR @@ -3846,157 +3846,157 @@ break; case 76: -#line 1207 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1207 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::InternalLinkage; ;} break; case 77: -#line 1208 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1208 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::WeakLinkage; ;} break; case 78: -#line 1209 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1209 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;} break; case 79: -#line 1210 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1210 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::AppendingLinkage; ;} break; case 80: -#line 1211 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1211 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;} break; case 81: -#line 1212 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1212 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::CommonLinkage; ;} break; case 82: -#line 1216 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1216 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;} break; case 83: -#line 1217 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1217 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;} break; case 84: -#line 1218 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1218 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;} break; case 85: -#line 1222 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1222 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Visibility) = GlobalValue::DefaultVisibility; ;} break; case 86: -#line 1223 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1223 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Visibility) = GlobalValue::DefaultVisibility; ;} break; case 87: -#line 1224 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1224 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Visibility) = GlobalValue::HiddenVisibility; ;} break; case 88: -#line 1225 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1225 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Visibility) = GlobalValue::ProtectedVisibility; ;} break; case 89: -#line 1229 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1229 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;} break; case 90: -#line 1230 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1230 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;} break; case 91: -#line 1231 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1231 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;} break; case 92: -#line 1235 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1235 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;} break; case 93: -#line 1236 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1236 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::InternalLinkage; ;} break; case 94: -#line 1237 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1237 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;} break; case 95: -#line 1238 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1238 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::WeakLinkage; ;} break; case 96: -#line 1239 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1239 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;} break; case 97: -#line 1243 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1243 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;} break; case 98: -#line 1244 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1244 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::WeakLinkage; ;} break; case 99: -#line 1245 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1245 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Linkage) = GlobalValue::InternalLinkage; ;} break; case 100: -#line 1248 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1248 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.UIntVal) = CallingConv::C; ;} break; case 101: -#line 1249 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1249 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.UIntVal) = CallingConv::C; ;} break; case 102: -#line 1250 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1250 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.UIntVal) = CallingConv::Fast; ;} break; case 103: -#line 1251 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1251 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.UIntVal) = CallingConv::Cold; ;} break; case 104: -#line 1252 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1252 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.UIntVal) = CallingConv::X86_StdCall; ;} break; case 105: -#line 1253 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1253 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.UIntVal) = CallingConv::X86_FastCall; ;} break; case 106: -#line 1254 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1254 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if ((unsigned)(yyvsp[(2) - (2)].UInt64Val) != (yyvsp[(2) - (2)].UInt64Val)) GEN_ERROR("Calling conv too large"); @@ -4006,176 +4006,176 @@ break; case 107: -#line 1261 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1261 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::ZExt; ;} break; case 108: -#line 1262 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1262 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::ZExt; ;} break; case 109: -#line 1263 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1263 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::SExt; ;} break; case 110: -#line 1264 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1264 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::SExt; ;} break; case 111: -#line 1265 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1265 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::InReg; ;} break; case 112: -#line 1266 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1266 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::StructRet; ;} break; case 113: -#line 1267 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1267 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::NoAlias; ;} break; case 114: -#line 1268 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1268 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::ByVal; ;} break; case 115: -#line 1269 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1269 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::Nest; ;} break; case 116: -#line 1270 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1270 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::constructAlignmentFromInt((yyvsp[(2) - (2)].UInt64Val)); ;} break; case 117: -#line 1274 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1274 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::None; ;} break; case 118: -#line 1275 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1275 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = (yyvsp[(1) - (2)].Attributes) | (yyvsp[(2) - (2)].Attributes); ;} break; case 119: -#line 1280 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1280 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::InReg; ;} break; case 120: -#line 1281 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1281 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::ZExt; ;} break; case 121: -#line 1282 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1282 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::SExt; ;} break; case 122: -#line 1285 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1285 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::None; ;} break; case 123: -#line 1286 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1286 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = (yyvsp[(1) - (2)].Attributes) | (yyvsp[(2) - (2)].Attributes); ;} break; case 124: -#line 1292 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1292 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::NoReturn; ;} break; case 125: -#line 1293 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1293 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::NoUnwind; ;} break; case 126: -#line 1294 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1294 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::InReg; ;} break; case 127: -#line 1295 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1295 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::ZExt; ;} break; case 128: -#line 1296 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1296 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::SExt; ;} break; case 129: -#line 1297 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1297 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::ReadNone; ;} break; case 130: -#line 1298 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1298 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::ReadOnly; ;} break; case 131: -#line 1299 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" - { (yyval.Attributes) = Attribute::NoInline ;} +#line 1299 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::NoInline; ;} break; case 132: -#line 1300 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" - { (yyval.Attributes) = Attribute::AlwaysInline ;} +#line 1300 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::AlwaysInline; ;} break; case 133: -#line 1301 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" - { (yyval.Attributes) = Attribute::OptimizeForSize ;} +#line 1301 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::OptimizeForSize; ;} break; case 134: -#line 1304 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1304 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = Attribute::None; ;} break; case 135: -#line 1305 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1305 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.Attributes) = (yyvsp[(1) - (2)].Attributes) | (yyvsp[(2) - (2)].Attributes); ;} break; case 136: -#line 1311 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1311 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.StrVal) = 0; ;} break; case 137: -#line 1312 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1312 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.StrVal) = (yyvsp[(2) - (2)].StrVal); ;} break; case 138: -#line 1319 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1319 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.UIntVal) = 0; ;} break; case 139: -#line 1320 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1320 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.UIntVal) = (yyvsp[(2) - (2)].UInt64Val); if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal))) @@ -4185,12 +4185,12 @@ break; case 140: -#line 1326 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1326 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.UIntVal) = 0; ;} break; case 141: -#line 1327 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1327 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.UIntVal) = (yyvsp[(3) - (3)].UInt64Val); if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal))) @@ -4200,7 +4200,7 @@ break; case 142: -#line 1336 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1336 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { for (unsigned i = 0, e = (yyvsp[(2) - (2)].StrVal)->length(); i != e; ++i) if ((*(yyvsp[(2) - (2)].StrVal))[i] == '"' || (*(yyvsp[(2) - (2)].StrVal))[i] == '\\') @@ -4211,27 +4211,27 @@ break; case 143: -#line 1344 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1344 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.StrVal) = 0; ;} break; case 144: -#line 1345 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1345 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.StrVal) = (yyvsp[(1) - (1)].StrVal); ;} break; case 145: -#line 1350 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1350 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" {;} break; case 146: -#line 1351 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1351 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" {;} break; case 147: -#line 1352 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1352 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CurGV->setSection(*(yyvsp[(1) - (1)].StrVal)); delete (yyvsp[(1) - (1)].StrVal); @@ -4240,7 +4240,7 @@ break; case 148: -#line 1357 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1357 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if ((yyvsp[(2) - (2)].UInt64Val) != 0 && !isPowerOf2_32((yyvsp[(2) - (2)].UInt64Val))) GEN_ERROR("Alignment must be a power of two"); @@ -4250,7 +4250,7 @@ break; case 156: -#line 1373 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1373 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.TypeVal) = new PATypeHolder(OpaqueType::get()); CHECK_FOR_ERROR @@ -4258,7 +4258,7 @@ break; case 157: -#line 1377 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1377 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.TypeVal) = new PATypeHolder((yyvsp[(1) - (1)].PrimType)); CHECK_FOR_ERROR @@ -4266,7 +4266,7 @@ break; case 158: -#line 1381 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1381 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Pointer type? if (*(yyvsp[(1) - (3)].TypeVal) == Type::LabelTy) GEN_ERROR("Cannot form a pointer to a basic block"); @@ -4277,7 +4277,7 @@ break; case 159: -#line 1388 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1388 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Named types are also simple types... const Type* tmp = getTypeVal((yyvsp[(1) - (1)].ValIDVal)); CHECK_FOR_ERROR @@ -4286,7 +4286,7 @@ break; case 160: -#line 1393 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1393 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Type UpReference if ((yyvsp[(2) - (2)].UInt64Val) > (uint64_t)~0U) GEN_ERROR("Value out of range"); OpaqueType *OT = OpaqueType::get(); // Use temporary placeholder @@ -4298,7 +4298,7 @@ break; case 161: -#line 1401 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1401 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Allow but ignore attributes on function types; this permits auto-upgrade. // FIXME: remove in LLVM 3.0. @@ -4337,7 +4337,7 @@ break; case 162: -#line 1436 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1436 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Allow but ignore attributes on function types; this permits auto-upgrade. // FIXME: remove in LLVM 3.0. @@ -4371,7 +4371,7 @@ break; case 163: -#line 1467 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1467 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Sized array type? (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(ArrayType::get(*(yyvsp[(4) - (5)].TypeVal), (yyvsp[(2) - (5)].UInt64Val)))); delete (yyvsp[(4) - (5)].TypeVal); @@ -4380,7 +4380,7 @@ break; case 164: -#line 1472 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1472 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Vector type? const llvm::Type* ElemTy = (yyvsp[(4) - (5)].TypeVal)->get(); if ((unsigned)(yyvsp[(2) - (5)].UInt64Val) != (yyvsp[(2) - (5)].UInt64Val)) @@ -4394,7 +4394,7 @@ break; case 165: -#line 1482 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1482 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Structure type? std::vector Elements; for (std::list::iterator I = (yyvsp[(2) - (3)].TypeList)->begin(), @@ -4408,7 +4408,7 @@ break; case 166: -#line 1492 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1492 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Empty structure type? (yyval.TypeVal) = new PATypeHolder(StructType::get(std::vector())); CHECK_FOR_ERROR @@ -4416,7 +4416,7 @@ break; case 167: -#line 1496 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1496 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { std::vector Elements; for (std::list::iterator I = (yyvsp[(3) - (5)].TypeList)->begin(), @@ -4430,7 +4430,7 @@ break; case 168: -#line 1506 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1506 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Empty structure type? (yyval.TypeVal) = new PATypeHolder(StructType::get(std::vector(), true)); CHECK_FOR_ERROR @@ -4438,7 +4438,7 @@ break; case 169: -#line 1513 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1513 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Allow but ignore attributes on function types; this permits auto-upgrade. // FIXME: remove in LLVM 3.0. @@ -4448,7 +4448,7 @@ break; case 170: -#line 1522 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1522 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (1)].TypeVal))->getDescription()); @@ -4459,14 +4459,14 @@ break; case 171: -#line 1529 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1529 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.TypeVal) = new PATypeHolder(Type::VoidTy); ;} break; case 172: -#line 1534 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1534 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.TypeWithAttrsList) = new TypeWithAttrsList(); (yyval.TypeWithAttrsList)->push_back((yyvsp[(1) - (1)].TypeWithAttrs)); @@ -4475,7 +4475,7 @@ break; case 173: -#line 1539 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1539 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { ((yyval.TypeWithAttrsList)=(yyvsp[(1) - (3)].TypeWithAttrsList))->push_back((yyvsp[(3) - (3)].TypeWithAttrs)); CHECK_FOR_ERROR @@ -4483,7 +4483,7 @@ break; case 175: -#line 1547 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1547 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.TypeWithAttrsList)=(yyvsp[(1) - (3)].TypeWithAttrsList); TypeWithAttrs TWA; TWA.Attrs = Attribute::None; @@ -4494,7 +4494,7 @@ break; case 176: -#line 1554 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1554 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.TypeWithAttrsList) = new TypeWithAttrsList; TypeWithAttrs TWA; TWA.Attrs = Attribute::None; @@ -4505,7 +4505,7 @@ break; case 177: -#line 1561 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1561 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.TypeWithAttrsList) = new TypeWithAttrsList(); CHECK_FOR_ERROR @@ -4513,7 +4513,7 @@ break; case 178: -#line 1569 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1569 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.TypeList) = new std::list(); (yyval.TypeList)->push_back(*(yyvsp[(1) - (1)].TypeVal)); @@ -4523,7 +4523,7 @@ break; case 179: -#line 1575 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1575 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { ((yyval.TypeList)=(yyvsp[(1) - (3)].TypeList))->push_back(*(yyvsp[(3) - (3)].TypeVal)); delete (yyvsp[(3) - (3)].TypeVal); @@ -4532,7 +4532,7 @@ break; case 180: -#line 1587 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1587 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Nonempty unsized arr if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (4)].TypeVal))->getDescription()); @@ -4564,7 +4564,7 @@ break; case 181: -#line 1615 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1615 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription()); @@ -4584,7 +4584,7 @@ break; case 182: -#line 1631 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1631 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription()); @@ -4615,7 +4615,7 @@ break; case 183: -#line 1658 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1658 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Nonempty unsized arr if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (4)].TypeVal))->getDescription()); @@ -4647,7 +4647,7 @@ break; case 184: -#line 1686 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1686 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { const StructType *STy = dyn_cast((yyvsp[(1) - (4)].TypeVal)->get()); if (STy == 0) @@ -4677,7 +4677,7 @@ break; case 185: -#line 1712 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1712 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription()); @@ -4701,7 +4701,7 @@ break; case 186: -#line 1732 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1732 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { const StructType *STy = dyn_cast((yyvsp[(1) - (6)].TypeVal)->get()); if (STy == 0) @@ -4731,7 +4731,7 @@ break; case 187: -#line 1758 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1758 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (5)].TypeVal))->getDescription()); @@ -4755,7 +4755,7 @@ break; case 188: -#line 1778 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1778 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription()); @@ -4771,7 +4771,7 @@ break; case 189: -#line 1790 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1790 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription()); @@ -4782,7 +4782,7 @@ break; case 190: -#line 1797 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1797 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription()); @@ -4852,7 +4852,7 @@ break; case 191: -#line 1863 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1863 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription()); @@ -4866,7 +4866,7 @@ break; case 192: -#line 1873 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1873 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription()); @@ -4880,7 +4880,7 @@ break; case 193: -#line 1883 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1883 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // integral constants if (!ConstantInt::isValueValidForType((yyvsp[(1) - (2)].PrimType), (yyvsp[(2) - (2)].SInt64Val))) GEN_ERROR("Constant value doesn't fit in type"); @@ -4890,7 +4890,7 @@ break; case 194: -#line 1889 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1889 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // arbitrary precision integer constants uint32_t BitWidth = cast((yyvsp[(1) - (2)].PrimType))->getBitWidth(); if ((yyvsp[(2) - (2)].APIntVal)->getBitWidth() > BitWidth) { @@ -4904,7 +4904,7 @@ break; case 195: -#line 1899 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1899 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // integral constants if (!ConstantInt::isValueValidForType((yyvsp[(1) - (2)].PrimType), (yyvsp[(2) - (2)].UInt64Val))) GEN_ERROR("Constant value doesn't fit in type"); @@ -4914,7 +4914,7 @@ break; case 196: -#line 1905 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1905 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // arbitrary precision integer constants uint32_t BitWidth = cast((yyvsp[(1) - (2)].PrimType))->getBitWidth(); if ((yyvsp[(2) - (2)].APIntVal)->getBitWidth() > BitWidth) { @@ -4928,7 +4928,7 @@ break; case 197: -#line 1915 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1915 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Boolean constants if (cast((yyvsp[(1) - (2)].PrimType))->getBitWidth() != 1) GEN_ERROR("Constant true must have type i1"); @@ -4938,7 +4938,7 @@ break; case 198: -#line 1921 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1921 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Boolean constants if (cast((yyvsp[(1) - (2)].PrimType))->getBitWidth() != 1) GEN_ERROR("Constant false must have type i1"); @@ -4948,7 +4948,7 @@ break; case 199: -#line 1927 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1927 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Floating point constants if (!ConstantFP::isValueValidForType((yyvsp[(1) - (2)].PrimType), *(yyvsp[(2) - (2)].FPVal))) GEN_ERROR("Floating point constant invalid for type"); @@ -4963,7 +4963,7 @@ break; case 200: -#line 1940 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1940 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(5) - (6)].TypeVal))->getDescription()); @@ -4979,7 +4979,7 @@ break; case 201: -#line 1952 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1952 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!isa((yyvsp[(3) - (5)].ConstVal)->getType())) GEN_ERROR("GetElementPtr requires a pointer operand"); @@ -5004,7 +5004,7 @@ break; case 202: -#line 1973 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1973 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if ((yyvsp[(3) - (8)].ConstVal)->getType() != Type::Int1Ty) GEN_ERROR("Select condition must be of boolean type"); @@ -5016,7 +5016,7 @@ break; case 203: -#line 1981 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1981 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if ((yyvsp[(3) - (6)].ConstVal)->getType() != (yyvsp[(5) - (6)].ConstVal)->getType()) GEN_ERROR("Binary operator types must match"); @@ -5026,7 +5026,7 @@ break; case 204: -#line 1987 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1987 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if ((yyvsp[(3) - (6)].ConstVal)->getType() != (yyvsp[(5) - (6)].ConstVal)->getType()) GEN_ERROR("Logical operator types must match"); @@ -5041,7 +5041,7 @@ break; case 205: -#line 1998 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 1998 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if ((yyvsp[(4) - (7)].ConstVal)->getType() != (yyvsp[(6) - (7)].ConstVal)->getType()) GEN_ERROR("icmp operand types must match"); @@ -5050,7 +5050,7 @@ break; case 206: -#line 2003 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2003 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if ((yyvsp[(4) - (7)].ConstVal)->getType() != (yyvsp[(6) - (7)].ConstVal)->getType()) GEN_ERROR("fcmp operand types must match"); @@ -5059,7 +5059,7 @@ break; case 207: -#line 2008 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2008 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if ((yyvsp[(4) - (7)].ConstVal)->getType() != (yyvsp[(6) - (7)].ConstVal)->getType()) GEN_ERROR("vicmp operand types must match"); @@ -5068,7 +5068,7 @@ break; case 208: -#line 2013 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2013 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if ((yyvsp[(4) - (7)].ConstVal)->getType() != (yyvsp[(6) - (7)].ConstVal)->getType()) GEN_ERROR("vfcmp operand types must match"); @@ -5077,7 +5077,7 @@ break; case 209: -#line 2018 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2018 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!ExtractElementInst::isValidOperands((yyvsp[(3) - (6)].ConstVal), (yyvsp[(5) - (6)].ConstVal))) GEN_ERROR("Invalid extractelement operands"); @@ -5087,7 +5087,7 @@ break; case 210: -#line 2024 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2024 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!InsertElementInst::isValidOperands((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal))) GEN_ERROR("Invalid insertelement operands"); @@ -5097,7 +5097,7 @@ break; case 211: -#line 2030 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2030 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!ShuffleVectorInst::isValidOperands((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal))) GEN_ERROR("Invalid shufflevector operands"); @@ -5107,7 +5107,7 @@ break; case 212: -#line 2036 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2036 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!isa((yyvsp[(3) - (5)].ConstVal)->getType()) && !isa((yyvsp[(3) - (5)].ConstVal)->getType())) GEN_ERROR("ExtractValue requires an aggregate operand"); @@ -5119,7 +5119,7 @@ break; case 213: -#line 2044 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2044 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!isa((yyvsp[(3) - (7)].ConstVal)->getType()) && !isa((yyvsp[(3) - (7)].ConstVal)->getType())) GEN_ERROR("InsertValue requires an aggregate operand"); @@ -5131,7 +5131,7 @@ break; case 214: -#line 2055 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2055 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { ((yyval.ConstVector) = (yyvsp[(1) - (3)].ConstVector))->push_back((yyvsp[(3) - (3)].ConstVal)); CHECK_FOR_ERROR @@ -5139,7 +5139,7 @@ break; case 215: -#line 2059 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2059 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ConstVector) = new std::vector(); (yyval.ConstVector)->push_back((yyvsp[(1) - (1)].ConstVal)); @@ -5148,27 +5148,27 @@ break; case 216: -#line 2067 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2067 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.BoolVal) = false; ;} break; case 217: -#line 2067 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2067 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.BoolVal) = true; ;} break; case 218: -#line 2070 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2070 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.BoolVal) = true; ;} break; case 219: -#line 2070 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2070 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.BoolVal) = false; ;} break; case 220: -#line 2073 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2073 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { const Type* VTy = (yyvsp[(1) - (2)].TypeVal)->get(); Value *V = getVal(VTy, (yyvsp[(2) - (2)].ValIDVal)); @@ -5184,7 +5184,7 @@ break; case 221: -#line 2085 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2085 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { Constant *Val = (yyvsp[(3) - (6)].ConstVal); const Type *DestTy = (yyvsp[(5) - (6)].TypeVal)->get(); @@ -5200,7 +5200,7 @@ break; case 222: -#line 2106 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2106 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ModuleVal) = ParserResult = CurModule.CurrentModule; CurModule.ModuleDone(); @@ -5209,7 +5209,7 @@ break; case 223: -#line 2111 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2111 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ModuleVal) = ParserResult = CurModule.CurrentModule; CurModule.ModuleDone(); @@ -5218,12 +5218,12 @@ break; case 226: -#line 2124 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2124 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CurFun.isDeclare = false; ;} break; case 227: -#line 2124 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2124 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CurFun.FunctionDone(); CHECK_FOR_ERROR @@ -5231,26 +5231,26 @@ break; case 228: -#line 2128 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2128 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CurFun.isDeclare = true; ;} break; case 229: -#line 2128 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2128 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CHECK_FOR_ERROR ;} break; case 230: -#line 2131 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2131 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CHECK_FOR_ERROR ;} break; case 231: -#line 2134 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2134 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (3)].TypeVal))->getDescription()); @@ -5278,7 +5278,7 @@ break; case 232: -#line 2158 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2158 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { ResolveTypeTo((yyvsp[(1) - (3)].StrVal), (yyvsp[(3) - (3)].PrimType)); @@ -5293,7 +5293,7 @@ break; case 233: -#line 2170 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2170 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { /* "Externally Visible" Linkage */ if ((yyvsp[(5) - (6)].ConstVal) == 0) @@ -5305,14 +5305,14 @@ break; case 234: -#line 2177 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2177 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CurGV = 0; ;} break; case 235: -#line 2181 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2181 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if ((yyvsp[(6) - (7)].ConstVal) == 0) GEN_ERROR("Global value initializer is not a constant"); @@ -5322,14 +5322,14 @@ break; case 236: -#line 2186 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2186 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CurGV = 0; ;} break; case 237: -#line 2190 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2190 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(6) - (7)].TypeVal))->getDescription()); @@ -5340,7 +5340,7 @@ break; case 238: -#line 2196 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2196 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CurGV = 0; CHECK_FOR_ERROR @@ -5348,7 +5348,7 @@ break; case 239: -#line 2200 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2200 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { std::string Name; if ((yyvsp[(1) - (5)].StrVal)) { @@ -5392,21 +5392,21 @@ break; case 240: -#line 2240 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2240 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CHECK_FOR_ERROR ;} break; case 241: -#line 2243 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2243 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CHECK_FOR_ERROR ;} break; case 242: -#line 2249 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2249 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm(); if (AsmSoFar.empty()) @@ -5419,7 +5419,7 @@ break; case 243: -#line 2259 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2259 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CurModule.CurrentModule->setTargetTriple(*(yyvsp[(3) - (3)].StrVal)); delete (yyvsp[(3) - (3)].StrVal); @@ -5427,7 +5427,7 @@ break; case 244: -#line 2263 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2263 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CurModule.CurrentModule->setDataLayout(*(yyvsp[(3) - (3)].StrVal)); delete (yyvsp[(3) - (3)].StrVal); @@ -5435,7 +5435,7 @@ break; case 246: -#line 2270 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2270 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CurModule.CurrentModule->addLibrary(*(yyvsp[(3) - (3)].StrVal)); delete (yyvsp[(3) - (3)].StrVal); @@ -5444,7 +5444,7 @@ break; case 247: -#line 2275 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2275 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CurModule.CurrentModule->addLibrary(*(yyvsp[(1) - (1)].StrVal)); delete (yyvsp[(1) - (1)].StrVal); @@ -5453,14 +5453,14 @@ break; case 248: -#line 2280 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2280 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CHECK_FOR_ERROR ;} break; case 249: -#line 2289 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2289 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (5)].TypeVal))->getDescription()); @@ -5474,7 +5474,7 @@ break; case 250: -#line 2299 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2299 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription()); @@ -5488,7 +5488,7 @@ break; case 251: -#line 2310 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2310 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ArgList) = (yyvsp[(1) - (1)].ArgList); CHECK_FOR_ERROR @@ -5496,7 +5496,7 @@ break; case 252: -#line 2314 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2314 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ArgList) = (yyvsp[(1) - (3)].ArgList); struct ArgListEntry E; @@ -5509,7 +5509,7 @@ break; case 253: -#line 2323 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2323 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ArgList) = new ArgListType; struct ArgListEntry E; @@ -5522,7 +5522,7 @@ break; case 254: -#line 2332 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2332 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ArgList) = 0; CHECK_FOR_ERROR @@ -5530,7 +5530,7 @@ break; case 255: -#line 2338 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2338 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { std::string FunctionName(*(yyvsp[(4) - (11)].StrVal)); delete (yyvsp[(4) - (11)].StrVal); // Free strdup'd memory! @@ -5681,7 +5681,7 @@ break; case 258: -#line 2488 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2488 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FunctionVal) = CurFun.CurrentFunction; @@ -5693,7 +5693,7 @@ break; case 261: -#line 2499 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2499 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FunctionVal) = (yyvsp[(1) - (2)].FunctionVal); CHECK_FOR_ERROR @@ -5701,7 +5701,7 @@ break; case 262: -#line 2504 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2504 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CurFun.CurrentFunction->setLinkage((yyvsp[(1) - (3)].Linkage)); CurFun.CurrentFunction->setVisibility((yyvsp[(2) - (3)].Visibility)); @@ -5712,7 +5712,7 @@ break; case 263: -#line 2516 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2516 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.BoolVal) = false; CHECK_FOR_ERROR @@ -5720,7 +5720,7 @@ break; case 264: -#line 2520 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2520 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.BoolVal) = true; CHECK_FOR_ERROR @@ -5728,7 +5728,7 @@ break; case 265: -#line 2525 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2525 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // A reference to a direct constant (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].SInt64Val)); CHECK_FOR_ERROR @@ -5736,7 +5736,7 @@ break; case 266: -#line 2529 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2529 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].UInt64Val)); CHECK_FOR_ERROR @@ -5744,7 +5744,7 @@ break; case 267: -#line 2533 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2533 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // arbitrary precision integer constants (yyval.ValIDVal) = ValID::create(*(yyvsp[(1) - (1)].APIntVal), true); delete (yyvsp[(1) - (1)].APIntVal); @@ -5753,7 +5753,7 @@ break; case 268: -#line 2538 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2538 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // arbitrary precision integer constants (yyval.ValIDVal) = ValID::create(*(yyvsp[(1) - (1)].APIntVal), false); delete (yyvsp[(1) - (1)].APIntVal); @@ -5762,7 +5762,7 @@ break; case 269: -#line 2543 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2543 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Perhaps it's an FP constant? (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].FPVal)); CHECK_FOR_ERROR @@ -5770,7 +5770,7 @@ break; case 270: -#line 2547 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2547 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ValIDVal) = ValID::create(ConstantInt::getTrue()); CHECK_FOR_ERROR @@ -5778,7 +5778,7 @@ break; case 271: -#line 2551 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2551 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ValIDVal) = ValID::create(ConstantInt::getFalse()); CHECK_FOR_ERROR @@ -5786,7 +5786,7 @@ break; case 272: -#line 2555 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2555 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ValIDVal) = ValID::createNull(); CHECK_FOR_ERROR @@ -5794,7 +5794,7 @@ break; case 273: -#line 2559 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2559 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ValIDVal) = ValID::createUndef(); CHECK_FOR_ERROR @@ -5802,7 +5802,7 @@ break; case 274: -#line 2563 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2563 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // A vector zero constant. (yyval.ValIDVal) = ValID::createZeroInit(); CHECK_FOR_ERROR @@ -5810,7 +5810,7 @@ break; case 275: -#line 2567 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2567 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Nonempty unsized packed vector const Type *ETy = (*(yyvsp[(2) - (3)].ConstVector))[0]->getType(); unsigned NumElements = (yyvsp[(2) - (3)].ConstVector)->size(); @@ -5836,7 +5836,7 @@ break; case 276: -#line 2589 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2589 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Nonempty unsized arr const Type *ETy = (*(yyvsp[(2) - (3)].ConstVector))[0]->getType(); uint64_t NumElements = (yyvsp[(2) - (3)].ConstVector)->size(); @@ -5862,7 +5862,7 @@ break; case 277: -#line 2611 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2611 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Use undef instead of an array because it's inconvenient to determine // the element type at this point, there being no elements to examine. @@ -5872,7 +5872,7 @@ break; case 278: -#line 2617 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2617 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { uint64_t NumElements = (yyvsp[(2) - (2)].StrVal)->length(); const Type *ETy = Type::Int8Ty; @@ -5889,7 +5889,7 @@ break; case 279: -#line 2630 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2630 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { std::vector Elements((yyvsp[(2) - (3)].ConstVector)->size()); for (unsigned i = 0, e = (yyvsp[(2) - (3)].ConstVector)->size(); i != e; ++i) @@ -5905,7 +5905,7 @@ break; case 280: -#line 2642 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2642 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { const StructType *STy = StructType::get(std::vector()); (yyval.ValIDVal) = ValID::create(ConstantStruct::get(STy, std::vector())); @@ -5914,7 +5914,7 @@ break; case 281: -#line 2647 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2647 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { std::vector Elements((yyvsp[(3) - (5)].ConstVector)->size()); for (unsigned i = 0, e = (yyvsp[(3) - (5)].ConstVector)->size(); i != e; ++i) @@ -5930,7 +5930,7 @@ break; case 282: -#line 2659 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2659 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { const StructType *STy = StructType::get(std::vector(), /*isPacked=*/true); @@ -5940,7 +5940,7 @@ break; case 283: -#line 2665 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2665 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].ConstVal)); CHECK_FOR_ERROR @@ -5948,7 +5948,7 @@ break; case 284: -#line 2669 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2669 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ValIDVal) = ValID::createInlineAsm(*(yyvsp[(3) - (5)].StrVal), *(yyvsp[(5) - (5)].StrVal), (yyvsp[(2) - (5)].BoolVal)); delete (yyvsp[(3) - (5)].StrVal); @@ -5958,7 +5958,7 @@ break; case 285: -#line 2679 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2679 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Is it an integer reference...? (yyval.ValIDVal) = ValID::createLocalID((yyvsp[(1) - (1)].UIntVal)); CHECK_FOR_ERROR @@ -5966,7 +5966,7 @@ break; case 286: -#line 2683 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2683 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ValIDVal) = ValID::createGlobalID((yyvsp[(1) - (1)].UIntVal)); CHECK_FOR_ERROR @@ -5974,7 +5974,7 @@ break; case 287: -#line 2687 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2687 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Is it a named reference...? (yyval.ValIDVal) = ValID::createLocalName(*(yyvsp[(1) - (1)].StrVal)); delete (yyvsp[(1) - (1)].StrVal); @@ -5983,7 +5983,7 @@ break; case 288: -#line 2692 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2692 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Is it a named reference...? (yyval.ValIDVal) = ValID::createGlobalName(*(yyvsp[(1) - (1)].StrVal)); delete (yyvsp[(1) - (1)].StrVal); @@ -5992,7 +5992,7 @@ break; case 291: -#line 2705 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2705 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription()); @@ -6003,7 +6003,7 @@ break; case 292: -#line 2714 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2714 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ValueList) = new std::vector(); (yyval.ValueList)->push_back((yyvsp[(1) - (1)].ValueVal)); @@ -6012,7 +6012,7 @@ break; case 293: -#line 2719 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2719 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { ((yyval.ValueList)=(yyvsp[(1) - (3)].ValueList))->push_back((yyvsp[(3) - (3)].ValueVal)); CHECK_FOR_ERROR @@ -6020,7 +6020,7 @@ break; case 294: -#line 2724 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2724 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.FunctionVal) = (yyvsp[(1) - (2)].FunctionVal); CHECK_FOR_ERROR @@ -6028,7 +6028,7 @@ break; case 295: -#line 2728 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2728 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Do not allow functions with 0 basic blocks (yyval.FunctionVal) = (yyvsp[(1) - (2)].FunctionVal); CHECK_FOR_ERROR @@ -6036,7 +6036,7 @@ break; case 296: -#line 2737 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2737 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { setValueName((yyvsp[(3) - (3)].TermInstVal), (yyvsp[(2) - (3)].StrVal)); CHECK_FOR_ERROR @@ -6048,7 +6048,7 @@ break; case 297: -#line 2746 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2746 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CHECK_FOR_ERROR int ValNum = InsertValue((yyvsp[(3) - (3)].TermInstVal)); @@ -6063,7 +6063,7 @@ break; case 298: -#line 2759 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2759 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (CastInst *CI1 = dyn_cast((yyvsp[(2) - (2)].InstVal))) if (CastInst *CI2 = dyn_cast(CI1->getOperand(0))) @@ -6076,7 +6076,7 @@ break; case 299: -#line 2768 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2768 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Empty space between instruction lists (yyval.BasicBlockVal) = defineBBVal(ValID::createLocalID(CurFun.NextValNum)); CHECK_FOR_ERROR @@ -6084,7 +6084,7 @@ break; case 300: -#line 2772 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2772 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Labelled (named) basic block (yyval.BasicBlockVal) = defineBBVal(ValID::createLocalName(*(yyvsp[(1) - (1)].StrVal))); delete (yyvsp[(1) - (1)].StrVal); @@ -6094,7 +6094,7 @@ break; case 301: -#line 2780 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2780 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Return with a result... ValueList &VL = *(yyvsp[(2) - (2)].ValueList); assert(!VL.empty() && "Invalid ret operands!"); @@ -6118,7 +6118,7 @@ break; case 302: -#line 2800 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2800 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Return with no result... (yyval.TermInstVal) = ReturnInst::Create(); CHECK_FOR_ERROR @@ -6126,7 +6126,7 @@ break; case 303: -#line 2804 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2804 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Unconditional Branch... BasicBlock* tmpBB = getBBVal((yyvsp[(3) - (3)].ValIDVal)); CHECK_FOR_ERROR @@ -6135,7 +6135,7 @@ break; case 304: -#line 2809 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2809 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (cast((yyvsp[(2) - (9)].PrimType))->getBitWidth() != 1) GEN_ERROR("Branch condition must have type i1"); @@ -6150,7 +6150,7 @@ break; case 305: -#line 2820 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2820 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { Value* tmpVal = getVal((yyvsp[(2) - (9)].PrimType), (yyvsp[(3) - (9)].ValIDVal)); CHECK_FOR_ERROR @@ -6173,7 +6173,7 @@ break; case 306: -#line 2839 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2839 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { Value* tmpVal = getVal((yyvsp[(2) - (8)].PrimType), (yyvsp[(3) - (8)].ValIDVal)); CHECK_FOR_ERROR @@ -6186,7 +6186,7 @@ break; case 307: -#line 2849 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2849 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Handle the short syntax @@ -6293,7 +6293,7 @@ break; case 308: -#line 2952 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2952 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.TermInstVal) = new UnwindInst(); CHECK_FOR_ERROR @@ -6301,7 +6301,7 @@ break; case 309: -#line 2956 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2956 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.TermInstVal) = new UnreachableInst(); CHECK_FOR_ERROR @@ -6309,7 +6309,7 @@ break; case 310: -#line 2963 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2963 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.JumpTable) = (yyvsp[(1) - (6)].JumpTable); Constant *V = cast(getExistingVal((yyvsp[(2) - (6)].PrimType), (yyvsp[(3) - (6)].ValIDVal))); @@ -6324,7 +6324,7 @@ break; case 311: -#line 2974 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2974 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.JumpTable) = new std::vector >(); Constant *V = cast(getExistingVal((yyvsp[(1) - (5)].PrimType), (yyvsp[(2) - (5)].ValIDVal))); @@ -6340,7 +6340,7 @@ break; case 312: -#line 2987 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2987 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Is this definition named?? if so, assign the name... setValueName((yyvsp[(2) - (2)].InstVal), (yyvsp[(1) - (2)].StrVal)); @@ -6352,7 +6352,7 @@ break; case 313: -#line 2996 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 2996 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { CHECK_FOR_ERROR int ValNum = InsertValue((yyvsp[(2) - (2)].InstVal)); @@ -6367,7 +6367,7 @@ break; case 314: -#line 3009 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3009 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Used for PHI nodes if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (6)].TypeVal))->getDescription()); @@ -6382,7 +6382,7 @@ break; case 315: -#line 3020 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3020 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.PHIList) = (yyvsp[(1) - (7)].PHIList); Value* tmpVal = getVal((yyvsp[(1) - (7)].PHIList)->front().first->getType(), (yyvsp[(4) - (7)].ValIDVal)); @@ -6394,7 +6394,7 @@ break; case 316: -#line 3030 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3030 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // FIXME: Remove trailing OptAttributes in LLVM 3.0, it was a mistake in 2.0 if (!UpRefs.empty()) @@ -6409,7 +6409,7 @@ break; case 317: -#line 3041 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3041 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // FIXME: Remove trailing OptAttributes in LLVM 3.0, it was a mistake in 2.0 // Labels are only valid in ASMs @@ -6421,7 +6421,7 @@ break; case 318: -#line 3049 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3049 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // FIXME: Remove trailing OptAttributes in LLVM 3.0, it was a mistake in 2.0 if (!UpRefs.empty()) @@ -6435,7 +6435,7 @@ break; case 319: -#line 3059 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3059 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // FIXME: Remove trailing OptAttributes in LLVM 3.0, it was a mistake in 2.0 (yyval.ParamList) = (yyvsp[(1) - (6)].ParamList); @@ -6446,17 +6446,17 @@ break; case 320: -#line 3066 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3066 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ParamList) = new ParamList(); ;} break; case 321: -#line 3069 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3069 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ValueList) = new std::vector(); ;} break; case 322: -#line 3070 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3070 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ValueList) = (yyvsp[(1) - (3)].ValueList); (yyval.ValueList)->push_back((yyvsp[(3) - (3)].ValueVal)); @@ -6465,7 +6465,7 @@ break; case 323: -#line 3078 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3078 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ConstantList) = new std::vector(); if ((unsigned)(yyvsp[(2) - (2)].UInt64Val) != (yyvsp[(2) - (2)].UInt64Val)) @@ -6475,7 +6475,7 @@ break; case 324: -#line 3084 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3084 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.ConstantList) = (yyvsp[(1) - (3)].ConstantList); if ((unsigned)(yyvsp[(3) - (3)].UInt64Val) != (yyvsp[(3) - (3)].UInt64Val)) @@ -6486,7 +6486,7 @@ break; case 325: -#line 3093 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3093 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.BoolVal) = true; CHECK_FOR_ERROR @@ -6494,7 +6494,7 @@ break; case 326: -#line 3097 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3097 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.BoolVal) = false; CHECK_FOR_ERROR @@ -6502,7 +6502,7 @@ break; case 327: -#line 3102 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3102 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (5)].TypeVal))->getDescription()); @@ -6522,7 +6522,7 @@ break; case 328: -#line 3118 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3118 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (5)].TypeVal))->getDescription()); @@ -6543,7 +6543,7 @@ break; case 329: -#line 3135 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3135 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription()); @@ -6559,7 +6559,7 @@ break; case 330: -#line 3147 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3147 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription()); @@ -6575,7 +6575,7 @@ break; case 331: -#line 3159 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3159 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription()); @@ -6593,7 +6593,7 @@ break; case 332: -#line 3173 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3173 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription()); @@ -6611,7 +6611,7 @@ break; case 333: -#line 3187 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3187 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(4) - (4)].TypeVal))->getDescription()); @@ -6627,7 +6627,7 @@ break; case 334: -#line 3199 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3199 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (isa((yyvsp[(2) - (6)].ValueVal)->getType())) { // vector select @@ -6652,7 +6652,7 @@ break; case 335: -#line 3220 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3220 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(4) - (4)].TypeVal))->getDescription()); @@ -6663,7 +6663,7 @@ break; case 336: -#line 3227 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3227 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!ExtractElementInst::isValidOperands((yyvsp[(2) - (4)].ValueVal), (yyvsp[(4) - (4)].ValueVal))) GEN_ERROR("Invalid extractelement operands"); @@ -6673,7 +6673,7 @@ break; case 337: -#line 3233 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3233 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!InsertElementInst::isValidOperands((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal))) GEN_ERROR("Invalid insertelement operands"); @@ -6683,7 +6683,7 @@ break; case 338: -#line 3239 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3239 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!ShuffleVectorInst::isValidOperands((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal))) GEN_ERROR("Invalid shufflevector operands"); @@ -6693,7 +6693,7 @@ break; case 339: -#line 3245 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3245 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { const Type *Ty = (yyvsp[(2) - (2)].PHIList)->front().first->getType(); if (!Ty->isFirstClassType()) @@ -6712,7 +6712,7 @@ break; case 340: -#line 3261 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3261 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { // Handle the short syntax @@ -6825,7 +6825,7 @@ break; case 341: -#line 3370 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3370 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.InstVal) = (yyvsp[(1) - (1)].InstVal); CHECK_FOR_ERROR @@ -6833,7 +6833,7 @@ break; case 342: -#line 3375 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3375 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.BoolVal) = true; CHECK_FOR_ERROR @@ -6841,7 +6841,7 @@ break; case 343: -#line 3379 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3379 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { (yyval.BoolVal) = false; CHECK_FOR_ERROR @@ -6849,7 +6849,7 @@ break; case 344: -#line 3386 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3386 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (3)].TypeVal))->getDescription()); @@ -6860,7 +6860,7 @@ break; case 345: -#line 3393 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3393 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (6)].TypeVal))->getDescription()); @@ -6874,7 +6874,7 @@ break; case 346: -#line 3403 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3403 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (3)].TypeVal))->getDescription()); @@ -6885,7 +6885,7 @@ break; case 347: -#line 3410 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3410 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (6)].TypeVal))->getDescription()); @@ -6899,7 +6899,7 @@ break; case 348: -#line 3420 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3420 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!isa((yyvsp[(2) - (2)].ValueVal)->getType())) GEN_ERROR("Trying to free nonpointer type " + @@ -6910,7 +6910,7 @@ break; case 349: -#line 3428 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3428 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (5)].TypeVal))->getDescription()); @@ -6928,7 +6928,7 @@ break; case 350: -#line 3442 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3442 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(5) - (7)].TypeVal))->getDescription()); @@ -6949,7 +6949,7 @@ break; case 351: -#line 3459 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3459 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (5)].TypeVal))->getDescription()); @@ -6967,7 +6967,7 @@ break; case 352: -#line 3473 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3473 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (4)].TypeVal))->getDescription()); @@ -6986,7 +6986,7 @@ break; case 353: -#line 3488 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3488 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (4)].TypeVal))->getDescription()); @@ -7005,7 +7005,7 @@ break; case 354: -#line 3503 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3503 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { if (!UpRefs.empty()) GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (7)].TypeVal))->getDescription()); @@ -7241,7 +7241,7 @@ } -#line 3522 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 3522 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" // common code from the two 'RunVMAsmParser' functions --- llvm-2.4.orig/lib/AsmParser/llvmAsmParser.h +++ llvm-2.4/lib/AsmParser/llvmAsmParser.h @@ -0,0 +1,420 @@ +/* A Bison parser, made by GNU Bison 2.3. */ + +/* Skeleton interface for Bison's Yacc-like parsers in C + + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 + Free Software Foundation, Inc. + + 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, 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., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + ESINT64VAL = 258, + EUINT64VAL = 259, + ESAPINTVAL = 260, + EUAPINTVAL = 261, + LOCALVAL_ID = 262, + GLOBALVAL_ID = 263, + FPVAL = 264, + VOID = 265, + INTTYPE = 266, + FLOAT = 267, + DOUBLE = 268, + X86_FP80 = 269, + FP128 = 270, + PPC_FP128 = 271, + LABEL = 272, + TYPE = 273, + LOCALVAR = 274, + GLOBALVAR = 275, + LABELSTR = 276, + STRINGCONSTANT = 277, + ATSTRINGCONSTANT = 278, + PCTSTRINGCONSTANT = 279, + ZEROINITIALIZER = 280, + TRUETOK = 281, + FALSETOK = 282, + BEGINTOK = 283, + ENDTOK = 284, + DECLARE = 285, + DEFINE = 286, + GLOBAL = 287, + CONSTANT = 288, + SECTION = 289, + ALIAS = 290, + VOLATILE = 291, + THREAD_LOCAL = 292, + TO = 293, + DOTDOTDOT = 294, + NULL_TOK = 295, + UNDEF = 296, + INTERNAL = 297, + LINKONCE = 298, + WEAK = 299, + APPENDING = 300, + DLLIMPORT = 301, + DLLEXPORT = 302, + EXTERN_WEAK = 303, + COMMON = 304, + OPAQUE = 305, + EXTERNAL = 306, + TARGET = 307, + TRIPLE = 308, + ALIGN = 309, + ADDRSPACE = 310, + DEPLIBS = 311, + CALL = 312, + TAIL = 313, + ASM_TOK = 314, + MODULE = 315, + SIDEEFFECT = 316, + CC_TOK = 317, + CCC_TOK = 318, + FASTCC_TOK = 319, + COLDCC_TOK = 320, + X86_STDCALLCC_TOK = 321, + X86_FASTCALLCC_TOK = 322, + DATALAYOUT = 323, + RET = 324, + BR = 325, + SWITCH = 326, + INVOKE = 327, + UNWIND = 328, + UNREACHABLE = 329, + ADD = 330, + SUB = 331, + MUL = 332, + UDIV = 333, + SDIV = 334, + FDIV = 335, + UREM = 336, + SREM = 337, + FREM = 338, + AND = 339, + OR = 340, + XOR = 341, + SHL = 342, + LSHR = 343, + ASHR = 344, + ICMP = 345, + FCMP = 346, + VICMP = 347, + VFCMP = 348, + EQ = 349, + NE = 350, + SLT = 351, + SGT = 352, + SLE = 353, + SGE = 354, + ULT = 355, + UGT = 356, + ULE = 357, + UGE = 358, + OEQ = 359, + ONE = 360, + OLT = 361, + OGT = 362, + OLE = 363, + OGE = 364, + ORD = 365, + UNO = 366, + UEQ = 367, + UNE = 368, + MALLOC = 369, + ALLOCA = 370, + FREE = 371, + LOAD = 372, + STORE = 373, + GETELEMENTPTR = 374, + TRUNC = 375, + ZEXT = 376, + SEXT = 377, + FPTRUNC = 378, + FPEXT = 379, + BITCAST = 380, + UITOFP = 381, + SITOFP = 382, + FPTOUI = 383, + FPTOSI = 384, + INTTOPTR = 385, + PTRTOINT = 386, + PHI_TOK = 387, + SELECT = 388, + VAARG = 389, + EXTRACTELEMENT = 390, + INSERTELEMENT = 391, + SHUFFLEVECTOR = 392, + GETRESULT = 393, + EXTRACTVALUE = 394, + INSERTVALUE = 395, + SIGNEXT = 396, + ZEROEXT = 397, + NORETURN = 398, + INREG = 399, + SRET = 400, + NOUNWIND = 401, + NOALIAS = 402, + BYVAL = 403, + NEST = 404, + READNONE = 405, + READONLY = 406, + GC = 407, + OPTSIZE = 408, + NOINLINE = 409, + ALWAYSINLINE = 410, + DEFAULT = 411, + HIDDEN = 412, + PROTECTED = 413 + }; +#endif +/* Tokens. */ +#define ESINT64VAL 258 +#define EUINT64VAL 259 +#define ESAPINTVAL 260 +#define EUAPINTVAL 261 +#define LOCALVAL_ID 262 +#define GLOBALVAL_ID 263 +#define FPVAL 264 +#define VOID 265 +#define INTTYPE 266 +#define FLOAT 267 +#define DOUBLE 268 +#define X86_FP80 269 +#define FP128 270 +#define PPC_FP128 271 +#define LABEL 272 +#define TYPE 273 +#define LOCALVAR 274 +#define GLOBALVAR 275 +#define LABELSTR 276 +#define STRINGCONSTANT 277 +#define ATSTRINGCONSTANT 278 +#define PCTSTRINGCONSTANT 279 +#define ZEROINITIALIZER 280 +#define TRUETOK 281 +#define FALSETOK 282 +#define BEGINTOK 283 +#define ENDTOK 284 +#define DECLARE 285 +#define DEFINE 286 +#define GLOBAL 287 +#define CONSTANT 288 +#define SECTION 289 +#define ALIAS 290 +#define VOLATILE 291 +#define THREAD_LOCAL 292 +#define TO 293 +#define DOTDOTDOT 294 +#define NULL_TOK 295 +#define UNDEF 296 +#define INTERNAL 297 +#define LINKONCE 298 +#define WEAK 299 +#define APPENDING 300 +#define DLLIMPORT 301 +#define DLLEXPORT 302 +#define EXTERN_WEAK 303 +#define COMMON 304 +#define OPAQUE 305 +#define EXTERNAL 306 +#define TARGET 307 +#define TRIPLE 308 +#define ALIGN 309 +#define ADDRSPACE 310 +#define DEPLIBS 311 +#define CALL 312 +#define TAIL 313 +#define ASM_TOK 314 +#define MODULE 315 +#define SIDEEFFECT 316 +#define CC_TOK 317 +#define CCC_TOK 318 +#define FASTCC_TOK 319 +#define COLDCC_TOK 320 +#define X86_STDCALLCC_TOK 321 +#define X86_FASTCALLCC_TOK 322 +#define DATALAYOUT 323 +#define RET 324 +#define BR 325 +#define SWITCH 326 +#define INVOKE 327 +#define UNWIND 328 +#define UNREACHABLE 329 +#define ADD 330 +#define SUB 331 +#define MUL 332 +#define UDIV 333 +#define SDIV 334 +#define FDIV 335 +#define UREM 336 +#define SREM 337 +#define FREM 338 +#define AND 339 +#define OR 340 +#define XOR 341 +#define SHL 342 +#define LSHR 343 +#define ASHR 344 +#define ICMP 345 +#define FCMP 346 +#define VICMP 347 +#define VFCMP 348 +#define EQ 349 +#define NE 350 +#define SLT 351 +#define SGT 352 +#define SLE 353 +#define SGE 354 +#define ULT 355 +#define UGT 356 +#define ULE 357 +#define UGE 358 +#define OEQ 359 +#define ONE 360 +#define OLT 361 +#define OGT 362 +#define OLE 363 +#define OGE 364 +#define ORD 365 +#define UNO 366 +#define UEQ 367 +#define UNE 368 +#define MALLOC 369 +#define ALLOCA 370 +#define FREE 371 +#define LOAD 372 +#define STORE 373 +#define GETELEMENTPTR 374 +#define TRUNC 375 +#define ZEXT 376 +#define SEXT 377 +#define FPTRUNC 378 +#define FPEXT 379 +#define BITCAST 380 +#define UITOFP 381 +#define SITOFP 382 +#define FPTOUI 383 +#define FPTOSI 384 +#define INTTOPTR 385 +#define PTRTOINT 386 +#define PHI_TOK 387 +#define SELECT 388 +#define VAARG 389 +#define EXTRACTELEMENT 390 +#define INSERTELEMENT 391 +#define SHUFFLEVECTOR 392 +#define GETRESULT 393 +#define EXTRACTVALUE 394 +#define INSERTVALUE 395 +#define SIGNEXT 396 +#define ZEROEXT 397 +#define NORETURN 398 +#define INREG 399 +#define SRET 400 +#define NOUNWIND 401 +#define NOALIAS 402 +#define BYVAL 403 +#define NEST 404 +#define READNONE 405 +#define READONLY 406 +#define GC 407 +#define OPTSIZE 408 +#define NOINLINE 409 +#define ALWAYSINLINE 410 +#define DEFAULT 411 +#define HIDDEN 412 +#define PROTECTED 413 + + + + +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef union YYSTYPE +#line 974 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" +{ + llvm::Module *ModuleVal; + llvm::Function *FunctionVal; + llvm::BasicBlock *BasicBlockVal; + llvm::TerminatorInst *TermInstVal; + llvm::Instruction *InstVal; + llvm::Constant *ConstVal; + + const llvm::Type *PrimType; + std::list *TypeList; + llvm::PATypeHolder *TypeVal; + llvm::Value *ValueVal; + std::vector *ValueList; + std::vector *ConstantList; + llvm::ArgListType *ArgList; + llvm::TypeWithAttrs TypeWithAttrs; + llvm::TypeWithAttrsList *TypeWithAttrsList; + llvm::ParamList *ParamList; + + // Represent the RHS of PHI node + std::list > *PHIList; + std::vector > *JumpTable; + std::vector *ConstVector; + + llvm::GlobalValue::LinkageTypes Linkage; + llvm::GlobalValue::VisibilityTypes Visibility; + llvm::Attributes Attributes; + llvm::APInt *APIntVal; + int64_t SInt64Val; + uint64_t UInt64Val; + int SIntVal; + unsigned UIntVal; + llvm::APFloat *FPVal; + bool BoolVal; + + std::string *StrVal; // This memory must be deleted + llvm::ValID ValIDVal; + + llvm::Instruction::BinaryOps BinaryOpVal; + llvm::Instruction::TermOps TermOpVal; + llvm::Instruction::MemoryOps MemOpVal; + llvm::Instruction::CastOps CastOpVal; + llvm::Instruction::OtherOps OtherOpVal; + llvm::ICmpInst::Predicate IPredicate; + llvm::FCmpInst::Predicate FPredicate; +} +/* Line 1489 of yacc.c. */ +#line 413 "llvmAsmParser.tab.h" + YYSTYPE; +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 +#endif + +extern YYSTYPE llvmAsmlval; + --- llvm-2.4.orig/lib/AsmParser/llvmAsmParser.h.cvs +++ llvm-2.4/lib/AsmParser/llvmAsmParser.h.cvs @@ -360,7 +360,7 @@ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED typedef union YYSTYPE -#line 974 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y" +#line 974 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" { llvm::Module *ModuleVal; llvm::Function *FunctionVal; --- llvm-2.4.orig/lib/AsmParser/llvmAsmParser.y.cvs +++ llvm-2.4/lib/AsmParser/llvmAsmParser.y.cvs @@ -1296,9 +1296,9 @@ | SIGNEXT { $$ = Attribute::SExt; } | READNONE { $$ = Attribute::ReadNone; } | READONLY { $$ = Attribute::ReadOnly; } - | NOINLINE { $$ = Attribute::NoInline } - | ALWAYSINLINE { $$ = Attribute::AlwaysInline } - | OPTSIZE { $$ = Attribute::OptimizeForSize } + | NOINLINE { $$ = Attribute::NoInline; } + | ALWAYSINLINE { $$ = Attribute::AlwaysInline; } + | OPTSIZE { $$ = Attribute::OptimizeForSize; } ; OptFuncAttrs : /* empty */ { $$ = Attribute::None; } --- llvm-2.4.orig/lib/AsmParser/llvmAsmParser.cpp +++ llvm-2.4/lib/AsmParser/llvmAsmParser.cpp @@ -0,0 +1,7319 @@ +/* A Bison parser, made by GNU Bison 2.3. */ + +/* Skeleton implementation for Bison's Yacc-like parsers in C + + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 + Free Software Foundation, Inc. + + 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, 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., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Bison version. */ +#define YYBISON_VERSION "2.3" + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 0 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + +/* Substitute the variable and function names. */ +#define yyparse llvmAsmparse +#define yylex llvmAsmlex +#define yyerror llvmAsmerror +#define yylval llvmAsmlval +#define yychar llvmAsmchar +#define yydebug llvmAsmdebug +#define yynerrs llvmAsmnerrs + + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + ESINT64VAL = 258, + EUINT64VAL = 259, + ESAPINTVAL = 260, + EUAPINTVAL = 261, + LOCALVAL_ID = 262, + GLOBALVAL_ID = 263, + FPVAL = 264, + VOID = 265, + INTTYPE = 266, + FLOAT = 267, + DOUBLE = 268, + X86_FP80 = 269, + FP128 = 270, + PPC_FP128 = 271, + LABEL = 272, + TYPE = 273, + LOCALVAR = 274, + GLOBALVAR = 275, + LABELSTR = 276, + STRINGCONSTANT = 277, + ATSTRINGCONSTANT = 278, + PCTSTRINGCONSTANT = 279, + ZEROINITIALIZER = 280, + TRUETOK = 281, + FALSETOK = 282, + BEGINTOK = 283, + ENDTOK = 284, + DECLARE = 285, + DEFINE = 286, + GLOBAL = 287, + CONSTANT = 288, + SECTION = 289, + ALIAS = 290, + VOLATILE = 291, + THREAD_LOCAL = 292, + TO = 293, + DOTDOTDOT = 294, + NULL_TOK = 295, + UNDEF = 296, + INTERNAL = 297, + LINKONCE = 298, + WEAK = 299, + APPENDING = 300, + DLLIMPORT = 301, + DLLEXPORT = 302, + EXTERN_WEAK = 303, + COMMON = 304, + OPAQUE = 305, + EXTERNAL = 306, + TARGET = 307, + TRIPLE = 308, + ALIGN = 309, + ADDRSPACE = 310, + DEPLIBS = 311, + CALL = 312, + TAIL = 313, + ASM_TOK = 314, + MODULE = 315, + SIDEEFFECT = 316, + CC_TOK = 317, + CCC_TOK = 318, + FASTCC_TOK = 319, + COLDCC_TOK = 320, + X86_STDCALLCC_TOK = 321, + X86_FASTCALLCC_TOK = 322, + DATALAYOUT = 323, + RET = 324, + BR = 325, + SWITCH = 326, + INVOKE = 327, + UNWIND = 328, + UNREACHABLE = 329, + ADD = 330, + SUB = 331, + MUL = 332, + UDIV = 333, + SDIV = 334, + FDIV = 335, + UREM = 336, + SREM = 337, + FREM = 338, + AND = 339, + OR = 340, + XOR = 341, + SHL = 342, + LSHR = 343, + ASHR = 344, + ICMP = 345, + FCMP = 346, + VICMP = 347, + VFCMP = 348, + EQ = 349, + NE = 350, + SLT = 351, + SGT = 352, + SLE = 353, + SGE = 354, + ULT = 355, + UGT = 356, + ULE = 357, + UGE = 358, + OEQ = 359, + ONE = 360, + OLT = 361, + OGT = 362, + OLE = 363, + OGE = 364, + ORD = 365, + UNO = 366, + UEQ = 367, + UNE = 368, + MALLOC = 369, + ALLOCA = 370, + FREE = 371, + LOAD = 372, + STORE = 373, + GETELEMENTPTR = 374, + TRUNC = 375, + ZEXT = 376, + SEXT = 377, + FPTRUNC = 378, + FPEXT = 379, + BITCAST = 380, + UITOFP = 381, + SITOFP = 382, + FPTOUI = 383, + FPTOSI = 384, + INTTOPTR = 385, + PTRTOINT = 386, + PHI_TOK = 387, + SELECT = 388, + VAARG = 389, + EXTRACTELEMENT = 390, + INSERTELEMENT = 391, + SHUFFLEVECTOR = 392, + GETRESULT = 393, + EXTRACTVALUE = 394, + INSERTVALUE = 395, + SIGNEXT = 396, + ZEROEXT = 397, + NORETURN = 398, + INREG = 399, + SRET = 400, + NOUNWIND = 401, + NOALIAS = 402, + BYVAL = 403, + NEST = 404, + READNONE = 405, + READONLY = 406, + GC = 407, + OPTSIZE = 408, + NOINLINE = 409, + ALWAYSINLINE = 410, + DEFAULT = 411, + HIDDEN = 412, + PROTECTED = 413 + }; +#endif +/* Tokens. */ +#define ESINT64VAL 258 +#define EUINT64VAL 259 +#define ESAPINTVAL 260 +#define EUAPINTVAL 261 +#define LOCALVAL_ID 262 +#define GLOBALVAL_ID 263 +#define FPVAL 264 +#define VOID 265 +#define INTTYPE 266 +#define FLOAT 267 +#define DOUBLE 268 +#define X86_FP80 269 +#define FP128 270 +#define PPC_FP128 271 +#define LABEL 272 +#define TYPE 273 +#define LOCALVAR 274 +#define GLOBALVAR 275 +#define LABELSTR 276 +#define STRINGCONSTANT 277 +#define ATSTRINGCONSTANT 278 +#define PCTSTRINGCONSTANT 279 +#define ZEROINITIALIZER 280 +#define TRUETOK 281 +#define FALSETOK 282 +#define BEGINTOK 283 +#define ENDTOK 284 +#define DECLARE 285 +#define DEFINE 286 +#define GLOBAL 287 +#define CONSTANT 288 +#define SECTION 289 +#define ALIAS 290 +#define VOLATILE 291 +#define THREAD_LOCAL 292 +#define TO 293 +#define DOTDOTDOT 294 +#define NULL_TOK 295 +#define UNDEF 296 +#define INTERNAL 297 +#define LINKONCE 298 +#define WEAK 299 +#define APPENDING 300 +#define DLLIMPORT 301 +#define DLLEXPORT 302 +#define EXTERN_WEAK 303 +#define COMMON 304 +#define OPAQUE 305 +#define EXTERNAL 306 +#define TARGET 307 +#define TRIPLE 308 +#define ALIGN 309 +#define ADDRSPACE 310 +#define DEPLIBS 311 +#define CALL 312 +#define TAIL 313 +#define ASM_TOK 314 +#define MODULE 315 +#define SIDEEFFECT 316 +#define CC_TOK 317 +#define CCC_TOK 318 +#define FASTCC_TOK 319 +#define COLDCC_TOK 320 +#define X86_STDCALLCC_TOK 321 +#define X86_FASTCALLCC_TOK 322 +#define DATALAYOUT 323 +#define RET 324 +#define BR 325 +#define SWITCH 326 +#define INVOKE 327 +#define UNWIND 328 +#define UNREACHABLE 329 +#define ADD 330 +#define SUB 331 +#define MUL 332 +#define UDIV 333 +#define SDIV 334 +#define FDIV 335 +#define UREM 336 +#define SREM 337 +#define FREM 338 +#define AND 339 +#define OR 340 +#define XOR 341 +#define SHL 342 +#define LSHR 343 +#define ASHR 344 +#define ICMP 345 +#define FCMP 346 +#define VICMP 347 +#define VFCMP 348 +#define EQ 349 +#define NE 350 +#define SLT 351 +#define SGT 352 +#define SLE 353 +#define SGE 354 +#define ULT 355 +#define UGT 356 +#define ULE 357 +#define UGE 358 +#define OEQ 359 +#define ONE 360 +#define OLT 361 +#define OGT 362 +#define OLE 363 +#define OGE 364 +#define ORD 365 +#define UNO 366 +#define UEQ 367 +#define UNE 368 +#define MALLOC 369 +#define ALLOCA 370 +#define FREE 371 +#define LOAD 372 +#define STORE 373 +#define GETELEMENTPTR 374 +#define TRUNC 375 +#define ZEXT 376 +#define SEXT 377 +#define FPTRUNC 378 +#define FPEXT 379 +#define BITCAST 380 +#define UITOFP 381 +#define SITOFP 382 +#define FPTOUI 383 +#define FPTOSI 384 +#define INTTOPTR 385 +#define PTRTOINT 386 +#define PHI_TOK 387 +#define SELECT 388 +#define VAARG 389 +#define EXTRACTELEMENT 390 +#define INSERTELEMENT 391 +#define SHUFFLEVECTOR 392 +#define GETRESULT 393 +#define EXTRACTVALUE 394 +#define INSERTVALUE 395 +#define SIGNEXT 396 +#define ZEROEXT 397 +#define NORETURN 398 +#define INREG 399 +#define SRET 400 +#define NOUNWIND 401 +#define NOALIAS 402 +#define BYVAL 403 +#define NEST 404 +#define READNONE 405 +#define READONLY 406 +#define GC 407 +#define OPTSIZE 408 +#define NOINLINE 409 +#define ALWAYSINLINE 410 +#define DEFAULT 411 +#define HIDDEN 412 +#define PROTECTED 413 + + + + +/* Copy the first part of user declarations. */ +#line 14 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + +#include "ParserInternals.h" +#include "llvm/CallingConv.h" +#include "llvm/InlineAsm.h" +#include "llvm/Instructions.h" +#include "llvm/Module.h" +#include "llvm/ValueSymbolTable.h" +#include "llvm/AutoUpgrade.h" +#include "llvm/Support/GetElementPtrTypeIterator.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/Support/MathExtras.h" +#include "llvm/Support/Streams.h" +#include +#include +#include +#include + +// The following is a gross hack. In order to rid the libAsmParser library of +// exceptions, we have to have a way of getting the yyparse function to go into +// an error situation. So, whenever we want an error to occur, the GenerateError +// function (see bottom of file) sets TriggerError. Then, at the end of each +// production in the grammer we use CHECK_FOR_ERROR which will invoke YYERROR +// (a goto) to put YACC in error state. Furthermore, several calls to +// GenerateError are made from inside productions and they must simulate the +// previous exception behavior by exiting the production immediately. We have +// replaced these with the GEN_ERROR macro which calls GeneratError and then +// immediately invokes YYERROR. This would be so much cleaner if it was a +// recursive descent parser. +static bool TriggerError = false; +#define CHECK_FOR_ERROR { if (TriggerError) { TriggerError = false; YYABORT; } } +#define GEN_ERROR(msg) { GenerateError(msg); YYERROR; } + +int yyerror(const char *ErrorMsg); // Forward declarations to prevent "implicit +int yylex(); // declaration" of xxx warnings. +int yyparse(); +using namespace llvm; + +static Module *ParserResult; + +// DEBUG_UPREFS - Define this symbol if you want to enable debugging output +// relating to upreferences in the input stream. +// +//#define DEBUG_UPREFS 1 +#ifdef DEBUG_UPREFS +#define UR_OUT(X) cerr << X +#else +#define UR_OUT(X) +#endif + +#define YYERROR_VERBOSE 1 + +static GlobalVariable *CurGV; + + +// This contains info used when building the body of a function. It is +// destroyed when the function is completed. +// +typedef std::vector ValueList; // Numbered defs + +static void +ResolveDefinitions(ValueList &LateResolvers, ValueList *FutureLateResolvers=0); + +static struct PerModuleInfo { + Module *CurrentModule; + ValueList Values; // Module level numbered definitions + ValueList LateResolveValues; + std::vector Types; + std::map LateResolveTypes; + + /// PlaceHolderInfo - When temporary placeholder objects are created, remember + /// how they were referenced and on which line of the input they came from so + /// that we can resolve them later and print error messages as appropriate. + std::map > PlaceHolderInfo; + + // GlobalRefs - This maintains a mapping between 's and forward + // references to global values. Global values may be referenced before they + // are defined, and if so, the temporary object that they represent is held + // here. This is used for forward references of GlobalValues. + // + typedef std::map, GlobalValue*> GlobalRefsType; + GlobalRefsType GlobalRefs; + + void ModuleDone() { + // If we could not resolve some functions at function compilation time + // (calls to functions before they are defined), resolve them now... Types + // are resolved when the constant pool has been completely parsed. + // + ResolveDefinitions(LateResolveValues); + if (TriggerError) + return; + + // Check to make sure that all global value forward references have been + // resolved! + // + if (!GlobalRefs.empty()) { + std::string UndefinedReferences = "Unresolved global references exist:\n"; + + for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end(); + I != E; ++I) { + UndefinedReferences += " " + I->first.first->getDescription() + " " + + I->first.second.getName() + "\n"; + } + GenerateError(UndefinedReferences); + return; + } + + // Look for intrinsic functions and CallInst that need to be upgraded + for (Module::iterator FI = CurrentModule->begin(), + FE = CurrentModule->end(); FI != FE; ) + UpgradeCallsToIntrinsic(FI++); // must be post-increment, as we remove + + Values.clear(); // Clear out function local definitions + Types.clear(); + CurrentModule = 0; + } + + // GetForwardRefForGlobal - Check to see if there is a forward reference + // for this global. If so, remove it from the GlobalRefs map and return it. + // If not, just return null. + GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) { + // Check to see if there is a forward reference to this global variable... + // if there is, eliminate it and patch the reference to use the new def'n. + GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID)); + GlobalValue *Ret = 0; + if (I != GlobalRefs.end()) { + Ret = I->second; + GlobalRefs.erase(I); + } + return Ret; + } + + bool TypeIsUnresolved(PATypeHolder* PATy) { + // If it isn't abstract, its resolved + const Type* Ty = PATy->get(); + if (!Ty->isAbstract()) + return false; + // Traverse the type looking for abstract types. If it isn't abstract then + // we don't need to traverse that leg of the type. + std::vector WorkList, SeenList; + WorkList.push_back(Ty); + while (!WorkList.empty()) { + const Type* Ty = WorkList.back(); + SeenList.push_back(Ty); + WorkList.pop_back(); + if (const OpaqueType* OpTy = dyn_cast(Ty)) { + // Check to see if this is an unresolved type + std::map::iterator I = LateResolveTypes.begin(); + std::map::iterator E = LateResolveTypes.end(); + for ( ; I != E; ++I) { + if (I->second.get() == OpTy) + return true; + } + } else if (const SequentialType* SeqTy = dyn_cast(Ty)) { + const Type* TheTy = SeqTy->getElementType(); + if (TheTy->isAbstract() && TheTy != Ty) { + std::vector::iterator I = SeenList.begin(), + E = SeenList.end(); + for ( ; I != E; ++I) + if (*I == TheTy) + break; + if (I == E) + WorkList.push_back(TheTy); + } + } else if (const StructType* StrTy = dyn_cast(Ty)) { + for (unsigned i = 0; i < StrTy->getNumElements(); ++i) { + const Type* TheTy = StrTy->getElementType(i); + if (TheTy->isAbstract() && TheTy != Ty) { + std::vector::iterator I = SeenList.begin(), + E = SeenList.end(); + for ( ; I != E; ++I) + if (*I == TheTy) + break; + if (I == E) + WorkList.push_back(TheTy); + } + } + } + } + return false; + } +} CurModule; + +static struct PerFunctionInfo { + Function *CurrentFunction; // Pointer to current function being created + + ValueList Values; // Keep track of #'d definitions + unsigned NextValNum; + ValueList LateResolveValues; + bool isDeclare; // Is this function a forward declararation? + GlobalValue::LinkageTypes Linkage; // Linkage for forward declaration. + GlobalValue::VisibilityTypes Visibility; + + /// BBForwardRefs - When we see forward references to basic blocks, keep + /// track of them here. + std::map BBForwardRefs; + + inline PerFunctionInfo() { + CurrentFunction = 0; + isDeclare = false; + Linkage = GlobalValue::ExternalLinkage; + Visibility = GlobalValue::DefaultVisibility; + } + + inline void FunctionStart(Function *M) { + CurrentFunction = M; + NextValNum = 0; + } + + void FunctionDone() { + // Any forward referenced blocks left? + if (!BBForwardRefs.empty()) { + GenerateError("Undefined reference to label " + + BBForwardRefs.begin()->second->getName()); + return; + } + + // Resolve all forward references now. + ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues); + + Values.clear(); // Clear out function local definitions + BBForwardRefs.clear(); + CurrentFunction = 0; + isDeclare = false; + Linkage = GlobalValue::ExternalLinkage; + Visibility = GlobalValue::DefaultVisibility; + } +} CurFun; // Info for the current function... + +static bool inFunctionScope() { return CurFun.CurrentFunction != 0; } + + +//===----------------------------------------------------------------------===// +// Code to handle definitions of all the types +//===----------------------------------------------------------------------===// + +/// InsertValue - Insert a value into the value table. If it is named, this +/// returns -1, otherwise it returns the slot number for the value. +static int InsertValue(Value *V, ValueList &ValueTab = CurFun.Values) { + // Things that have names or are void typed don't get slot numbers + if (V->hasName() || (V->getType() == Type::VoidTy)) + return -1; + + // In the case of function values, we have to allow for the forward reference + // of basic blocks, which are included in the numbering. Consequently, we keep + // track of the next insertion location with NextValNum. When a BB gets + // inserted, it could change the size of the CurFun.Values vector. + if (&ValueTab == &CurFun.Values) { + if (ValueTab.size() <= CurFun.NextValNum) + ValueTab.resize(CurFun.NextValNum+1); + ValueTab[CurFun.NextValNum++] = V; + return CurFun.NextValNum-1; + } + // For all other lists, its okay to just tack it on the back of the vector. + ValueTab.push_back(V); + return ValueTab.size()-1; +} + +static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) { + switch (D.Type) { + case ValID::LocalID: // Is it a numbered definition? + // Module constants occupy the lowest numbered slots... + if (D.Num < CurModule.Types.size()) + return CurModule.Types[D.Num]; + break; + case ValID::LocalName: // Is it a named definition? + if (const Type *N = CurModule.CurrentModule->getTypeByName(D.getName())) { + D.destroy(); // Free old strdup'd memory... + return N; + } + break; + default: + GenerateError("Internal parser error: Invalid symbol type reference"); + return 0; + } + + // If we reached here, we referenced either a symbol that we don't know about + // or an id number that hasn't been read yet. We may be referencing something + // forward, so just create an entry to be resolved later and get to it... + // + if (DoNotImprovise) return 0; // Do we just want a null to be returned? + + + if (inFunctionScope()) { + if (D.Type == ValID::LocalName) { + GenerateError("Reference to an undefined type: '" + D.getName() + "'"); + return 0; + } else { + GenerateError("Reference to an undefined type: #" + utostr(D.Num)); + return 0; + } + } + + std::map::iterator I =CurModule.LateResolveTypes.find(D); + if (I != CurModule.LateResolveTypes.end()) + return I->second; + + Type *Typ = OpaqueType::get(); + CurModule.LateResolveTypes.insert(std::make_pair(D, Typ)); + return Typ; + } + +// getExistingVal - Look up the value specified by the provided type and +// the provided ValID. If the value exists and has already been defined, return +// it. Otherwise return null. +// +static Value *getExistingVal(const Type *Ty, const ValID &D) { + if (isa(Ty)) { + GenerateError("Functions are not values and " + "must be referenced as pointers"); + return 0; + } + + switch (D.Type) { + case ValID::LocalID: { // Is it a numbered definition? + // Check that the number is within bounds. + if (D.Num >= CurFun.Values.size()) + return 0; + Value *Result = CurFun.Values[D.Num]; + if (Ty != Result->getType()) { + GenerateError("Numbered value (%" + utostr(D.Num) + ") of type '" + + Result->getType()->getDescription() + "' does not match " + "expected type, '" + Ty->getDescription() + "'"); + return 0; + } + return Result; + } + case ValID::GlobalID: { // Is it a numbered definition? + if (D.Num >= CurModule.Values.size()) + return 0; + Value *Result = CurModule.Values[D.Num]; + if (Ty != Result->getType()) { + GenerateError("Numbered value (@" + utostr(D.Num) + ") of type '" + + Result->getType()->getDescription() + "' does not match " + "expected type, '" + Ty->getDescription() + "'"); + return 0; + } + return Result; + } + + case ValID::LocalName: { // Is it a named definition? + if (!inFunctionScope()) + return 0; + ValueSymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable(); + Value *N = SymTab.lookup(D.getName()); + if (N == 0) + return 0; + if (N->getType() != Ty) + return 0; + + D.destroy(); // Free old strdup'd memory... + return N; + } + case ValID::GlobalName: { // Is it a named definition? + ValueSymbolTable &SymTab = CurModule.CurrentModule->getValueSymbolTable(); + Value *N = SymTab.lookup(D.getName()); + if (N == 0) + return 0; + if (N->getType() != Ty) + return 0; + + D.destroy(); // Free old strdup'd memory... + return N; + } + + // Check to make sure that "Ty" is an integral type, and that our + // value will fit into the specified type... + case ValID::ConstSIntVal: // Is it a constant pool reference?? + if (!isa(Ty) || + !ConstantInt::isValueValidForType(Ty, D.ConstPool64)) { + GenerateError("Signed integral constant '" + + itostr(D.ConstPool64) + "' is invalid for type '" + + Ty->getDescription() + "'"); + return 0; + } + return ConstantInt::get(Ty, D.ConstPool64, true); + + case ValID::ConstUIntVal: // Is it an unsigned const pool reference? + if (isa(Ty) && + ConstantInt::isValueValidForType(Ty, D.UConstPool64)) + return ConstantInt::get(Ty, D.UConstPool64); + + if (!isa(Ty) || + !ConstantInt::isValueValidForType(Ty, D.ConstPool64)) { + GenerateError("Integral constant '" + utostr(D.UConstPool64) + + "' is invalid or out of range for type '" + + Ty->getDescription() + "'"); + return 0; + } + // This is really a signed reference. Transmogrify. + return ConstantInt::get(Ty, D.ConstPool64, true); + + case ValID::ConstAPInt: // Is it an unsigned const pool reference? + if (!isa(Ty)) { + GenerateError("Integral constant '" + D.getName() + + "' is invalid or out of range for type '" + + Ty->getDescription() + "'"); + return 0; + } + + { + APSInt Tmp = *D.ConstPoolInt; + Tmp.extOrTrunc(Ty->getPrimitiveSizeInBits()); + return ConstantInt::get(Tmp); + } + + case ValID::ConstFPVal: // Is it a floating point const pool reference? + if (!Ty->isFloatingPoint() || + !ConstantFP::isValueValidForType(Ty, *D.ConstPoolFP)) { + GenerateError("FP constant invalid for type"); + return 0; + } + // Lexer has no type info, so builds all float and double FP constants + // as double. Fix this here. Long double does not need this. + if (&D.ConstPoolFP->getSemantics() == &APFloat::IEEEdouble && + Ty==Type::FloatTy) + D.ConstPoolFP->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven); + return ConstantFP::get(*D.ConstPoolFP); + + case ValID::ConstNullVal: // Is it a null value? + if (!isa(Ty)) { + GenerateError("Cannot create a a non pointer null"); + return 0; + } + return ConstantPointerNull::get(cast(Ty)); + + case ValID::ConstUndefVal: // Is it an undef value? + return UndefValue::get(Ty); + + case ValID::ConstZeroVal: // Is it a zero value? + return Constant::getNullValue(Ty); + + case ValID::ConstantVal: // Fully resolved constant? + if (D.ConstantValue->getType() != Ty) { + GenerateError("Constant expression type different from required type"); + return 0; + } + return D.ConstantValue; + + case ValID::InlineAsmVal: { // Inline asm expression + const PointerType *PTy = dyn_cast(Ty); + const FunctionType *FTy = + PTy ? dyn_cast(PTy->getElementType()) : 0; + if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints)) { + GenerateError("Invalid type for asm constraint string"); + return 0; + } + InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints, + D.IAD->HasSideEffects); + D.destroy(); // Free InlineAsmDescriptor. + return IA; + } + default: + assert(0 && "Unhandled case!"); + return 0; + } // End of switch + + assert(0 && "Unhandled case!"); + return 0; +} + +// getVal - This function is identical to getExistingVal, except that if a +// value is not already defined, it "improvises" by creating a placeholder var +// that looks and acts just like the requested variable. When the value is +// defined later, all uses of the placeholder variable are replaced with the +// real thing. +// +static Value *getVal(const Type *Ty, const ValID &ID) { + if (Ty == Type::LabelTy) { + GenerateError("Cannot use a basic block here"); + return 0; + } + + // See if the value has already been defined. + Value *V = getExistingVal(Ty, ID); + if (V) return V; + if (TriggerError) return 0; + + if (!Ty->isFirstClassType() && !isa(Ty)) { + GenerateError("Invalid use of a non-first-class type"); + return 0; + } + + // If we reached here, we referenced either a symbol that we don't know about + // or an id number that hasn't been read yet. We may be referencing something + // forward, so just create an entry to be resolved later and get to it... + // + switch (ID.Type) { + case ValID::GlobalName: + case ValID::GlobalID: { + const PointerType *PTy = dyn_cast(Ty); + if (!PTy) { + GenerateError("Invalid type for reference to global" ); + return 0; + } + const Type* ElTy = PTy->getElementType(); + if (const FunctionType *FTy = dyn_cast(ElTy)) + V = Function::Create(FTy, GlobalValue::ExternalLinkage); + else + V = new GlobalVariable(ElTy, false, GlobalValue::ExternalLinkage, 0, "", + (Module*)0, false, PTy->getAddressSpace()); + break; + } + default: + V = new Argument(Ty); + } + + // Remember where this forward reference came from. FIXME, shouldn't we try + // to recycle these things?? + CurModule.PlaceHolderInfo.insert(std::make_pair(V, std::make_pair(ID, + LLLgetLineNo()))); + + if (inFunctionScope()) + InsertValue(V, CurFun.LateResolveValues); + else + InsertValue(V, CurModule.LateResolveValues); + return V; +} + +/// defineBBVal - This is a definition of a new basic block with the specified +/// identifier which must be the same as CurFun.NextValNum, if its numeric. +static BasicBlock *defineBBVal(const ValID &ID) { + assert(inFunctionScope() && "Can't get basic block at global scope!"); + + BasicBlock *BB = 0; + + // First, see if this was forward referenced + + std::map::iterator BBI = CurFun.BBForwardRefs.find(ID); + if (BBI != CurFun.BBForwardRefs.end()) { + BB = BBI->second; + // The forward declaration could have been inserted anywhere in the + // function: insert it into the correct place now. + CurFun.CurrentFunction->getBasicBlockList().remove(BB); + CurFun.CurrentFunction->getBasicBlockList().push_back(BB); + + // We're about to erase the entry, save the key so we can clean it up. + ValID Tmp = BBI->first; + + // Erase the forward ref from the map as its no longer "forward" + CurFun.BBForwardRefs.erase(ID); + + // The key has been removed from the map but so we don't want to leave + // strdup'd memory around so destroy it too. + Tmp.destroy(); + + // If its a numbered definition, bump the number and set the BB value. + if (ID.Type == ValID::LocalID) { + assert(ID.Num == CurFun.NextValNum && "Invalid new block number"); + InsertValue(BB); + } + } else { + // We haven't seen this BB before and its first mention is a definition. + // Just create it and return it. + std::string Name (ID.Type == ValID::LocalName ? ID.getName() : ""); + BB = BasicBlock::Create(Name, CurFun.CurrentFunction); + if (ID.Type == ValID::LocalID) { + assert(ID.Num == CurFun.NextValNum && "Invalid new block number"); + InsertValue(BB); + } + } + + ID.destroy(); + return BB; +} + +/// getBBVal - get an existing BB value or create a forward reference for it. +/// +static BasicBlock *getBBVal(const ValID &ID) { + assert(inFunctionScope() && "Can't get basic block at global scope!"); + + BasicBlock *BB = 0; + + std::map::iterator BBI = CurFun.BBForwardRefs.find(ID); + if (BBI != CurFun.BBForwardRefs.end()) { + BB = BBI->second; + } if (ID.Type == ValID::LocalName) { + std::string Name = ID.getName(); + Value *N = CurFun.CurrentFunction->getValueSymbolTable().lookup(Name); + if (N) { + if (N->getType()->getTypeID() == Type::LabelTyID) + BB = cast(N); + else + GenerateError("Reference to label '" + Name + "' is actually of type '"+ + N->getType()->getDescription() + "'"); + } + } else if (ID.Type == ValID::LocalID) { + if (ID.Num < CurFun.NextValNum && ID.Num < CurFun.Values.size()) { + if (CurFun.Values[ID.Num]->getType()->getTypeID() == Type::LabelTyID) + BB = cast(CurFun.Values[ID.Num]); + else + GenerateError("Reference to label '%" + utostr(ID.Num) + + "' is actually of type '"+ + CurFun.Values[ID.Num]->getType()->getDescription() + "'"); + } + } else { + GenerateError("Illegal label reference " + ID.getName()); + return 0; + } + + // If its already been defined, return it now. + if (BB) { + ID.destroy(); // Free strdup'd memory. + return BB; + } + + // Otherwise, this block has not been seen before, create it. + std::string Name; + if (ID.Type == ValID::LocalName) + Name = ID.getName(); + BB = BasicBlock::Create(Name, CurFun.CurrentFunction); + + // Insert it in the forward refs map. + CurFun.BBForwardRefs[ID] = BB; + + return BB; +} + + +//===----------------------------------------------------------------------===// +// Code to handle forward references in instructions +//===----------------------------------------------------------------------===// +// +// This code handles the late binding needed with statements that reference +// values not defined yet... for example, a forward branch, or the PHI node for +// a loop body. +// +// This keeps a table (CurFun.LateResolveValues) of all such forward references +// and back patchs after we are done. +// + +// ResolveDefinitions - If we could not resolve some defs at parsing +// time (forward branches, phi functions for loops, etc...) resolve the +// defs now... +// +static void +ResolveDefinitions(ValueList &LateResolvers, ValueList *FutureLateResolvers) { + // Loop over LateResolveDefs fixing up stuff that couldn't be resolved + while (!LateResolvers.empty()) { + Value *V = LateResolvers.back(); + LateResolvers.pop_back(); + + std::map >::iterator PHI = + CurModule.PlaceHolderInfo.find(V); + assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error!"); + + ValID &DID = PHI->second.first; + + Value *TheRealValue = getExistingVal(V->getType(), DID); + if (TriggerError) + return; + if (TheRealValue) { + V->replaceAllUsesWith(TheRealValue); + delete V; + CurModule.PlaceHolderInfo.erase(PHI); + } else if (FutureLateResolvers) { + // Functions have their unresolved items forwarded to the module late + // resolver table + InsertValue(V, *FutureLateResolvers); + } else { + if (DID.Type == ValID::LocalName || DID.Type == ValID::GlobalName) { + GenerateError("Reference to an invalid definition: '" +DID.getName()+ + "' of type '" + V->getType()->getDescription() + "'", + PHI->second.second); + return; + } else { + GenerateError("Reference to an invalid definition: #" + + itostr(DID.Num) + " of type '" + + V->getType()->getDescription() + "'", + PHI->second.second); + return; + } + } + } + LateResolvers.clear(); +} + +// ResolveTypeTo - A brand new type was just declared. This means that (if +// name is not null) things referencing Name can be resolved. Otherwise, things +// refering to the number can be resolved. Do this now. +// +static void ResolveTypeTo(std::string *Name, const Type *ToTy) { + ValID D; + if (Name) + D = ValID::createLocalName(*Name); + else + D = ValID::createLocalID(CurModule.Types.size()); + + std::map::iterator I = + CurModule.LateResolveTypes.find(D); + if (I != CurModule.LateResolveTypes.end()) { + ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy); + CurModule.LateResolveTypes.erase(I); + } + D.destroy(); +} + +// setValueName - Set the specified value to the name given. The name may be +// null potentially, in which case this is a noop. The string passed in is +// assumed to be a malloc'd string buffer, and is free'd by this function. +// +static void setValueName(Value *V, std::string *NameStr) { + if (!NameStr) return; + std::string Name(*NameStr); // Copy string + delete NameStr; // Free old string + + if (V->getType() == Type::VoidTy) { + GenerateError("Can't assign name '" + Name+"' to value with void type"); + return; + } + + assert(inFunctionScope() && "Must be in function scope!"); + ValueSymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable(); + if (ST.lookup(Name)) { + GenerateError("Redefinition of value '" + Name + "' of type '" + + V->getType()->getDescription() + "'"); + return; + } + + // Set the name. + V->setName(Name); +} + +/// ParseGlobalVariable - Handle parsing of a global. If Initializer is null, +/// this is a declaration, otherwise it is a definition. +static GlobalVariable * +ParseGlobalVariable(std::string *NameStr, + GlobalValue::LinkageTypes Linkage, + GlobalValue::VisibilityTypes Visibility, + bool isConstantGlobal, const Type *Ty, + Constant *Initializer, bool IsThreadLocal, + unsigned AddressSpace = 0) { + if (isa(Ty)) { + GenerateError("Cannot declare global vars of function type"); + return 0; + } + if (Ty == Type::LabelTy) { + GenerateError("Cannot declare global vars of label type"); + return 0; + } + + const PointerType *PTy = PointerType::get(Ty, AddressSpace); + + std::string Name; + if (NameStr) { + Name = *NameStr; // Copy string + delete NameStr; // Free old string + } + + // See if this global value was forward referenced. If so, recycle the + // object. + ValID ID; + if (!Name.empty()) { + ID = ValID::createGlobalName(Name); + } else { + ID = ValID::createGlobalID(CurModule.Values.size()); + } + + if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) { + // Move the global to the end of the list, from whereever it was + // previously inserted. + GlobalVariable *GV = cast(FWGV); + CurModule.CurrentModule->getGlobalList().remove(GV); + CurModule.CurrentModule->getGlobalList().push_back(GV); + GV->setInitializer(Initializer); + GV->setLinkage(Linkage); + GV->setVisibility(Visibility); + GV->setConstant(isConstantGlobal); + GV->setThreadLocal(IsThreadLocal); + InsertValue(GV, CurModule.Values); + ID.destroy(); + return GV; + } + + ID.destroy(); + + // If this global has a name + if (!Name.empty()) { + // if the global we're parsing has an initializer (is a definition) and + // has external linkage. + if (Initializer && Linkage != GlobalValue::InternalLinkage) + // If there is already a global with external linkage with this name + if (CurModule.CurrentModule->getGlobalVariable(Name, false)) { + // If we allow this GVar to get created, it will be renamed in the + // symbol table because it conflicts with an existing GVar. We can't + // allow redefinition of GVars whose linking indicates that their name + // must stay the same. Issue the error. + GenerateError("Redefinition of global variable named '" + Name + + "' of type '" + Ty->getDescription() + "'"); + return 0; + } + } + + // Otherwise there is no existing GV to use, create one now. + GlobalVariable *GV = + new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name, + CurModule.CurrentModule, IsThreadLocal, AddressSpace); + GV->setVisibility(Visibility); + InsertValue(GV, CurModule.Values); + return GV; +} + +// setTypeName - Set the specified type to the name given. The name may be +// null potentially, in which case this is a noop. The string passed in is +// assumed to be a malloc'd string buffer, and is freed by this function. +// +// This function returns true if the type has already been defined, but is +// allowed to be redefined in the specified context. If the name is a new name +// for the type plane, it is inserted and false is returned. +static bool setTypeName(const Type *T, std::string *NameStr) { + assert(!inFunctionScope() && "Can't give types function-local names!"); + if (NameStr == 0) return false; + + std::string Name(*NameStr); // Copy string + delete NameStr; // Free old string + + // We don't allow assigning names to void type + if (T == Type::VoidTy) { + GenerateError("Can't assign name '" + Name + "' to the void type"); + return false; + } + + // Set the type name, checking for conflicts as we do so. + bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, T); + + if (AlreadyExists) { // Inserting a name that is already defined??? + const Type *Existing = CurModule.CurrentModule->getTypeByName(Name); + assert(Existing && "Conflict but no matching type?!"); + + // There is only one case where this is allowed: when we are refining an + // opaque type. In this case, Existing will be an opaque type. + if (const OpaqueType *OpTy = dyn_cast(Existing)) { + // We ARE replacing an opaque type! + const_cast(OpTy)->refineAbstractTypeTo(T); + return true; + } + + // Otherwise, this is an attempt to redefine a type. That's okay if + // the redefinition is identical to the original. This will be so if + // Existing and T point to the same Type object. In this one case we + // allow the equivalent redefinition. + if (Existing == T) return true; // Yes, it's equal. + + // Any other kind of (non-equivalent) redefinition is an error. + GenerateError("Redefinition of type named '" + Name + "' of type '" + + T->getDescription() + "'"); + } + + return false; +} + +//===----------------------------------------------------------------------===// +// Code for handling upreferences in type names... +// + +// TypeContains - Returns true if Ty directly contains E in it. +// +static bool TypeContains(const Type *Ty, const Type *E) { + return std::find(Ty->subtype_begin(), Ty->subtype_end(), + E) != Ty->subtype_end(); +} + +namespace { + struct UpRefRecord { + // NestingLevel - The number of nesting levels that need to be popped before + // this type is resolved. + unsigned NestingLevel; + + // LastContainedTy - This is the type at the current binding level for the + // type. Every time we reduce the nesting level, this gets updated. + const Type *LastContainedTy; + + // UpRefTy - This is the actual opaque type that the upreference is + // represented with. + OpaqueType *UpRefTy; + + UpRefRecord(unsigned NL, OpaqueType *URTy) + : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) {} + }; +} + +// UpRefs - A list of the outstanding upreferences that need to be resolved. +static std::vector UpRefs; + +/// HandleUpRefs - Every time we finish a new layer of types, this function is +/// called. It loops through the UpRefs vector, which is a list of the +/// currently active types. For each type, if the up reference is contained in +/// the newly completed type, we decrement the level count. When the level +/// count reaches zero, the upreferenced type is the type that is passed in: +/// thus we can complete the cycle. +/// +static PATypeHolder HandleUpRefs(const Type *ty) { + // If Ty isn't abstract, or if there are no up-references in it, then there is + // nothing to resolve here. + if (!ty->isAbstract() || UpRefs.empty()) return ty; + + PATypeHolder Ty(ty); + UR_OUT("Type '" << Ty->getDescription() << + "' newly formed. Resolving upreferences.\n" << + UpRefs.size() << " upreferences active!\n"); + + // If we find any resolvable upreferences (i.e., those whose NestingLevel goes + // to zero), we resolve them all together before we resolve them to Ty. At + // the end of the loop, if there is anything to resolve to Ty, it will be in + // this variable. + OpaqueType *TypeToResolve = 0; + + for (unsigned i = 0; i != UpRefs.size(); ++i) { + UR_OUT(" UR#" << i << " - TypeContains(" << Ty->getDescription() << ", " + << UpRefs[i].second->getDescription() << ") = " + << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n"); + if (TypeContains(Ty, UpRefs[i].LastContainedTy)) { + // Decrement level of upreference + unsigned Level = --UpRefs[i].NestingLevel; + UpRefs[i].LastContainedTy = Ty; + UR_OUT(" Uplevel Ref Level = " << Level << "\n"); + if (Level == 0) { // Upreference should be resolved! + if (!TypeToResolve) { + TypeToResolve = UpRefs[i].UpRefTy; + } else { + UR_OUT(" * Resolving upreference for " + << UpRefs[i].second->getDescription() << "\n"; + std::string OldName = UpRefs[i].UpRefTy->getDescription()); + UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve); + UR_OUT(" * Type '" << OldName << "' refined upreference to: " + << (const void*)Ty << ", " << Ty->getDescription() << "\n"); + } + UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list... + --i; // Do not skip the next element... + } + } + } + + if (TypeToResolve) { + UR_OUT(" * Resolving upreference for " + << UpRefs[i].second->getDescription() << "\n"; + std::string OldName = TypeToResolve->getDescription()); + TypeToResolve->refineAbstractTypeTo(Ty); + } + + return Ty; +} + +//===----------------------------------------------------------------------===// +// RunVMAsmParser - Define an interface to this parser +//===----------------------------------------------------------------------===// +// +static Module* RunParser(Module * M); + +Module *llvm::RunVMAsmParser(llvm::MemoryBuffer *MB) { + InitLLLexer(MB); + Module *M = RunParser(new Module(LLLgetFilename())); + FreeLexer(); + return M; +} + + + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +/* Enabling the token table. */ +#ifndef YYTOKEN_TABLE +# define YYTOKEN_TABLE 0 +#endif + +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef union YYSTYPE +#line 974 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" +{ + llvm::Module *ModuleVal; + llvm::Function *FunctionVal; + llvm::BasicBlock *BasicBlockVal; + llvm::TerminatorInst *TermInstVal; + llvm::Instruction *InstVal; + llvm::Constant *ConstVal; + + const llvm::Type *PrimType; + std::list *TypeList; + llvm::PATypeHolder *TypeVal; + llvm::Value *ValueVal; + std::vector *ValueList; + std::vector *ConstantList; + llvm::ArgListType *ArgList; + llvm::TypeWithAttrs TypeWithAttrs; + llvm::TypeWithAttrsList *TypeWithAttrsList; + llvm::ParamList *ParamList; + + // Represent the RHS of PHI node + std::list > *PHIList; + std::vector > *JumpTable; + std::vector *ConstVector; + + llvm::GlobalValue::LinkageTypes Linkage; + llvm::GlobalValue::VisibilityTypes Visibility; + llvm::Attributes Attributes; + llvm::APInt *APIntVal; + int64_t SInt64Val; + uint64_t UInt64Val; + int SIntVal; + unsigned UIntVal; + llvm::APFloat *FPVal; + bool BoolVal; + + std::string *StrVal; // This memory must be deleted + llvm::ValID ValIDVal; + + llvm::Instruction::BinaryOps BinaryOpVal; + llvm::Instruction::TermOps TermOpVal; + llvm::Instruction::MemoryOps MemOpVal; + llvm::Instruction::CastOps CastOpVal; + llvm::Instruction::OtherOps OtherOpVal; + llvm::ICmpInst::Predicate IPredicate; + llvm::FCmpInst::Predicate FPredicate; +} +/* Line 187 of yacc.c. */ +#line 1428 "llvmAsmParser.tab.c" + YYSTYPE; +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 +#endif + + + +/* Copy the second part of user declarations. */ + + +/* Line 216 of yacc.c. */ +#line 1441 "llvmAsmParser.tab.c" + +#ifdef short +# undef short +#endif + +#ifdef YYTYPE_UINT8 +typedef YYTYPE_UINT8 yytype_uint8; +#else +typedef unsigned char yytype_uint8; +#endif + +#ifdef YYTYPE_INT8 +typedef YYTYPE_INT8 yytype_int8; +#elif (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +typedef signed char yytype_int8; +#else +typedef short int yytype_int8; +#endif + +#ifdef YYTYPE_UINT16 +typedef YYTYPE_UINT16 yytype_uint16; +#else +typedef unsigned short int yytype_uint16; +#endif + +#ifdef YYTYPE_INT16 +typedef YYTYPE_INT16 yytype_int16; +#else +typedef short int yytype_int16; +#endif + +#ifndef YYSIZE_T +# ifdef __SIZE_TYPE__ +# define YYSIZE_T __SIZE_TYPE__ +# elif defined size_t +# define YYSIZE_T size_t +# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# else +# define YYSIZE_T unsigned int +# endif +#endif + +#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) + +#ifndef YY_ +# if YYENABLE_NLS +# if ENABLE_NLS +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_(msgid) dgettext ("bison-runtime", msgid) +# endif +# endif +# ifndef YY_ +# define YY_(msgid) msgid +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YYUSE(e) ((void) (e)) +#else +# define YYUSE(e) /* empty */ +#endif + +/* Identity function, used to suppress warnings about constant conditions. */ +#ifndef lint +# define YYID(n) (n) +#else +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static int +YYID (int i) +#else +static int +YYID (i) + int i; +#endif +{ + return i; +} +#endif + +#if ! defined yyoverflow || YYERROR_VERBOSE + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# elif defined __BUILTIN_VA_ARG_INCR +# include /* INFRINGES ON USER NAME SPACE */ +# elif defined _AIX +# define YYSTACK_ALLOC __alloca +# elif defined _MSC_VER +# include /* INFRINGES ON USER NAME SPACE */ +# define alloca _alloca +# else +# define YYSTACK_ALLOC alloca +# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# include /* INFRINGES ON USER NAME SPACE */ +# ifndef _STDLIB_H +# define _STDLIB_H 1 +# endif +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +# endif +# else +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# ifndef YYSTACK_ALLOC_MAXIMUM +# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +# endif +# if (defined __cplusplus && ! defined _STDLIB_H \ + && ! ((defined YYMALLOC || defined malloc) \ + && (defined YYFREE || defined free))) +# include /* INFRINGES ON USER NAME SPACE */ +# ifndef _STDLIB_H +# define _STDLIB_H 1 +# endif +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif +#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ + + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yytype_int16 yyss; + YYSTYPE yyvs; + }; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (YYID (0)) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (YYID (0)) + +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 44 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 2439 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 173 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 89 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 354 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 717 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 413 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const yytype_uint8 yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 159, 160, 163, 2, 162, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 168, 161, 169, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 165, 164, 167, 2, 2, 2, 2, 2, 172, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 166, 2, 2, 170, 2, 171, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const yytype_uint16 yyprhs[] = +{ + 0, 0, 3, 5, 7, 9, 11, 13, 15, 17, + 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, + 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, + 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, + 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, + 99, 101, 103, 105, 107, 109, 111, 113, 115, 117, + 119, 121, 123, 125, 127, 129, 130, 135, 136, 139, + 140, 143, 145, 147, 149, 150, 153, 155, 157, 159, + 161, 163, 165, 167, 169, 171, 172, 174, 176, 178, + 179, 181, 183, 184, 186, 188, 190, 192, 193, 195, + 197, 198, 200, 202, 204, 206, 208, 211, 213, 215, + 217, 219, 221, 223, 225, 227, 229, 232, 233, 236, + 238, 240, 242, 243, 246, 248, 250, 252, 254, 256, + 258, 260, 262, 264, 266, 267, 270, 271, 274, 275, + 278, 279, 283, 286, 287, 289, 290, 294, 296, 299, + 301, 303, 305, 307, 309, 311, 313, 315, 317, 321, + 323, 326, 332, 338, 344, 350, 354, 357, 363, 368, + 371, 373, 375, 377, 381, 383, 387, 389, 390, 392, + 396, 401, 405, 409, 414, 419, 423, 430, 436, 439, + 442, 445, 448, 451, 454, 457, 460, 463, 466, 469, + 472, 479, 485, 494, 501, 508, 516, 524, 532, 540, + 547, 556, 565, 571, 579, 583, 585, 587, 589, 591, + 592, 595, 602, 604, 605, 607, 610, 611, 615, 616, + 620, 624, 628, 632, 633, 642, 643, 653, 654, 664, + 670, 673, 677, 679, 683, 687, 691, 695, 697, 698, + 704, 708, 710, 714, 716, 717, 729, 731, 733, 738, + 740, 742, 745, 749, 750, 752, 754, 756, 758, 760, + 762, 764, 766, 768, 770, 772, 776, 780, 783, 786, + 790, 793, 799, 804, 806, 812, 814, 816, 818, 820, + 822, 824, 827, 829, 833, 836, 839, 843, 847, 850, + 851, 853, 856, 859, 863, 873, 883, 892, 908, 910, + 912, 919, 925, 928, 931, 938, 946, 951, 956, 963, + 970, 971, 972, 976, 979, 983, 986, 988, 994, 1000, + 1007, 1014, 1021, 1028, 1033, 1040, 1045, 1050, 1057, 1064, + 1067, 1077, 1079, 1081, 1082, 1086, 1093, 1097, 1104, 1107, + 1113, 1121, 1127, 1132, 1137 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yytype_int16 yyrhs[] = +{ + 222, 0, -1, 75, -1, 76, -1, 77, -1, 78, + -1, 79, -1, 80, -1, 81, -1, 82, -1, 83, + -1, 87, -1, 88, -1, 89, -1, 84, -1, 85, + -1, 86, -1, 120, -1, 121, -1, 122, -1, 123, + -1, 124, -1, 125, -1, 126, -1, 127, -1, 128, + -1, 129, -1, 130, -1, 131, -1, 94, -1, 95, + -1, 96, -1, 97, -1, 98, -1, 99, -1, 100, + -1, 101, -1, 102, -1, 103, -1, 104, -1, 105, + -1, 106, -1, 107, -1, 108, -1, 109, -1, 110, + -1, 111, -1, 112, -1, 113, -1, 100, -1, 101, + -1, 102, -1, 103, -1, 26, -1, 27, -1, 11, + -1, 12, -1, 13, -1, 16, -1, 15, -1, 14, + -1, 19, -1, 22, -1, 24, -1, 181, -1, -1, + 55, 159, 4, 160, -1, -1, 181, 161, -1, -1, + 7, 161, -1, 20, -1, 23, -1, 188, -1, -1, + 186, 161, -1, 42, -1, 44, -1, 43, -1, 45, + -1, 47, -1, 49, -1, 46, -1, 48, -1, 51, + -1, -1, 156, -1, 157, -1, 158, -1, -1, 46, + -1, 48, -1, -1, 42, -1, 43, -1, 44, -1, + 47, -1, -1, 44, -1, 42, -1, -1, 63, -1, + 64, -1, 65, -1, 66, -1, 67, -1, 62, 4, + -1, 142, -1, 121, -1, 141, -1, 122, -1, 144, + -1, 145, -1, 147, -1, 148, -1, 149, -1, 54, + 4, -1, -1, 197, 196, -1, 144, -1, 142, -1, + 141, -1, -1, 199, 198, -1, 143, -1, 146, -1, + 144, -1, 142, -1, 141, -1, 150, -1, 151, -1, + 154, -1, 155, -1, 153, -1, -1, 201, 200, -1, + -1, 152, 22, -1, -1, 54, 4, -1, -1, 162, + 54, 4, -1, 34, 22, -1, -1, 205, -1, -1, + 162, 208, 207, -1, 205, -1, 54, 4, -1, 11, + -1, 12, -1, 13, -1, 16, -1, 15, -1, 14, + -1, 17, -1, 50, -1, 209, -1, 210, 183, 163, + -1, 244, -1, 164, 4, -1, 210, 159, 214, 160, + 201, -1, 10, 159, 214, 160, 201, -1, 165, 4, + 166, 210, 167, -1, 168, 4, 166, 210, 169, -1, + 170, 215, 171, -1, 170, 171, -1, 168, 170, 215, + 171, 169, -1, 168, 170, 171, 169, -1, 210, 197, + -1, 210, -1, 10, -1, 211, -1, 213, 162, 211, + -1, 213, -1, 213, 162, 39, -1, 39, -1, -1, + 210, -1, 215, 162, 210, -1, 210, 165, 218, 167, + -1, 210, 165, 167, -1, 210, 172, 22, -1, 210, + 168, 218, 169, -1, 210, 170, 218, 171, -1, 210, + 170, 171, -1, 210, 168, 170, 218, 171, 169, -1, + 210, 168, 170, 171, 169, -1, 210, 40, -1, 210, + 41, -1, 210, 244, -1, 210, 217, -1, 210, 25, + -1, 179, 3, -1, 179, 5, -1, 179, 4, -1, + 179, 6, -1, 11, 26, -1, 11, 27, -1, 180, + 9, -1, 176, 159, 216, 38, 210, 160, -1, 119, + 159, 216, 256, 160, -1, 133, 159, 216, 162, 216, + 162, 216, 160, -1, 174, 159, 216, 162, 216, 160, + -1, 175, 159, 216, 162, 216, 160, -1, 90, 177, + 159, 216, 162, 216, 160, -1, 91, 178, 159, 216, + 162, 216, 160, -1, 92, 177, 159, 216, 162, 216, + 160, -1, 93, 178, 159, 216, 162, 216, 160, -1, + 135, 159, 216, 162, 216, 160, -1, 136, 159, 216, + 162, 216, 162, 216, 160, -1, 137, 159, 216, 162, + 216, 162, 216, 160, -1, 139, 159, 216, 257, 160, + -1, 140, 159, 216, 162, 216, 257, 160, -1, 218, + 162, 216, -1, 216, -1, 32, -1, 33, -1, 37, + -1, -1, 212, 244, -1, 125, 159, 221, 38, 210, + 160, -1, 223, -1, -1, 224, -1, 223, 224, -1, + -1, 31, 225, 240, -1, -1, 30, 226, 241, -1, + 60, 59, 230, -1, 184, 18, 210, -1, 184, 18, + 10, -1, -1, 187, 191, 220, 219, 216, 183, 227, + 207, -1, -1, 187, 189, 191, 220, 219, 216, 183, + 228, 207, -1, -1, 187, 190, 191, 220, 219, 210, + 183, 229, 207, -1, 187, 191, 35, 194, 221, -1, + 52, 231, -1, 56, 161, 232, -1, 22, -1, 53, + 161, 22, -1, 68, 161, 22, -1, 165, 233, 167, + -1, 233, 162, 22, -1, 22, -1, -1, 234, 162, + 210, 197, 182, -1, 210, 197, 182, -1, 234, -1, + 234, 162, 39, -1, 39, -1, -1, 195, 199, 212, + 186, 159, 235, 160, 201, 206, 203, 202, -1, 28, + -1, 170, -1, 193, 191, 236, 237, -1, 29, -1, + 171, -1, 248, 239, -1, 192, 191, 236, -1, -1, + 61, -1, 3, -1, 4, -1, 5, -1, 6, -1, + 9, -1, 26, -1, 27, -1, 40, -1, 41, -1, + 25, -1, 168, 218, 169, -1, 165, 218, 167, -1, + 165, 167, -1, 172, 22, -1, 170, 218, 171, -1, + 170, 171, -1, 168, 170, 218, 171, 169, -1, 168, + 170, 171, 169, -1, 217, -1, 59, 242, 22, 162, + 22, -1, 7, -1, 8, -1, 181, -1, 186, -1, + 244, -1, 243, -1, 210, 245, -1, 246, -1, 247, + 162, 246, -1, 248, 249, -1, 238, 249, -1, 250, + 184, 251, -1, 250, 185, 251, -1, 250, 253, -1, + -1, 21, -1, 69, 247, -1, 69, 10, -1, 70, + 17, 245, -1, 70, 11, 245, 162, 17, 245, 162, + 17, 245, -1, 71, 179, 245, 162, 17, 245, 165, + 252, 167, -1, 71, 179, 245, 162, 17, 245, 165, + 167, -1, 72, 195, 199, 212, 245, 159, 255, 160, + 201, 38, 17, 245, 73, 17, 245, -1, 73, -1, + 74, -1, 252, 179, 243, 162, 17, 245, -1, 179, + 243, 162, 17, 245, -1, 184, 259, -1, 185, 259, + -1, 210, 165, 245, 162, 245, 167, -1, 254, 162, + 165, 245, 162, 245, 167, -1, 210, 197, 245, 197, + -1, 17, 197, 245, 197, -1, 255, 162, 210, 197, + 245, 197, -1, 255, 162, 17, 197, 245, 197, -1, + -1, -1, 256, 162, 246, -1, 162, 4, -1, 257, + 162, 4, -1, 58, 57, -1, 57, -1, 174, 210, + 245, 162, 245, -1, 175, 210, 245, 162, 245, -1, + 90, 177, 210, 245, 162, 245, -1, 91, 178, 210, + 245, 162, 245, -1, 92, 177, 210, 245, 162, 245, + -1, 93, 178, 210, 245, 162, 245, -1, 176, 246, + 38, 210, -1, 133, 246, 162, 246, 162, 246, -1, + 134, 246, 162, 210, -1, 135, 246, 162, 246, -1, + 136, 246, 162, 246, 162, 246, -1, 137, 246, 162, + 246, 162, 246, -1, 132, 254, -1, 258, 195, 199, + 212, 245, 159, 255, 160, 201, -1, 261, -1, 36, + -1, -1, 114, 210, 204, -1, 114, 210, 162, 11, + 245, 204, -1, 115, 210, 204, -1, 115, 210, 162, + 11, 245, 204, -1, 116, 246, -1, 260, 117, 210, + 245, 204, -1, 260, 118, 246, 162, 210, 245, 204, + -1, 138, 210, 245, 162, 4, -1, 119, 210, 245, + 256, -1, 139, 210, 245, 257, -1, 140, 210, 245, + 162, 210, 245, 257, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const yytype_uint16 yyrline[] = +{ + 0, 1140, 1140, 1140, 1140, 1140, 1140, 1140, 1140, 1140, + 1140, 1141, 1141, 1141, 1141, 1141, 1141, 1142, 1142, 1142, + 1142, 1142, 1142, 1143, 1143, 1143, 1143, 1143, 1143, 1146, + 1146, 1147, 1147, 1148, 1148, 1149, 1149, 1150, 1150, 1154, + 1154, 1155, 1155, 1156, 1156, 1157, 1157, 1158, 1158, 1159, + 1159, 1160, 1160, 1161, 1162, 1167, 1168, 1168, 1168, 1168, + 1168, 1170, 1170, 1170, 1171, 1171, 1173, 1174, 1178, 1182, + 1187, 1193, 1193, 1195, 1196, 1201, 1207, 1208, 1209, 1210, + 1211, 1212, 1216, 1217, 1218, 1222, 1223, 1224, 1225, 1229, + 1230, 1231, 1235, 1236, 1237, 1238, 1239, 1243, 1244, 1245, + 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1261, 1262, 1263, + 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1274, 1275, 1280, + 1281, 1282, 1285, 1286, 1292, 1293, 1294, 1295, 1296, 1297, + 1298, 1299, 1300, 1301, 1304, 1305, 1311, 1312, 1319, 1320, + 1326, 1327, 1336, 1344, 1345, 1350, 1351, 1352, 1357, 1370, + 1370, 1370, 1370, 1370, 1370, 1370, 1373, 1377, 1381, 1388, + 1393, 1401, 1436, 1467, 1472, 1482, 1492, 1496, 1506, 1513, + 1522, 1529, 1534, 1539, 1546, 1547, 1554, 1561, 1569, 1575, + 1587, 1615, 1631, 1658, 1686, 1712, 1732, 1758, 1778, 1790, + 1797, 1863, 1873, 1883, 1889, 1899, 1905, 1915, 1921, 1927, + 1940, 1952, 1973, 1981, 1987, 1998, 2003, 2008, 2013, 2018, + 2024, 2030, 2036, 2044, 2055, 2059, 2067, 2067, 2070, 2070, + 2073, 2085, 2106, 2111, 2119, 2120, 2124, 2124, 2128, 2128, + 2131, 2134, 2158, 2170, 2169, 2181, 2180, 2190, 2189, 2200, + 2240, 2243, 2249, 2259, 2263, 2268, 2270, 2275, 2280, 2289, + 2299, 2310, 2314, 2323, 2332, 2337, 2486, 2486, 2488, 2497, + 2497, 2499, 2504, 2516, 2520, 2525, 2529, 2533, 2538, 2543, + 2547, 2551, 2555, 2559, 2563, 2567, 2589, 2611, 2617, 2630, + 2642, 2647, 2659, 2665, 2669, 2679, 2683, 2687, 2692, 2699, + 2699, 2705, 2714, 2719, 2724, 2728, 2737, 2746, 2759, 2768, + 2772, 2780, 2800, 2804, 2809, 2820, 2839, 2848, 2952, 2956, + 2963, 2974, 2987, 2996, 3009, 3020, 3030, 3041, 3049, 3059, + 3066, 3069, 3070, 3078, 3084, 3093, 3097, 3102, 3118, 3135, + 3147, 3159, 3173, 3187, 3199, 3220, 3227, 3233, 3239, 3245, + 3260, 3370, 3375, 3379, 3386, 3393, 3403, 3410, 3420, 3428, + 3442, 3459, 3473, 3488, 3503 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "ESAPINTVAL", + "EUAPINTVAL", "LOCALVAL_ID", "GLOBALVAL_ID", "FPVAL", "VOID", "INTTYPE", + "FLOAT", "DOUBLE", "X86_FP80", "FP128", "PPC_FP128", "LABEL", "TYPE", + "LOCALVAR", "GLOBALVAR", "LABELSTR", "STRINGCONSTANT", + "ATSTRINGCONSTANT", "PCTSTRINGCONSTANT", "ZEROINITIALIZER", "TRUETOK", + "FALSETOK", "BEGINTOK", "ENDTOK", "DECLARE", "DEFINE", "GLOBAL", + "CONSTANT", "SECTION", "ALIAS", "VOLATILE", "THREAD_LOCAL", "TO", + "DOTDOTDOT", "NULL_TOK", "UNDEF", "INTERNAL", "LINKONCE", "WEAK", + "APPENDING", "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "COMMON", "OPAQUE", + "EXTERNAL", "TARGET", "TRIPLE", "ALIGN", "ADDRSPACE", "DEPLIBS", "CALL", + "TAIL", "ASM_TOK", "MODULE", "SIDEEFFECT", "CC_TOK", "CCC_TOK", + "FASTCC_TOK", "COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK", + "DATALAYOUT", "RET", "BR", "SWITCH", "INVOKE", "UNWIND", "UNREACHABLE", + "ADD", "SUB", "MUL", "UDIV", "SDIV", "FDIV", "UREM", "SREM", "FREM", + "AND", "OR", "XOR", "SHL", "LSHR", "ASHR", "ICMP", "FCMP", "VICMP", + "VFCMP", "EQ", "NE", "SLT", "SGT", "SLE", "SGE", "ULT", "UGT", "ULE", + "UGE", "OEQ", "ONE", "OLT", "OGT", "OLE", "OGE", "ORD", "UNO", "UEQ", + "UNE", "MALLOC", "ALLOCA", "FREE", "LOAD", "STORE", "GETELEMENTPTR", + "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT", "BITCAST", "UITOFP", + "SITOFP", "FPTOUI", "FPTOSI", "INTTOPTR", "PTRTOINT", "PHI_TOK", + "SELECT", "VAARG", "EXTRACTELEMENT", "INSERTELEMENT", "SHUFFLEVECTOR", + "GETRESULT", "EXTRACTVALUE", "INSERTVALUE", "SIGNEXT", "ZEROEXT", + "NORETURN", "INREG", "SRET", "NOUNWIND", "NOALIAS", "BYVAL", "NEST", + "READNONE", "READONLY", "GC", "OPTSIZE", "NOINLINE", "ALWAYSINLINE", + "DEFAULT", "HIDDEN", "PROTECTED", "'('", "')'", "'='", "','", "'*'", + "'\\\\'", "'['", "'x'", "']'", "'<'", "'>'", "'{'", "'}'", "'c'", + "$accept", "ArithmeticOps", "LogicalOps", "CastOps", "IPredicates", + "FPredicates", "IntType", "FPType", "LocalName", "OptLocalName", + "OptAddrSpace", "OptLocalAssign", "LocalNumber", "GlobalName", + "OptGlobalAssign", "GlobalAssign", "GVInternalLinkage", + "GVExternalLinkage", "GVVisibilityStyle", "FunctionDeclareLinkage", + "FunctionDefineLinkage", "AliasLinkage", "OptCallingConv", "Attribute", + "OptAttributes", "RetAttr", "OptRetAttrs", "FuncAttr", "OptFuncAttrs", + "OptGC", "OptAlign", "OptCAlign", "SectionString", "OptSection", + "GlobalVarAttributes", "GlobalVarAttribute", "PrimType", "Types", + "ArgType", "ResultTypes", "ArgTypeList", "ArgTypeListI", "TypeListI", + "ConstVal", "ConstExpr", "ConstVector", "GlobalType", "ThreadLocal", + "AliaseeRef", "Module", "DefinitionList", "Definition", "@1", "@2", "@3", + "@4", "@5", "AsmBlock", "TargetDefinition", "LibrariesDefinition", + "LibList", "ArgListH", "ArgList", "FunctionHeaderH", "BEGIN", + "FunctionHeader", "END", "Function", "FunctionProto", "OptSideEffect", + "ConstValueRef", "SymbolicValueRef", "ValueRef", "ResolvedVal", + "ReturnedVal", "BasicBlockList", "BasicBlock", "InstructionList", + "BBTerminatorInst", "JumpTable", "Inst", "PHIList", "ParamList", + "IndexList", "ConstantIndexList", "OptTailCall", "InstVal", + "OptVolatile", "MemoryInst", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const yytype_uint16 yytoknum[] = +{ + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, + 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, + 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 40, + 41, 61, 44, 42, 92, 91, 120, 93, 60, 62, + 123, 125, 99 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const yytype_uint16 yyr1[] = +{ + 0, 173, 174, 174, 174, 174, 174, 174, 174, 174, + 174, 175, 175, 175, 175, 175, 175, 176, 176, 176, + 176, 176, 176, 176, 176, 176, 176, 176, 176, 177, + 177, 177, 177, 177, 177, 177, 177, 177, 177, 178, + 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, + 178, 178, 178, 178, 178, 179, 180, 180, 180, 180, + 180, 181, 181, 181, 182, 182, 183, 183, 184, 184, + 185, 186, 186, 187, 187, 188, 189, 189, 189, 189, + 189, 189, 190, 190, 190, 191, 191, 191, 191, 192, + 192, 192, 193, 193, 193, 193, 193, 194, 194, 194, + 195, 195, 195, 195, 195, 195, 195, 196, 196, 196, + 196, 196, 196, 196, 196, 196, 196, 197, 197, 198, + 198, 198, 199, 199, 200, 200, 200, 200, 200, 200, + 200, 200, 200, 200, 201, 201, 202, 202, 203, 203, + 204, 204, 205, 206, 206, 207, 207, 208, 208, 209, + 209, 209, 209, 209, 209, 209, 210, 210, 210, 210, + 210, 210, 210, 210, 210, 210, 210, 210, 210, 211, + 212, 212, 213, 213, 214, 214, 214, 214, 215, 215, + 216, 216, 216, 216, 216, 216, 216, 216, 216, 216, + 216, 216, 216, 216, 216, 216, 216, 216, 216, 216, + 217, 217, 217, 217, 217, 217, 217, 217, 217, 217, + 217, 217, 217, 217, 218, 218, 219, 219, 220, 220, + 221, 221, 222, 222, 223, 223, 225, 224, 226, 224, + 224, 224, 224, 227, 224, 228, 224, 229, 224, 224, + 224, 224, 230, 231, 231, 232, 233, 233, 233, 234, + 234, 235, 235, 235, 235, 236, 237, 237, 238, 239, + 239, 240, 241, 242, 242, 243, 243, 243, 243, 243, + 243, 243, 243, 243, 243, 243, 243, 243, 243, 243, + 243, 243, 243, 243, 243, 244, 244, 244, 244, 245, + 245, 246, 247, 247, 248, 248, 249, 249, 250, 250, + 250, 251, 251, 251, 251, 251, 251, 251, 251, 251, + 252, 252, 253, 253, 254, 254, 255, 255, 255, 255, + 255, 256, 256, 257, 257, 258, 258, 259, 259, 259, + 259, 259, 259, 259, 259, 259, 259, 259, 259, 259, + 259, 259, 260, 260, 261, 261, 261, 261, 261, 261, + 261, 261, 261, 261, 261 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const yytype_uint8 yyr2[] = +{ + 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 0, 4, 0, 2, 0, + 2, 1, 1, 1, 0, 2, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, + 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, + 0, 1, 1, 1, 1, 1, 2, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 2, 0, 2, 1, + 1, 1, 0, 2, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 0, 2, 0, 2, 0, 2, + 0, 3, 2, 0, 1, 0, 3, 1, 2, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, + 2, 5, 5, 5, 5, 3, 2, 5, 4, 2, + 1, 1, 1, 3, 1, 3, 1, 0, 1, 3, + 4, 3, 3, 4, 4, 3, 6, 5, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 6, 5, 8, 6, 6, 7, 7, 7, 7, 6, + 8, 8, 5, 7, 3, 1, 1, 1, 1, 0, + 2, 6, 1, 0, 1, 2, 0, 3, 0, 3, + 3, 3, 3, 0, 8, 0, 9, 0, 9, 5, + 2, 3, 1, 3, 3, 3, 3, 1, 0, 5, + 3, 1, 3, 1, 0, 11, 1, 1, 4, 1, + 1, 2, 3, 0, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 3, 3, 2, 2, 3, + 2, 5, 4, 1, 5, 1, 1, 1, 1, 1, + 1, 2, 1, 3, 2, 2, 3, 3, 2, 0, + 1, 2, 2, 3, 9, 9, 8, 15, 1, 1, + 6, 5, 2, 2, 6, 7, 4, 4, 6, 6, + 0, 0, 3, 2, 3, 2, 1, 5, 5, 6, + 6, 6, 6, 4, 6, 4, 4, 6, 6, 2, + 9, 1, 1, 0, 3, 6, 3, 6, 2, 5, + 7, 5, 4, 4, 7 +}; + +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const yytype_uint16 yydefact[] = +{ + 74, 61, 71, 62, 72, 63, 228, 226, 0, 0, + 0, 0, 0, 0, 85, 73, 0, 74, 224, 89, + 92, 0, 0, 240, 0, 0, 68, 0, 75, 76, + 78, 77, 79, 82, 80, 83, 81, 84, 86, 87, + 88, 85, 85, 219, 1, 225, 90, 91, 85, 229, + 93, 94, 95, 96, 85, 299, 227, 299, 0, 0, + 248, 241, 242, 230, 285, 286, 232, 149, 150, 151, + 154, 153, 152, 155, 156, 0, 0, 0, 0, 287, + 288, 157, 231, 159, 219, 219, 97, 218, 0, 100, + 100, 300, 295, 69, 259, 260, 261, 294, 243, 244, + 247, 0, 177, 160, 0, 0, 0, 0, 166, 178, + 0, 0, 177, 0, 0, 0, 99, 98, 0, 216, + 217, 0, 0, 101, 102, 103, 104, 105, 122, 262, + 0, 0, 343, 343, 298, 0, 245, 176, 117, 172, + 174, 0, 0, 0, 0, 0, 0, 165, 0, 0, + 158, 0, 0, 171, 0, 170, 0, 239, 149, 150, + 151, 154, 153, 152, 0, 0, 67, 67, 106, 0, + 256, 257, 258, 70, 342, 326, 0, 0, 0, 0, + 100, 308, 309, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 14, 15, 16, 11, 12, 13, 0, 0, + 0, 0, 0, 0, 0, 0, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 296, 100, 312, 0, 341, 297, 313, 246, 169, 0, + 134, 67, 67, 168, 0, 179, 0, 134, 67, 67, + 0, 220, 197, 198, 193, 195, 194, 196, 199, 192, + 188, 189, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 191, 190, 233, 121, 120, 119, 123, 0, 325, 302, + 67, 292, 301, 0, 0, 55, 0, 122, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 0, 53, + 54, 49, 50, 51, 52, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 0, 0, 0, 140, 140, + 348, 67, 67, 339, 0, 0, 0, 0, 0, 67, + 67, 67, 67, 67, 0, 122, 0, 0, 0, 108, + 110, 109, 107, 111, 112, 113, 114, 115, 118, 175, + 173, 162, 163, 164, 167, 66, 161, 235, 237, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 181, 215, 0, 0, 0, 185, 0, 182, 0, + 0, 0, 145, 0, 265, 266, 267, 268, 269, 274, + 270, 271, 272, 273, 263, 0, 0, 0, 0, 283, + 290, 289, 291, 0, 0, 303, 0, 0, 67, 67, + 67, 67, 0, 344, 0, 346, 321, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 67, 0, 116, 128, 127, 124, 126, 125, 129, + 130, 133, 131, 132, 135, 145, 145, 0, 0, 0, + 0, 0, 321, 0, 0, 0, 0, 0, 0, 0, + 180, 166, 178, 0, 183, 184, 0, 0, 0, 0, + 234, 254, 264, 0, 277, 0, 0, 0, 280, 0, + 278, 293, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 352, 0, 0, 0, 335, 336, 0, 0, + 0, 0, 353, 0, 0, 0, 333, 0, 140, 0, + 236, 238, 67, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 214, 187, 0, 0, 0, 0, + 0, 0, 147, 145, 253, 117, 251, 0, 0, 276, + 166, 0, 275, 279, 0, 0, 0, 0, 0, 0, + 0, 140, 141, 140, 0, 0, 0, 0, 0, 0, + 351, 323, 0, 67, 327, 328, 0, 0, 349, 67, + 221, 0, 0, 0, 0, 201, 0, 0, 0, 0, + 212, 0, 186, 0, 0, 67, 142, 148, 146, 65, + 0, 134, 0, 282, 0, 0, 0, 320, 329, 330, + 331, 332, 345, 347, 322, 0, 0, 334, 337, 338, + 324, 0, 320, 140, 0, 0, 0, 0, 0, 209, + 0, 0, 0, 203, 204, 200, 64, 250, 252, 117, + 143, 284, 281, 0, 0, 117, 117, 0, 314, 0, + 354, 0, 350, 205, 206, 207, 208, 0, 0, 0, + 213, 65, 144, 138, 0, 306, 0, 0, 0, 0, + 134, 0, 315, 134, 202, 210, 211, 249, 0, 136, + 304, 0, 305, 0, 108, 110, 117, 117, 0, 117, + 117, 340, 139, 0, 255, 0, 0, 317, 316, 0, + 0, 0, 137, 0, 0, 0, 117, 117, 311, 0, + 0, 319, 318, 310, 0, 0, 307 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yytype_int16 yydefgoto[] = +{ + -1, 277, 278, 279, 308, 325, 164, 165, 79, 637, + 113, 12, 133, 80, 14, 15, 41, 42, 43, 48, + 54, 118, 128, 358, 238, 286, 169, 454, 361, 694, + 679, 423, 542, 663, 480, 543, 81, 166, 139, 156, + 140, 141, 110, 382, 409, 383, 121, 88, 157, 16, + 17, 18, 20, 19, 392, 455, 456, 63, 23, 61, + 101, 546, 547, 129, 172, 55, 96, 56, 49, 483, + 410, 83, 412, 291, 292, 57, 92, 93, 230, 667, + 134, 333, 647, 502, 512, 231, 232, 233, 234 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -620 +static const yytype_int16 yypact[] = +{ + 484, -620, -620, -620, -620, -620, -620, -620, -14, -116, + -6, -83, 104, -31, 24, -620, 161, 528, -620, 238, + 204, 43, 49, -620, 5, 196, -620, 1912, -620, -620, + -620, -620, -620, -620, -620, -620, -620, -620, -620, -620, + -620, 173, 173, 227, -620, -620, -620, -620, 173, -620, + -620, -620, -620, -620, 173, 202, -620, -9, 234, 243, + 246, -620, -620, -620, -620, -620, 67, -620, -620, -620, + -620, -620, -620, -620, -620, 273, 285, 3, 624, -620, + -620, -620, 4, -620, 201, 201, 253, -620, 81, 240, + 240, -620, -620, 39, -620, -620, -620, -620, -620, -620, + -620, -59, 1564, -620, 128, 132, 643, 67, -620, 4, + -114, 165, 1564, 145, 81, 81, -620, -620, 1605, -620, + -620, 2014, 324, -620, -620, -620, -620, -620, -620, -620, + -13, 188, 2299, 2299, -620, 328, -620, -620, 4, -620, + 189, 194, 2076, 2076, 186, -111, 2076, -620, 352, 205, + -620, 2014, 2076, 67, 208, 4, 247, -620, 216, 351, + 355, 359, 365, 368, 269, 372, 1625, 306, -620, 1517, + -620, -620, -620, -620, -620, -620, 325, 2094, 38, 373, + 240, -620, -620, -620, -620, -620, -620, -620, -620, -620, + -620, -620, -620, -620, -620, -620, -620, -620, 298, 336, + 298, 336, 2076, 2076, 2076, 2076, -620, -620, -620, -620, + -620, -620, -620, -620, -620, -620, -620, -620, 2076, 2076, + 2076, 2076, 2076, 2076, 2076, 2076, 2076, 2076, 2076, 2076, + -620, 240, -620, 66, -620, -620, -620, -620, 231, 1791, + -620, -17, -21, -620, 214, 4, 225, -620, 306, -5, + 1605, -620, -620, -620, -620, -620, -620, -620, -620, -620, + -620, -620, 298, 336, 298, 336, 229, 230, 249, 250, + 251, 252, 256, 1809, 2117, 690, 364, 257, 259, 261, + -620, -620, -620, -620, -620, -620, -620, 114, -620, 67, + 1019, -620, 262, 1189, 1189, -620, 1189, -620, -620, -620, + -620, -620, -620, -620, -620, -620, -620, -620, 2076, -620, + -620, -620, -620, -620, -620, -620, -620, -620, -620, -620, + -620, -620, -620, -620, -620, 2076, 2076, 2076, -23, 28, + -620, 1019, -18, 265, 266, 268, 272, 288, 289, 1019, + 1019, 1019, 1019, 1019, 383, -620, 2076, 2076, 398, -620, + -620, -620, -620, -620, -620, -620, -620, -620, -620, -620, + -620, 137, -620, -620, -620, -620, 137, -620, 145, 385, + 293, 294, 295, 297, 2014, 2014, 2014, 2014, 2014, 2014, + 2014, -620, -620, -56, 1069, -74, -620, -80, -620, 2014, + 2014, 2014, 296, 300, -620, -620, -620, -620, -620, -620, + -620, -620, -620, -620, 396, 1832, 2135, 1239, 403, -620, + -620, -620, -620, 2076, 299, -620, 301, 1517, 1019, 1019, + 1019, 1019, 8, -620, 33, -620, -620, 1189, 303, 2076, + 2076, 2076, 2076, 2076, 302, 304, 307, 308, 309, 2076, + 1517, 1019, 312, -620, -620, -620, -620, -620, -620, -620, + -620, -620, -620, -620, -620, 296, 296, 2076, 2014, 2014, + 2014, 2014, -620, 317, 318, 319, 320, 304, 323, 2014, + -620, 326, 1471, -77, -620, -620, 327, 330, 424, 2, + -620, 1850, -620, 443, -620, -52, 1280, -73, -620, -72, + -620, -620, 469, 471, 1189, 332, 334, 337, 338, 1189, + 494, 1189, 339, 343, 1189, 347, 4, -620, 348, 349, + 508, 519, 362, 2076, 1189, 1189, 4, 1189, 363, 2076, + -620, -620, 26, 367, 375, 377, 387, 149, 2014, 2014, + 2014, 2014, 157, 2014, -620, -620, 357, 2014, 2014, 2076, + 505, 526, -620, 296, -620, 4, 391, 394, 393, -620, + 366, -62, -620, -620, 1189, 1189, 386, 1189, 1189, 1189, + 1189, 363, -620, 363, 2076, 1189, 395, 2076, 2076, 2076, + -620, -620, 552, 1019, -620, -620, 405, 511, -620, 1019, + -620, 2014, 2014, 2014, 2014, -620, 400, 406, 407, 408, + -620, 304, -620, 411, 412, 57, -620, -620, -620, 11, + 1891, -620, 545, -620, 399, 413, 414, 2179, -620, -620, + -620, -620, -620, -620, -620, 409, 1189, -620, -620, -620, + -620, 304, 2179, 363, 417, 418, 423, 425, 2014, -620, + 2014, 2014, 180, -620, -620, -620, -620, -620, -620, 4, + 172, -620, -620, 556, -3, 46, 4, 181, -620, 422, + 362, 184, -620, -620, -620, -620, -620, 430, 431, 432, + -620, 11, -620, 539, 1189, -620, 1337, -1, 865, 865, + -620, 2197, -620, -620, -620, -620, -620, -620, 590, 445, + -620, 433, -620, 1337, 446, 453, -620, -620, 86, 46, + 4, 137, -620, 582, -620, 596, 452, 231, 231, 598, + 865, 865, -620, 1189, 599, 1189, -620, -620, -620, 1189, + 544, 231, 231, -620, 603, 1189, -620 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yytype_int16 yypgoto[] = +{ + -620, 42, 112, 200, -160, -158, -177, -620, 0, -39, + -151, 531, -620, 9, -620, -620, -620, -620, 77, -620, + -620, -620, -152, -620, -518, -620, -268, -620, -244, -620, + -620, -311, -15, -620, -414, -620, -620, -26, 389, -164, + -620, 514, 523, 142, -162, -261, 220, 263, 380, -620, + -620, 625, -620, -620, -620, -620, -620, -620, -620, -620, + -620, -620, -620, 559, -620, -620, -620, -620, -620, -620, + -619, -82, 267, -198, -620, -620, 595, -620, 535, -620, + -620, -620, 47, 215, -456, -620, 543, -620, -620 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -224 +static const yytype_int16 yytable[] = +{ + 11, 82, 296, 366, 280, 287, 330, 105, 295, 13, + 295, 532, 91, 385, 387, 170, 282, 11, 425, 499, + 94, 334, 335, 336, 337, 338, 13, 599, 297, 417, + 1, 344, 111, 3, 111, 5, 540, 111, 111, 21, + 326, 520, 521, 327, 501, 24, 131, 681, 146, 293, + 111, 146, 109, 25, 22, 294, 541, 147, 1, 111, + 244, 3, 500, 5, 696, 348, 29, 30, 31, 32, + 33, 34, 35, 36, 251, 37, 138, 440, 26, 345, + 109, 111, 469, 111, 281, 469, 138, 500, 469, 469, + 469, 475, 155, 11, 536, 474, 552, 367, 368, 553, + 469, -155, 370, 135, 372, 371, 469, 373, 136, 604, + 469, 470, 111, 119, 120, 549, 241, 242, 84, 85, + 245, 661, 27, 473, 699, 89, 249, 668, 669, 598, + 28, 90, 349, 350, 2, 632, 112, 4, 112, 422, + -67, 112, 112, 155, 485, 487, 489, 427, 363, 442, + 362, 290, 351, 352, 112, 353, 354, 171, 355, 356, + 357, 44, 95, 112, 665, 650, 682, -67, 697, 698, + 60, 700, 701, 106, 227, 227, 328, 329, 290, 331, + 38, 39, 40, 346, 347, 112, 580, 112, 711, 712, + 424, -67, 332, 290, 290, 290, 290, 290, 339, 340, + 341, 342, 343, 290, 58, -155, 540, 578, 411, -155, + 59, 411, 411, 138, 411, 491, 112, 635, 62, -55, + -55, -55, -55, 91, 155, 551, 102, 444, 445, 446, + 447, 505, 448, 507, 508, 509, 449, 450, 87, 451, + 452, 453, 252, 253, 228, 228, 50, 51, 52, 411, + 612, 53, 613, 494, 64, 65, 98, 411, 411, 411, + 411, 411, 86, 167, 87, 99, 1, 2, 100, 3, + 4, 5, 254, 255, 256, 257, 517, 103, 444, 445, + 446, 447, 418, 448, 46, 348, 47, 449, 450, 104, + 451, 452, 453, 248, 142, 116, 393, 117, 143, 419, + 420, 421, 122, 123, 124, 125, 126, 127, 150, 585, + 280, 564, 652, 444, 445, 446, 447, 590, 448, 572, + 441, 290, 449, 450, 148, 451, 452, 453, 168, 38, + 39, 40, 229, 229, 151, 152, 411, 411, 411, 411, + 660, 670, 572, 671, 673, 411, 671, 114, 115, 173, + 237, 239, 349, 350, 240, 243, 246, 640, 472, 411, + -56, 111, 309, 310, -57, 247, 614, 250, -60, 617, + 618, 619, 351, 352, -59, 353, 354, -58, 355, 356, + 357, 258, 288, 364, 295, 365, 388, 290, 374, 375, + 281, 155, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 443, 290, 506, 290, 290, 290, 376, 377, + 378, 379, 411, 516, 155, 380, 389, 411, 390, 411, + 391, 439, 411, 457, 413, 490, 688, 428, 429, 691, + 430, 522, 411, 411, 431, 411, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 432, 433, 458, 459, 460, 545, 461, 482, 479, 481, + 472, 492, 539, 493, 510, 548, 511, 666, 504, 513, + 514, 515, 411, 411, 519, 411, 411, 411, 411, 528, + 529, 530, 531, 411, -223, 533, 554, 573, 555, 537, + 683, 411, 538, 579, 557, 535, 558, 411, 562, 559, + 560, 564, -69, 1, 2, 565, 3, 4, 5, 567, + 568, 569, 570, 595, 6, 7, 462, 463, 464, 465, + 466, 467, 468, 571, 572, 577, 592, 596, -222, 581, + 597, 476, 477, 478, 411, 603, 8, 582, 290, 583, + 9, 290, 290, 290, 10, 607, -69, 1, 2, 584, + 3, 4, 5, 600, 601, 602, 620, 616, 6, 7, + 414, 415, 628, 416, 622, 500, 629, 641, 642, 630, + 631, 633, 634, 664, 639, 643, 648, 653, 654, 644, + 8, 646, 411, 655, 9, 656, 411, 411, 10, 672, + 674, 675, 676, 678, 692, 695, 646, 693, 426, 636, + 523, 524, 525, 526, 702, -18, 434, 435, 436, 437, + 438, 534, -19, 703, 704, 705, 709, 714, 411, 411, + 715, 411, 677, 411, 132, 662, 149, 411, 360, 145, + 369, 64, 65, 411, 107, 67, 68, 69, 70, 71, + 72, 73, 45, 1, 2, 690, 3, 4, 5, 130, + 64, 65, 97, 107, 67, 68, 69, 70, 71, 72, + 73, 636, 1, 2, 0, 3, 4, 5, 235, 651, + 586, 587, 588, 589, 74, 591, 236, 527, 0, 593, + 594, 0, 0, 0, 0, 495, 496, 497, 498, 0, + 0, 0, 0, 74, 503, 0, 0, 64, 65, 0, + 107, 158, 159, 160, 161, 162, 163, 73, 518, 1, + 2, 0, 3, 4, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 624, 625, 626, 627, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 74, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 556, 0, 0, 0, 0, 561, 0, 563, 0, + 657, 566, 658, 659, 0, 0, 0, 0, 0, 0, + 0, 574, 575, 0, 576, 0, 0, 0, 75, 76, + 0, 0, 77, 0, 78, 108, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 75, 76, 0, + 0, 77, 0, 78, 144, 0, 0, 0, 0, 0, + 0, 605, 606, 0, 608, 609, 610, 611, 0, 0, + 0, 0, 615, 0, 0, 0, 0, 0, 0, 0, + 621, 0, 0, 0, 0, 0, 623, 0, 0, 0, + 0, 0, 0, 0, 75, 76, 0, 0, 77, 0, + 78, 386, 0, 0, 0, 0, 0, 0, 394, 395, + 396, 397, 64, 65, 398, 0, 0, 0, 0, 0, + 0, 0, 0, 649, 1, 2, 0, 3, 4, 5, + 399, 400, 401, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 402, 403, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 348, + 0, 0, 0, 0, 404, 0, 0, 0, 0, 0, + 0, 680, 0, 0, 0, 686, 687, 0, 0, 0, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 262, 263, 264, 265, 0, + 0, 0, 0, 0, 0, 0, 0, 706, 707, 0, + 708, 0, 710, 0, 0, 0, 713, 0, 0, 0, + 0, 0, 716, 0, 266, 206, 684, 685, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 0, 267, 0, + 268, 269, 270, 0, 271, 272, 351, 352, 0, 353, + 354, 0, 355, 356, 357, 0, 0, 0, 0, 0, + 0, 0, 394, 395, 396, 397, 64, 65, 398, 0, + 405, 0, 0, 406, 0, 407, 0, 408, 1, 2, + 0, 3, 4, 5, 399, 400, 401, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 402, + 403, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 111, 0, 64, 65, 404, 107, + 158, 159, 160, 161, 162, 163, 73, 0, 1, 2, + 0, 3, 4, 5, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 262, + 263, 264, 265, 0, 0, 0, 0, 0, 0, 74, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 266, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 0, 267, 0, 268, 269, 270, 0, 271, 272, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 112, 0, + 0, 0, 0, 0, 405, 0, 0, 406, 0, 407, + 0, 408, 394, 395, 396, 397, 64, 65, 398, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, + 0, 3, 4, 5, 399, 400, 401, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 402, + 403, 0, 0, 75, 76, 0, 0, 77, 0, 78, + 471, 0, 0, 0, 0, 0, 64, 65, 404, 107, + 158, 159, 160, 161, 162, 163, 73, 0, 1, 2, + 0, 3, 4, 5, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 262, + 263, 264, 265, 0, 0, 0, 0, 64, 65, 74, + 107, 158, 159, 160, 161, 162, 163, 73, 0, 1, + 2, 0, 3, 4, 5, 0, 0, 0, 266, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 0, 267, 0, 268, 269, 270, 0, 271, 272, + 74, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 394, 395, 396, 397, 0, 0, 398, 0, 0, 0, + 0, 0, 0, 0, 405, 0, 0, 406, 0, 407, + 0, 408, 399, 400, 401, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 402, 403, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 404, 0, 0, 0, + 0, 0, 0, 75, 76, 0, 0, 77, 0, 78, + 488, 0, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 262, 263, 264, + 265, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 75, 76, 0, 0, 77, 0, + 78, 550, 0, 0, 0, 0, 266, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 0, + 267, 0, 268, 269, 270, 0, 271, 272, 64, 65, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 0, 3, 4, 5, 259, 0, 0, 0, + 0, 0, 405, 0, 0, 406, 0, 407, 0, 408, + 0, 260, 261, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 64, 65, 111, 153, 67, 68, + 69, 70, 71, 72, 73, 0, 1, 2, 0, 3, + 4, 5, 0, 0, 0, 0, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, 262, 263, 264, 265, 0, 0, 74, 0, 0, + 0, 64, 65, 0, 107, 67, 68, 69, 70, 71, + 72, 73, 0, 1, 2, 0, 3, 4, 5, 0, + 266, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 137, 267, 0, 268, 269, 270, 0, + 271, 272, 64, 65, 74, 153, 67, 68, 69, 70, + 71, 72, 73, 0, 1, 2, 0, 3, 4, 5, + 112, 0, 64, 65, -67, 0, 273, 0, 0, 274, + 0, 275, 0, 276, 1, 2, 0, 3, 4, 5, + 259, 0, 0, 0, 0, 74, 0, 0, 283, 284, + 0, 285, 0, 0, 0, 260, 261, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 111, 75, 76, 0, 0, 77, 0, 78, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 262, 263, 264, 265, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 75, 76, + 154, 0, 77, 0, 78, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 266, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 0, 267, 0, + 268, 269, 270, 0, 271, 272, 0, 0, 0, 75, + 76, 0, 0, 77, 0, 78, 0, 0, 0, 0, + 0, 0, 0, 0, 112, 0, 0, 0, 0, 0, + 273, 0, 0, 274, 0, 275, 0, 276, 64, 65, + 0, 107, 67, 68, 69, 70, 71, 72, 73, 0, + 1, 2, 0, 3, 4, 5, 64, 65, 0, 107, + 158, 159, 160, 161, 162, 163, 73, 0, 1, 2, + 359, 3, 4, 5, 0, 0, 0, 0, 0, 64, + 65, 74, 107, 158, 159, 160, 161, 162, 163, 73, + 0, 1, 2, 0, 3, 4, 5, 64, 65, 74, + 107, 67, 68, 69, 70, 71, 72, 73, 0, 1, + 2, 0, 3, 4, 5, 0, 0, 0, 0, 0, + 0, 0, 74, 0, 0, 0, 0, 0, 0, 544, + 0, 0, 0, 0, 0, 0, 0, 0, 64, 65, + 74, 107, 67, 68, 69, 70, 71, 72, 73, 0, + 1, 2, 0, 3, 4, 5, 0, 0, 0, 64, + 65, 0, 66, 67, 68, 69, 70, 71, 72, 73, + 638, 1, 2, 0, 3, 4, 5, 0, 0, 0, + 0, 74, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 75, 76, 0, 0, 77, + 0, 78, 74, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 75, 76, 0, 381, 77, 0, 78, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 75, 76, 0, 484, + 77, 0, 78, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 75, 76, 0, 0, 77, 0, + 78, 64, 65, 0, 107, 158, 159, 160, 161, 162, + 163, 73, 0, 1, 2, 0, 3, 4, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 75, 76, 0, 0, 77, + 0, 78, 0, 0, 74, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 75, 76, 0, 0, + 77, 0, 78, 64, 65, 0, 107, 67, 68, 69, + 70, 71, 72, 73, 0, 1, 2, 0, 3, 4, + 5, 64, 65, 0, 289, 67, 68, 69, 70, 71, + 72, 73, 0, 1, 2, 0, 3, 4, 5, 0, + 0, 0, 0, 0, 64, 65, 74, 107, 158, 159, + 160, 161, 162, 163, 73, 0, 1, 2, 0, 3, + 4, 5, 64, 65, 74, 107, 158, 159, 160, 161, + 162, 163, 73, 0, 1, 2, 0, 3, 4, 5, + 0, 0, 0, 0, 0, 0, 0, 74, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 75, 76, + 0, 0, 77, 0, 78, 74, 64, 65, 0, 107, + 67, 68, 69, 70, 71, 72, 645, 0, 1, 2, + 0, 3, 4, 5, 64, 65, 0, 107, 67, 68, + 69, 70, 71, 72, 689, 0, 1, 2, 0, 3, + 4, 5, 0, 0, 0, 0, 0, 0, 0, 74, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 75, 76, 0, 0, 77, 0, 78, 74, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 75, 76, + 0, 0, 77, 0, 78, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 75, 76, 0, 0, 77, 0, 384, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 75, + 76, 0, 0, 77, 0, 486, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 174, 0, 0, 0, 0, + 0, 0, 0, 75, 76, 0, 0, 77, 0, 78, + 0, 0, 0, 0, 0, 0, 175, 176, 0, 0, + 0, 75, 76, 0, 0, 77, 0, 78, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 202, 203, 204, 0, 0, 205, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226 +}; + +static const yytype_int16 yycheck[] = +{ + 0, 27, 179, 247, 166, 169, 204, 4, 11, 0, + 11, 467, 21, 274, 275, 28, 167, 17, 329, 11, + 29, 219, 220, 221, 222, 223, 17, 545, 180, 297, + 19, 229, 55, 22, 55, 24, 34, 55, 55, 53, + 200, 455, 456, 201, 11, 161, 7, 666, 162, 11, + 55, 162, 78, 59, 68, 17, 54, 171, 19, 55, + 171, 22, 54, 24, 683, 54, 42, 43, 44, 45, + 46, 47, 48, 49, 156, 51, 102, 345, 161, 231, + 106, 55, 162, 55, 166, 162, 112, 54, 162, 162, + 162, 171, 118, 93, 171, 169, 169, 248, 249, 171, + 162, 55, 262, 162, 264, 263, 162, 265, 167, 171, + 162, 167, 55, 32, 33, 167, 142, 143, 41, 42, + 146, 639, 18, 384, 38, 48, 152, 645, 646, 543, + 161, 54, 121, 122, 20, 591, 159, 23, 159, 162, + 163, 159, 159, 169, 405, 406, 407, 165, 169, 347, + 167, 177, 141, 142, 159, 144, 145, 170, 147, 148, + 149, 0, 171, 159, 167, 621, 167, 163, 686, 687, + 165, 689, 690, 170, 132, 133, 202, 203, 204, 205, + 156, 157, 158, 117, 118, 159, 160, 159, 706, 707, + 162, 163, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 161, 159, 34, 518, 290, 163, + 161, 293, 294, 239, 296, 413, 159, 160, 22, 3, + 4, 5, 6, 21, 250, 486, 159, 141, 142, 143, + 144, 429, 146, 431, 432, 433, 150, 151, 37, 153, + 154, 155, 26, 27, 132, 133, 42, 43, 44, 331, + 561, 47, 563, 417, 7, 8, 22, 339, 340, 341, + 342, 343, 35, 121, 37, 22, 19, 20, 22, 22, + 23, 24, 3, 4, 5, 6, 440, 4, 141, 142, + 143, 144, 308, 146, 46, 54, 48, 150, 151, 4, + 153, 154, 155, 151, 166, 42, 287, 44, 166, 325, + 326, 327, 62, 63, 64, 65, 66, 67, 163, 160, + 472, 162, 623, 141, 142, 143, 144, 160, 146, 162, + 346, 347, 150, 151, 159, 153, 154, 155, 4, 156, + 157, 158, 132, 133, 114, 115, 418, 419, 420, 421, + 160, 160, 162, 162, 160, 427, 162, 84, 85, 161, + 22, 162, 121, 122, 160, 169, 4, 601, 384, 441, + 9, 55, 26, 27, 9, 160, 564, 159, 9, 567, + 568, 569, 141, 142, 9, 144, 145, 9, 147, 148, + 149, 9, 57, 169, 11, 160, 22, 413, 159, 159, + 472, 417, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 4, 429, 430, 431, 432, 433, 159, 159, + 159, 159, 494, 439, 440, 159, 159, 499, 159, 501, + 159, 38, 504, 38, 162, 22, 670, 162, 162, 673, + 162, 457, 514, 515, 162, 517, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 162, 162, 159, 159, 159, 481, 159, 61, 162, 159, + 486, 162, 38, 162, 162, 22, 162, 644, 165, 162, + 162, 162, 554, 555, 162, 557, 558, 559, 560, 162, + 162, 162, 162, 565, 0, 162, 17, 513, 17, 162, + 667, 573, 162, 519, 162, 169, 162, 579, 4, 162, + 162, 162, 18, 19, 20, 162, 22, 23, 24, 162, + 162, 162, 4, 539, 30, 31, 374, 375, 376, 377, + 378, 379, 380, 4, 162, 162, 169, 22, 0, 162, + 4, 389, 390, 391, 616, 169, 52, 162, 564, 162, + 56, 567, 568, 569, 60, 159, 18, 19, 20, 162, + 22, 23, 24, 162, 160, 162, 4, 162, 30, 31, + 293, 294, 162, 296, 159, 54, 160, 22, 169, 162, + 162, 160, 160, 17, 600, 162, 167, 160, 160, 165, + 52, 607, 664, 160, 56, 160, 668, 669, 60, 167, + 160, 160, 160, 54, 4, 162, 622, 152, 331, 599, + 458, 459, 460, 461, 22, 159, 339, 340, 341, 342, + 343, 469, 159, 17, 162, 17, 17, 73, 700, 701, + 17, 703, 661, 705, 93, 640, 112, 709, 239, 106, + 250, 7, 8, 715, 10, 11, 12, 13, 14, 15, + 16, 17, 17, 19, 20, 671, 22, 23, 24, 90, + 7, 8, 57, 10, 11, 12, 13, 14, 15, 16, + 17, 661, 19, 20, -1, 22, 23, 24, 133, 622, + 528, 529, 530, 531, 50, 533, 133, 462, -1, 537, + 538, -1, -1, -1, -1, 418, 419, 420, 421, -1, + -1, -1, -1, 50, 427, -1, -1, 7, 8, -1, + 10, 11, 12, 13, 14, 15, 16, 17, 441, 19, + 20, -1, 22, 23, 24, -1, -1, -1, -1, -1, + -1, -1, -1, 581, 582, 583, 584, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 50, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 494, -1, -1, -1, -1, 499, -1, 501, -1, + 628, 504, 630, 631, -1, -1, -1, -1, -1, -1, + -1, 514, 515, -1, 517, -1, -1, -1, 164, 165, + -1, -1, 168, -1, 170, 171, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 164, 165, -1, + -1, 168, -1, 170, 171, -1, -1, -1, -1, -1, + -1, 554, 555, -1, 557, 558, 559, 560, -1, -1, + -1, -1, 565, -1, -1, -1, -1, -1, -1, -1, + 573, -1, -1, -1, -1, -1, 579, -1, -1, -1, + -1, -1, -1, -1, 164, 165, -1, -1, 168, -1, + 170, 171, -1, -1, -1, -1, -1, -1, 3, 4, + 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, + -1, -1, -1, 616, 19, 20, -1, 22, 23, 24, + 25, 26, 27, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 40, 41, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 54, + -1, -1, -1, -1, 59, -1, -1, -1, -1, -1, + -1, 664, -1, -1, -1, 668, 669, -1, -1, -1, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, + -1, -1, -1, -1, -1, -1, -1, 700, 701, -1, + 703, -1, 705, -1, -1, -1, 709, -1, -1, -1, + -1, -1, 715, -1, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, -1, 133, -1, + 135, 136, 137, -1, 139, 140, 141, 142, -1, 144, + 145, -1, 147, 148, 149, -1, -1, -1, -1, -1, + -1, -1, 3, 4, 5, 6, 7, 8, 9, -1, + 165, -1, -1, 168, -1, 170, -1, 172, 19, 20, + -1, 22, 23, 24, 25, 26, 27, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 40, + 41, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 55, -1, 7, 8, 59, 10, + 11, 12, 13, 14, 15, 16, 17, -1, 19, 20, + -1, 22, 23, 24, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, -1, -1, -1, -1, -1, -1, 50, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, -1, 133, -1, 135, 136, 137, -1, 139, 140, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 159, -1, + -1, -1, -1, -1, 165, -1, -1, 168, -1, 170, + -1, 172, 3, 4, 5, 6, 7, 8, 9, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 19, 20, + -1, 22, 23, 24, 25, 26, 27, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 40, + 41, -1, -1, 164, 165, -1, -1, 168, -1, 170, + 171, -1, -1, -1, -1, -1, 7, 8, 59, 10, + 11, 12, 13, 14, 15, 16, 17, -1, 19, 20, + -1, 22, 23, 24, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, -1, -1, -1, -1, 7, 8, 50, + 10, 11, 12, 13, 14, 15, 16, 17, -1, 19, + 20, -1, 22, 23, 24, -1, -1, -1, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, -1, 133, -1, 135, 136, 137, -1, 139, 140, + 50, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 3, 4, 5, 6, -1, -1, 9, -1, -1, -1, + -1, -1, -1, -1, 165, -1, -1, 168, -1, 170, + -1, 172, 25, 26, 27, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 40, 41, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 59, -1, -1, -1, + -1, -1, -1, 164, 165, -1, -1, 168, -1, 170, + 171, -1, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 164, 165, -1, -1, 168, -1, + 170, 171, -1, -1, -1, -1, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, 129, 130, 131, -1, + 133, -1, 135, 136, 137, -1, 139, 140, 7, 8, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 19, 20, -1, 22, 23, 24, 25, -1, -1, -1, + -1, -1, 165, -1, -1, 168, -1, 170, -1, 172, + -1, 40, 41, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 7, 8, 55, 10, 11, 12, + 13, 14, 15, 16, 17, -1, 19, 20, -1, 22, + 23, 24, -1, -1, -1, -1, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, -1, -1, 50, -1, -1, + -1, 7, 8, -1, 10, 11, 12, 13, 14, 15, + 16, 17, -1, 19, 20, -1, 22, 23, 24, -1, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 39, 133, -1, 135, 136, 137, -1, + 139, 140, 7, 8, 50, 10, 11, 12, 13, 14, + 15, 16, 17, -1, 19, 20, -1, 22, 23, 24, + 159, -1, 7, 8, 163, -1, 165, -1, -1, 168, + -1, 170, -1, 172, 19, 20, -1, 22, 23, 24, + 25, -1, -1, -1, -1, 50, -1, -1, 141, 142, + -1, 144, -1, -1, -1, 40, 41, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 55, 164, 165, -1, -1, 168, -1, 170, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 164, 165, + 125, -1, 168, -1, 170, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, -1, 133, -1, + 135, 136, 137, -1, 139, 140, -1, -1, -1, 164, + 165, -1, -1, 168, -1, 170, -1, -1, -1, -1, + -1, -1, -1, -1, 159, -1, -1, -1, -1, -1, + 165, -1, -1, 168, -1, 170, -1, 172, 7, 8, + -1, 10, 11, 12, 13, 14, 15, 16, 17, -1, + 19, 20, -1, 22, 23, 24, 7, 8, -1, 10, + 11, 12, 13, 14, 15, 16, 17, -1, 19, 20, + 39, 22, 23, 24, -1, -1, -1, -1, -1, 7, + 8, 50, 10, 11, 12, 13, 14, 15, 16, 17, + -1, 19, 20, -1, 22, 23, 24, 7, 8, 50, + 10, 11, 12, 13, 14, 15, 16, 17, -1, 19, + 20, -1, 22, 23, 24, -1, -1, -1, -1, -1, + -1, -1, 50, -1, -1, -1, -1, -1, -1, 39, + -1, -1, -1, -1, -1, -1, -1, -1, 7, 8, + 50, 10, 11, 12, 13, 14, 15, 16, 17, -1, + 19, 20, -1, 22, 23, 24, -1, -1, -1, 7, + 8, -1, 10, 11, 12, 13, 14, 15, 16, 17, + 39, 19, 20, -1, 22, 23, 24, -1, -1, -1, + -1, 50, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 164, 165, -1, -1, 168, + -1, 170, 50, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 164, 165, -1, 167, 168, -1, 170, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 164, 165, -1, 167, + 168, -1, 170, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 164, 165, -1, -1, 168, -1, + 170, 7, 8, -1, 10, 11, 12, 13, 14, 15, + 16, 17, -1, 19, 20, -1, 22, 23, 24, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 164, 165, -1, -1, 168, + -1, 170, -1, -1, 50, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 164, 165, -1, -1, + 168, -1, 170, 7, 8, -1, 10, 11, 12, 13, + 14, 15, 16, 17, -1, 19, 20, -1, 22, 23, + 24, 7, 8, -1, 10, 11, 12, 13, 14, 15, + 16, 17, -1, 19, 20, -1, 22, 23, 24, -1, + -1, -1, -1, -1, 7, 8, 50, 10, 11, 12, + 13, 14, 15, 16, 17, -1, 19, 20, -1, 22, + 23, 24, 7, 8, 50, 10, 11, 12, 13, 14, + 15, 16, 17, -1, 19, 20, -1, 22, 23, 24, + -1, -1, -1, -1, -1, -1, -1, 50, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 164, 165, + -1, -1, 168, -1, 170, 50, 7, 8, -1, 10, + 11, 12, 13, 14, 15, 16, 17, -1, 19, 20, + -1, 22, 23, 24, 7, 8, -1, 10, 11, 12, + 13, 14, 15, 16, 17, -1, 19, 20, -1, 22, + 23, 24, -1, -1, -1, -1, -1, -1, -1, 50, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 164, 165, -1, -1, 168, -1, 170, 50, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 164, 165, + -1, -1, 168, -1, 170, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 164, 165, -1, -1, 168, -1, 170, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 164, + 165, -1, -1, 168, -1, 170, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 36, -1, -1, -1, -1, + -1, -1, -1, 164, 165, -1, -1, 168, -1, 170, + -1, -1, -1, -1, -1, -1, 57, 58, -1, -1, + -1, 164, 165, -1, -1, 168, -1, 170, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 114, 115, 116, -1, -1, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const yytype_uint16 yystos[] = +{ + 0, 19, 20, 22, 23, 24, 30, 31, 52, 56, + 60, 181, 184, 186, 187, 188, 222, 223, 224, 226, + 225, 53, 68, 231, 161, 59, 161, 18, 161, 42, + 43, 44, 45, 46, 47, 48, 49, 51, 156, 157, + 158, 189, 190, 191, 0, 224, 46, 48, 192, 241, + 42, 43, 44, 47, 193, 238, 240, 248, 161, 161, + 165, 232, 22, 230, 7, 8, 10, 11, 12, 13, + 14, 15, 16, 17, 50, 164, 165, 168, 170, 181, + 186, 209, 210, 244, 191, 191, 35, 37, 220, 191, + 191, 21, 249, 250, 29, 171, 239, 249, 22, 22, + 22, 233, 159, 4, 4, 4, 170, 10, 171, 210, + 215, 55, 159, 183, 220, 220, 42, 44, 194, 32, + 33, 219, 62, 63, 64, 65, 66, 67, 195, 236, + 236, 7, 184, 185, 253, 162, 167, 39, 210, 211, + 213, 214, 166, 166, 171, 215, 162, 171, 159, 214, + 163, 219, 219, 10, 125, 210, 212, 221, 11, 12, + 13, 14, 15, 16, 179, 180, 210, 216, 4, 199, + 28, 170, 237, 161, 36, 57, 58, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 114, 115, 116, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + 134, 135, 136, 137, 138, 139, 140, 174, 175, 176, + 251, 258, 259, 260, 261, 251, 259, 22, 197, 162, + 160, 210, 210, 169, 171, 210, 4, 160, 216, 210, + 159, 244, 26, 27, 3, 4, 5, 6, 9, 25, + 40, 41, 90, 91, 92, 93, 119, 133, 135, 136, + 137, 139, 140, 165, 168, 170, 172, 174, 175, 176, + 217, 244, 183, 141, 142, 144, 198, 212, 57, 10, + 210, 246, 247, 11, 17, 11, 179, 195, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 177, 26, + 27, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 178, 177, 178, 210, 210, + 246, 210, 210, 254, 246, 246, 246, 246, 246, 210, + 210, 210, 210, 210, 246, 195, 117, 118, 54, 121, + 122, 141, 142, 144, 145, 147, 148, 149, 196, 39, + 211, 201, 167, 169, 169, 160, 201, 183, 183, 221, + 177, 178, 177, 178, 159, 159, 159, 159, 159, 159, + 159, 167, 216, 218, 170, 218, 171, 218, 22, 159, + 159, 159, 227, 186, 3, 4, 5, 6, 9, 25, + 26, 27, 40, 41, 59, 165, 168, 170, 172, 217, + 243, 244, 245, 162, 245, 245, 245, 199, 210, 210, + 210, 210, 162, 204, 162, 204, 245, 165, 162, 162, + 162, 162, 162, 162, 245, 245, 245, 245, 245, 38, + 199, 210, 246, 4, 141, 142, 143, 144, 146, 150, + 151, 153, 154, 155, 200, 228, 229, 38, 159, 159, + 159, 159, 216, 216, 216, 216, 216, 216, 216, 162, + 167, 171, 210, 218, 169, 171, 216, 216, 216, 162, + 207, 159, 61, 242, 167, 218, 170, 218, 171, 218, + 22, 246, 162, 162, 212, 245, 245, 245, 245, 11, + 54, 11, 256, 245, 165, 246, 210, 246, 246, 246, + 162, 162, 257, 162, 162, 162, 210, 212, 245, 162, + 207, 207, 210, 216, 216, 216, 216, 256, 162, 162, + 162, 162, 257, 162, 216, 169, 171, 162, 162, 38, + 34, 54, 205, 208, 39, 210, 234, 235, 22, 167, + 171, 218, 169, 171, 17, 17, 245, 162, 162, 162, + 162, 245, 4, 245, 162, 162, 245, 162, 162, 162, + 4, 4, 162, 210, 245, 245, 245, 162, 204, 210, + 160, 162, 162, 162, 162, 160, 216, 216, 216, 216, + 160, 216, 169, 216, 216, 210, 22, 4, 207, 197, + 162, 160, 162, 169, 171, 245, 245, 159, 245, 245, + 245, 245, 204, 204, 246, 245, 162, 246, 246, 246, + 4, 245, 159, 245, 216, 216, 216, 216, 162, 160, + 162, 162, 257, 160, 160, 160, 181, 182, 39, 210, + 201, 22, 169, 162, 165, 17, 210, 255, 167, 245, + 257, 255, 204, 160, 160, 160, 160, 216, 216, 216, + 160, 197, 205, 206, 17, 167, 179, 252, 197, 197, + 160, 162, 167, 160, 160, 160, 160, 182, 54, 203, + 245, 243, 167, 179, 121, 122, 245, 245, 201, 17, + 210, 201, 4, 152, 202, 162, 243, 197, 197, 38, + 197, 197, 22, 17, 162, 17, 245, 245, 245, 17, + 245, 197, 197, 245, 73, 17, 245 +}; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ + +#define YYFAIL goto yyerrlab + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yytoken = YYTRANSLATE (yychar); \ + YYPOPSTACK (1); \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ +while (YYID (0)) + + +#define YYTERROR 1 +#define YYERRCODE 256 + + +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (YYID (N)) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (YYID (0)) +#endif + + +/* YY_LOCATION_PRINT -- Print the location on the stream. + This macro was not mandated originally: define only if we know + we won't break user code: when these are the locations we know. */ + +#ifndef YY_LOCATION_PRINT +# if YYLTYPE_IS_TRIVIAL +# define YY_LOCATION_PRINT(File, Loc) \ + fprintf (File, "%d.%d-%d.%d", \ + (Loc).first_line, (Loc).first_column, \ + (Loc).last_line, (Loc).last_column) +# else +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +# endif +#endif + + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#ifdef YYLEX_PARAM +# define YYLEX yylex (YYLEX_PARAM) +#else +# define YYLEX yylex () +#endif + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (YYID (0)) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Type, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (YYID (0)) + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +#else +static void +yy_symbol_value_print (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; +#endif +{ + if (!yyvaluep) + return; +# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# else + YYUSE (yyoutput); +# endif + switch (yytype) + { + default: + break; + } +} + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +#else +static void +yy_symbol_print (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; +#endif +{ + if (yytype < YYNTOKENS) + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + + yy_symbol_value_print (yyoutput, yytype, yyvaluep); + YYFPRINTF (yyoutput, ")"); +} + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) +#else +static void +yy_stack_print (bottom, top) + yytype_int16 *bottom; + yytype_int16 *top; +#endif +{ + YYFPRINTF (stderr, "Stack now"); + for (; bottom <= top; ++bottom) + YYFPRINTF (stderr, " %d", *bottom); + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (YYID (0)) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_reduce_print (YYSTYPE *yyvsp, int yyrule) +#else +static void +yy_reduce_print (yyvsp, yyrule) + YYSTYPE *yyvsp; + int yyrule; +#endif +{ + int yynrhs = yyr2[yyrule]; + int yyi; + unsigned long int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + fprintf (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], + &(yyvsp[(yyi + 1) - (yynrhs)]) + ); + fprintf (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyvsp, Rule); \ +} while (YYID (0)) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static YYSIZE_T +yystrlen (const char *yystr) +#else +static YYSIZE_T +yystrlen (yystr) + const char *yystr; +#endif +{ + YYSIZE_T yylen; + for (yylen = 0; yystr[yylen]; yylen++) + continue; + return yylen; +} +# endif +# endif + +# ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static char * +yystpcpy (char *yydest, const char *yysrc) +#else +static char * +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +#endif +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +# ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYSIZE_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYSIZE_T yyn = 0; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (! yyres) + return yystrlen (yystr); + + return yystpcpy (yyres, yystr) - yyres; +} +# endif + +/* Copy into YYRESULT an error message about the unexpected token + YYCHAR while in state YYSTATE. Return the number of bytes copied, + including the terminating null byte. If YYRESULT is null, do not + copy anything; just return the number of bytes that would be + copied. As a special case, return 0 if an ordinary "syntax error" + message will do. Return YYSIZE_MAXIMUM if overflow occurs during + size calculation. */ +static YYSIZE_T +yysyntax_error (char *yyresult, int yystate, int yychar) +{ + int yyn = yypact[yystate]; + + if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) + return 0; + else + { + int yytype = YYTRANSLATE (yychar); + YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); + YYSIZE_T yysize = yysize0; + YYSIZE_T yysize1; + int yysize_overflow = 0; + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + int yyx; + +# if 0 + /* This is so xgettext sees the translatable formats that are + constructed on the fly. */ + YY_("syntax error, unexpected %s"); + YY_("syntax error, unexpected %s, expecting %s"); + YY_("syntax error, unexpected %s, expecting %s or %s"); + YY_("syntax error, unexpected %s, expecting %s or %s or %s"); + YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); +# endif + char *yyfmt; + char const *yyf; + static char const yyunexpected[] = "syntax error, unexpected %s"; + static char const yyexpecting[] = ", expecting %s"; + static char const yyor[] = " or %s"; + char yyformat[sizeof yyunexpected + + sizeof yyexpecting - 1 + + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) + * (sizeof yyor - 1))]; + char const *yyprefix = yyexpecting; + + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yycount = 1; + + yyarg[0] = yytname[yytype]; + yyfmt = yystpcpy (yyformat, yyunexpected); + + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + yysize = yysize0; + yyformat[sizeof yyunexpected - 1] = '\0'; + break; + } + yyarg[yycount++] = yytname[yyx]; + yysize1 = yysize + yytnamerr (0, yytname[yyx]); + yysize_overflow |= (yysize1 < yysize); + yysize = yysize1; + yyfmt = yystpcpy (yyfmt, yyprefix); + yyprefix = yyor; + } + + yyf = YY_(yyformat); + yysize1 = yysize + yystrlen (yyf); + yysize_overflow |= (yysize1 < yysize); + yysize = yysize1; + + if (yysize_overflow) + return YYSIZE_MAXIMUM; + + if (yyresult) + { + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + char *yyp = yyresult; + int yyi = 0; + while ((*yyp = *yyf) != '\0') + { + if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyf += 2; + } + else + { + yyp++; + yyf++; + } + } + } + return yysize; + } +} +#endif /* YYERROR_VERBOSE */ + + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) +#else +static void +yydestruct (yymsg, yytype, yyvaluep) + const char *yymsg; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + YYUSE (yyvaluep); + + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { + + default: + break; + } +} + + +/* Prevent warnings from -Wmissing-prototypes. */ + +#ifdef YYPARSE_PARAM +#if defined __STDC__ || defined __cplusplus +int yyparse (void *YYPARSE_PARAM); +#else +int yyparse (); +#endif +#else /* ! YYPARSE_PARAM */ +#if defined __STDC__ || defined __cplusplus +int yyparse (void); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ + + + +/* The look-ahead symbol. */ +int yychar; + +/* The semantic value of the look-ahead symbol. */ +YYSTYPE yylval; + +/* Number of syntax errors so far. */ +int yynerrs; + + + +/*----------. +| yyparse. | +`----------*/ + +#ifdef YYPARSE_PARAM +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (void *YYPARSE_PARAM) +#else +int +yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +#endif +#else /* ! YYPARSE_PARAM */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (void) +#else +int +yyparse () + +#endif +#endif +{ + + int yystate; + int yyn; + int yyresult; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + /* Look-ahead token as an internal (translated) token number. */ + int yytoken = 0; +#if YYERROR_VERBOSE + /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char *yymsg = yymsgbuf; + YYSIZE_T yymsg_alloc = sizeof yymsgbuf; +#endif + + /* Three stacks and their tools: + `yyss': related to states, + `yyvs': related to semantic values, + `yyls': related to locations. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + yytype_int16 yyssa[YYINITDEPTH]; + yytype_int16 *yyss = yyssa; + yytype_int16 *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + YYSTYPE *yyvsp; + + + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) + + YYSIZE_T yystacksize = YYINITDEPTH; + + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss; + yyvsp = yyvs; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + yytype_int16 *yyss1 = yyss; + + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyexhaustedlab; +# else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + goto yyexhaustedlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yytype_int16 *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyexhaustedlab; + YYSTACK_RELOCATE (yyss); + YYSTACK_RELOCATE (yyvs); + +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + + /* Do appropriate processing given the current state. Read a + look-ahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to look-ahead token. */ + yyn = yypact[yystate]; + if (yyn == YYPACT_NINF) + goto yydefault; + + /* Not known => get a look-ahead token if don't already have one. */ + + /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yyn == 0 || yyn == YYTABLE_NINF) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + if (yyn == YYFINAL) + YYACCEPT; + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the look-ahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the shifted token unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + yystate = yyn; + *++yyvsp = yylval; + + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 29: +#line 1146 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.IPredicate) = ICmpInst::ICMP_EQ; ;} + break; + + case 30: +#line 1146 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.IPredicate) = ICmpInst::ICMP_NE; ;} + break; + + case 31: +#line 1147 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.IPredicate) = ICmpInst::ICMP_SLT; ;} + break; + + case 32: +#line 1147 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.IPredicate) = ICmpInst::ICMP_SGT; ;} + break; + + case 33: +#line 1148 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.IPredicate) = ICmpInst::ICMP_SLE; ;} + break; + + case 34: +#line 1148 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.IPredicate) = ICmpInst::ICMP_SGE; ;} + break; + + case 35: +#line 1149 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.IPredicate) = ICmpInst::ICMP_ULT; ;} + break; + + case 36: +#line 1149 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.IPredicate) = ICmpInst::ICMP_UGT; ;} + break; + + case 37: +#line 1150 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.IPredicate) = ICmpInst::ICMP_ULE; ;} + break; + + case 38: +#line 1150 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.IPredicate) = ICmpInst::ICMP_UGE; ;} + break; + + case 39: +#line 1154 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.FPredicate) = FCmpInst::FCMP_OEQ; ;} + break; + + case 40: +#line 1154 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.FPredicate) = FCmpInst::FCMP_ONE; ;} + break; + + case 41: +#line 1155 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.FPredicate) = FCmpInst::FCMP_OLT; ;} + break; + + case 42: +#line 1155 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.FPredicate) = FCmpInst::FCMP_OGT; ;} + break; + + case 43: +#line 1156 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.FPredicate) = FCmpInst::FCMP_OLE; ;} + break; + + case 44: +#line 1156 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.FPredicate) = FCmpInst::FCMP_OGE; ;} + break; + + case 45: +#line 1157 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.FPredicate) = FCmpInst::FCMP_ORD; ;} + break; + + case 46: +#line 1157 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.FPredicate) = FCmpInst::FCMP_UNO; ;} + break; + + case 47: +#line 1158 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.FPredicate) = FCmpInst::FCMP_UEQ; ;} + break; + + case 48: +#line 1158 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.FPredicate) = FCmpInst::FCMP_UNE; ;} + break; + + case 49: +#line 1159 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.FPredicate) = FCmpInst::FCMP_ULT; ;} + break; + + case 50: +#line 1159 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.FPredicate) = FCmpInst::FCMP_UGT; ;} + break; + + case 51: +#line 1160 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.FPredicate) = FCmpInst::FCMP_ULE; ;} + break; + + case 52: +#line 1160 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.FPredicate) = FCmpInst::FCMP_UGE; ;} + break; + + case 53: +#line 1161 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.FPredicate) = FCmpInst::FCMP_TRUE; ;} + break; + + case 54: +#line 1162 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.FPredicate) = FCmpInst::FCMP_FALSE; ;} + break; + + case 65: +#line 1171 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.StrVal) = 0; ;} + break; + + case 66: +#line 1173 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.UIntVal)=(yyvsp[(3) - (4)].UInt64Val); ;} + break; + + case 67: +#line 1174 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.UIntVal)=0; ;} + break; + + case 68: +#line 1178 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.StrVal) = (yyvsp[(1) - (2)].StrVal); + CHECK_FOR_ERROR + ;} + break; + + case 69: +#line 1182 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.StrVal) = 0; + CHECK_FOR_ERROR + ;} + break; + + case 70: +#line 1187 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.UIntVal) = (yyvsp[(1) - (2)].UIntVal); + CHECK_FOR_ERROR +;} + break; + + case 74: +#line 1196 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.StrVal) = 0; + CHECK_FOR_ERROR + ;} + break; + + case 75: +#line 1201 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.StrVal) = (yyvsp[(1) - (2)].StrVal); + CHECK_FOR_ERROR + ;} + break; + + case 76: +#line 1207 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::InternalLinkage; ;} + break; + + case 77: +#line 1208 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::WeakLinkage; ;} + break; + + case 78: +#line 1209 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;} + break; + + case 79: +#line 1210 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::AppendingLinkage; ;} + break; + + case 80: +#line 1211 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;} + break; + + case 81: +#line 1212 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::CommonLinkage; ;} + break; + + case 82: +#line 1216 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;} + break; + + case 83: +#line 1217 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;} + break; + + case 84: +#line 1218 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;} + break; + + case 85: +#line 1222 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Visibility) = GlobalValue::DefaultVisibility; ;} + break; + + case 86: +#line 1223 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Visibility) = GlobalValue::DefaultVisibility; ;} + break; + + case 87: +#line 1224 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Visibility) = GlobalValue::HiddenVisibility; ;} + break; + + case 88: +#line 1225 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Visibility) = GlobalValue::ProtectedVisibility; ;} + break; + + case 89: +#line 1229 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;} + break; + + case 90: +#line 1230 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;} + break; + + case 91: +#line 1231 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;} + break; + + case 92: +#line 1235 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;} + break; + + case 93: +#line 1236 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::InternalLinkage; ;} + break; + + case 94: +#line 1237 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;} + break; + + case 95: +#line 1238 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::WeakLinkage; ;} + break; + + case 96: +#line 1239 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;} + break; + + case 97: +#line 1243 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;} + break; + + case 98: +#line 1244 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::WeakLinkage; ;} + break; + + case 99: +#line 1245 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Linkage) = GlobalValue::InternalLinkage; ;} + break; + + case 100: +#line 1248 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.UIntVal) = CallingConv::C; ;} + break; + + case 101: +#line 1249 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.UIntVal) = CallingConv::C; ;} + break; + + case 102: +#line 1250 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.UIntVal) = CallingConv::Fast; ;} + break; + + case 103: +#line 1251 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.UIntVal) = CallingConv::Cold; ;} + break; + + case 104: +#line 1252 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.UIntVal) = CallingConv::X86_StdCall; ;} + break; + + case 105: +#line 1253 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.UIntVal) = CallingConv::X86_FastCall; ;} + break; + + case 106: +#line 1254 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if ((unsigned)(yyvsp[(2) - (2)].UInt64Val) != (yyvsp[(2) - (2)].UInt64Val)) + GEN_ERROR("Calling conv too large"); + (yyval.UIntVal) = (yyvsp[(2) - (2)].UInt64Val); + CHECK_FOR_ERROR + ;} + break; + + case 107: +#line 1261 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::ZExt; ;} + break; + + case 108: +#line 1262 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::ZExt; ;} + break; + + case 109: +#line 1263 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::SExt; ;} + break; + + case 110: +#line 1264 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::SExt; ;} + break; + + case 111: +#line 1265 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::InReg; ;} + break; + + case 112: +#line 1266 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::StructRet; ;} + break; + + case 113: +#line 1267 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::NoAlias; ;} + break; + + case 114: +#line 1268 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::ByVal; ;} + break; + + case 115: +#line 1269 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::Nest; ;} + break; + + case 116: +#line 1270 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = + Attribute::constructAlignmentFromInt((yyvsp[(2) - (2)].UInt64Val)); ;} + break; + + case 117: +#line 1274 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::None; ;} + break; + + case 118: +#line 1275 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.Attributes) = (yyvsp[(1) - (2)].Attributes) | (yyvsp[(2) - (2)].Attributes); + ;} + break; + + case 119: +#line 1280 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::InReg; ;} + break; + + case 120: +#line 1281 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::ZExt; ;} + break; + + case 121: +#line 1282 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::SExt; ;} + break; + + case 122: +#line 1285 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::None; ;} + break; + + case 123: +#line 1286 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.Attributes) = (yyvsp[(1) - (2)].Attributes) | (yyvsp[(2) - (2)].Attributes); + ;} + break; + + case 124: +#line 1292 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::NoReturn; ;} + break; + + case 125: +#line 1293 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::NoUnwind; ;} + break; + + case 126: +#line 1294 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::InReg; ;} + break; + + case 127: +#line 1295 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::ZExt; ;} + break; + + case 128: +#line 1296 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::SExt; ;} + break; + + case 129: +#line 1297 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::ReadNone; ;} + break; + + case 130: +#line 1298 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::ReadOnly; ;} + break; + + case 131: +#line 1299 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::NoInline; ;} + break; + + case 132: +#line 1300 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::AlwaysInline; ;} + break; + + case 133: +#line 1301 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::OptimizeForSize; ;} + break; + + case 134: +#line 1304 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.Attributes) = Attribute::None; ;} + break; + + case 135: +#line 1305 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.Attributes) = (yyvsp[(1) - (2)].Attributes) | (yyvsp[(2) - (2)].Attributes); + ;} + break; + + case 136: +#line 1311 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.StrVal) = 0; ;} + break; + + case 137: +#line 1312 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.StrVal) = (yyvsp[(2) - (2)].StrVal); + ;} + break; + + case 138: +#line 1319 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.UIntVal) = 0; ;} + break; + + case 139: +#line 1320 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.UIntVal) = (yyvsp[(2) - (2)].UInt64Val); + if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal))) + GEN_ERROR("Alignment must be a power of two"); + CHECK_FOR_ERROR +;} + break; + + case 140: +#line 1326 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.UIntVal) = 0; ;} + break; + + case 141: +#line 1327 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.UIntVal) = (yyvsp[(3) - (3)].UInt64Val); + if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal))) + GEN_ERROR("Alignment must be a power of two"); + CHECK_FOR_ERROR +;} + break; + + case 142: +#line 1336 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + for (unsigned i = 0, e = (yyvsp[(2) - (2)].StrVal)->length(); i != e; ++i) + if ((*(yyvsp[(2) - (2)].StrVal))[i] == '"' || (*(yyvsp[(2) - (2)].StrVal))[i] == '\\') + GEN_ERROR("Invalid character in section name"); + (yyval.StrVal) = (yyvsp[(2) - (2)].StrVal); + CHECK_FOR_ERROR +;} + break; + + case 143: +#line 1344 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.StrVal) = 0; ;} + break; + + case 144: +#line 1345 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.StrVal) = (yyvsp[(1) - (1)].StrVal); ;} + break; + + case 145: +#line 1350 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + {;} + break; + + case 146: +#line 1351 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + {;} + break; + + case 147: +#line 1352 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + CurGV->setSection(*(yyvsp[(1) - (1)].StrVal)); + delete (yyvsp[(1) - (1)].StrVal); + CHECK_FOR_ERROR + ;} + break; + + case 148: +#line 1357 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if ((yyvsp[(2) - (2)].UInt64Val) != 0 && !isPowerOf2_32((yyvsp[(2) - (2)].UInt64Val))) + GEN_ERROR("Alignment must be a power of two"); + CurGV->setAlignment((yyvsp[(2) - (2)].UInt64Val)); + CHECK_FOR_ERROR + ;} + break; + + case 156: +#line 1373 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.TypeVal) = new PATypeHolder(OpaqueType::get()); + CHECK_FOR_ERROR + ;} + break; + + case 157: +#line 1377 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.TypeVal) = new PATypeHolder((yyvsp[(1) - (1)].PrimType)); + CHECK_FOR_ERROR + ;} + break; + + case 158: +#line 1381 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Pointer type? + if (*(yyvsp[(1) - (3)].TypeVal) == Type::LabelTy) + GEN_ERROR("Cannot form a pointer to a basic block"); + (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(PointerType::get(*(yyvsp[(1) - (3)].TypeVal), (yyvsp[(2) - (3)].UIntVal)))); + delete (yyvsp[(1) - (3)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 159: +#line 1388 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Named types are also simple types... + const Type* tmp = getTypeVal((yyvsp[(1) - (1)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.TypeVal) = new PATypeHolder(tmp); + ;} + break; + + case 160: +#line 1393 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Type UpReference + if ((yyvsp[(2) - (2)].UInt64Val) > (uint64_t)~0U) GEN_ERROR("Value out of range"); + OpaqueType *OT = OpaqueType::get(); // Use temporary placeholder + UpRefs.push_back(UpRefRecord((unsigned)(yyvsp[(2) - (2)].UInt64Val), OT)); // Add to vector... + (yyval.TypeVal) = new PATypeHolder(OT); + UR_OUT("New Upreference!\n"); + CHECK_FOR_ERROR + ;} + break; + + case 161: +#line 1401 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + // Allow but ignore attributes on function types; this permits auto-upgrade. + // FIXME: remove in LLVM 3.0. + const Type *RetTy = *(yyvsp[(1) - (5)].TypeVal); + if (!FunctionType::isValidReturnType(RetTy)) + GEN_ERROR("Invalid result type for LLVM function"); + + std::vector Params; + TypeWithAttrsList::iterator I = (yyvsp[(3) - (5)].TypeWithAttrsList)->begin(), E = (yyvsp[(3) - (5)].TypeWithAttrsList)->end(); + for (; I != E; ++I ) { + const Type *Ty = I->Ty->get(); + Params.push_back(Ty); + } + + bool isVarArg = Params.size() && Params.back() == Type::VoidTy; + if (isVarArg) Params.pop_back(); + + for (unsigned i = 0; i != Params.size(); ++i) + if (!(Params[i]->isFirstClassType() || isa(Params[i]))) + GEN_ERROR("Function arguments must be value types!"); + + CHECK_FOR_ERROR + + FunctionType *FT = FunctionType::get(RetTy, Params, isVarArg); + delete (yyvsp[(1) - (5)].TypeVal); // Delete the return type handle + (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(FT)); + + // Delete the argument list + for (I = (yyvsp[(3) - (5)].TypeWithAttrsList)->begin() ; I != E; ++I ) { + delete I->Ty; + } + delete (yyvsp[(3) - (5)].TypeWithAttrsList); + + CHECK_FOR_ERROR + ;} + break; + + case 162: +#line 1436 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + // Allow but ignore attributes on function types; this permits auto-upgrade. + // FIXME: remove in LLVM 3.0. + std::vector Params; + TypeWithAttrsList::iterator I = (yyvsp[(3) - (5)].TypeWithAttrsList)->begin(), E = (yyvsp[(3) - (5)].TypeWithAttrsList)->end(); + for ( ; I != E; ++I ) { + const Type* Ty = I->Ty->get(); + Params.push_back(Ty); + } + + bool isVarArg = Params.size() && Params.back() == Type::VoidTy; + if (isVarArg) Params.pop_back(); + + for (unsigned i = 0; i != Params.size(); ++i) + if (!(Params[i]->isFirstClassType() || isa(Params[i]))) + GEN_ERROR("Function arguments must be value types!"); + + CHECK_FOR_ERROR + + FunctionType *FT = FunctionType::get((yyvsp[(1) - (5)].PrimType), Params, isVarArg); + (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(FT)); + + // Delete the argument list + for (I = (yyvsp[(3) - (5)].TypeWithAttrsList)->begin() ; I != E; ++I ) { + delete I->Ty; + } + delete (yyvsp[(3) - (5)].TypeWithAttrsList); + + CHECK_FOR_ERROR + ;} + break; + + case 163: +#line 1467 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Sized array type? + (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(ArrayType::get(*(yyvsp[(4) - (5)].TypeVal), (yyvsp[(2) - (5)].UInt64Val)))); + delete (yyvsp[(4) - (5)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 164: +#line 1472 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Vector type? + const llvm::Type* ElemTy = (yyvsp[(4) - (5)].TypeVal)->get(); + if ((unsigned)(yyvsp[(2) - (5)].UInt64Val) != (yyvsp[(2) - (5)].UInt64Val)) + GEN_ERROR("Unsigned result not equal to signed result"); + if (!ElemTy->isFloatingPoint() && !ElemTy->isInteger()) + GEN_ERROR("Element type of a VectorType must be primitive"); + (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(VectorType::get(*(yyvsp[(4) - (5)].TypeVal), (unsigned)(yyvsp[(2) - (5)].UInt64Val)))); + delete (yyvsp[(4) - (5)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 165: +#line 1482 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Structure type? + std::vector Elements; + for (std::list::iterator I = (yyvsp[(2) - (3)].TypeList)->begin(), + E = (yyvsp[(2) - (3)].TypeList)->end(); I != E; ++I) + Elements.push_back(*I); + + (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(StructType::get(Elements))); + delete (yyvsp[(2) - (3)].TypeList); + CHECK_FOR_ERROR + ;} + break; + + case 166: +#line 1492 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Empty structure type? + (yyval.TypeVal) = new PATypeHolder(StructType::get(std::vector())); + CHECK_FOR_ERROR + ;} + break; + + case 167: +#line 1496 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + std::vector Elements; + for (std::list::iterator I = (yyvsp[(3) - (5)].TypeList)->begin(), + E = (yyvsp[(3) - (5)].TypeList)->end(); I != E; ++I) + Elements.push_back(*I); + + (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true))); + delete (yyvsp[(3) - (5)].TypeList); + CHECK_FOR_ERROR + ;} + break; + + case 168: +#line 1506 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Empty structure type? + (yyval.TypeVal) = new PATypeHolder(StructType::get(std::vector(), true)); + CHECK_FOR_ERROR + ;} + break; + + case 169: +#line 1513 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + // Allow but ignore attributes on function types; this permits auto-upgrade. + // FIXME: remove in LLVM 3.0. + (yyval.TypeWithAttrs).Ty = (yyvsp[(1) - (2)].TypeVal); + (yyval.TypeWithAttrs).Attrs = Attribute::None; + ;} + break; + + case 170: +#line 1522 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (1)].TypeVal))->getDescription()); + if (!(*(yyvsp[(1) - (1)].TypeVal))->isFirstClassType() && !isa((yyvsp[(1) - (1)].TypeVal)->get())) + GEN_ERROR("LLVM functions cannot return aggregate types"); + (yyval.TypeVal) = (yyvsp[(1) - (1)].TypeVal); + ;} + break; + + case 171: +#line 1529 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.TypeVal) = new PATypeHolder(Type::VoidTy); + ;} + break; + + case 172: +#line 1534 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.TypeWithAttrsList) = new TypeWithAttrsList(); + (yyval.TypeWithAttrsList)->push_back((yyvsp[(1) - (1)].TypeWithAttrs)); + CHECK_FOR_ERROR + ;} + break; + + case 173: +#line 1539 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + ((yyval.TypeWithAttrsList)=(yyvsp[(1) - (3)].TypeWithAttrsList))->push_back((yyvsp[(3) - (3)].TypeWithAttrs)); + CHECK_FOR_ERROR + ;} + break; + + case 175: +#line 1547 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.TypeWithAttrsList)=(yyvsp[(1) - (3)].TypeWithAttrsList); + TypeWithAttrs TWA; TWA.Attrs = Attribute::None; + TWA.Ty = new PATypeHolder(Type::VoidTy); + (yyval.TypeWithAttrsList)->push_back(TWA); + CHECK_FOR_ERROR + ;} + break; + + case 176: +#line 1554 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.TypeWithAttrsList) = new TypeWithAttrsList; + TypeWithAttrs TWA; TWA.Attrs = Attribute::None; + TWA.Ty = new PATypeHolder(Type::VoidTy); + (yyval.TypeWithAttrsList)->push_back(TWA); + CHECK_FOR_ERROR + ;} + break; + + case 177: +#line 1561 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.TypeWithAttrsList) = new TypeWithAttrsList(); + CHECK_FOR_ERROR + ;} + break; + + case 178: +#line 1569 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.TypeList) = new std::list(); + (yyval.TypeList)->push_back(*(yyvsp[(1) - (1)].TypeVal)); + delete (yyvsp[(1) - (1)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 179: +#line 1575 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + ((yyval.TypeList)=(yyvsp[(1) - (3)].TypeList))->push_back(*(yyvsp[(3) - (3)].TypeVal)); + delete (yyvsp[(3) - (3)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 180: +#line 1587 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Nonempty unsized arr + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (4)].TypeVal))->getDescription()); + const ArrayType *ATy = dyn_cast((yyvsp[(1) - (4)].TypeVal)->get()); + if (ATy == 0) + GEN_ERROR("Cannot make array constant with type: '" + + (*(yyvsp[(1) - (4)].TypeVal))->getDescription() + "'"); + const Type *ETy = ATy->getElementType(); + uint64_t NumElements = ATy->getNumElements(); + + // Verify that we have the correct size... + if (NumElements != uint64_t(-1) && NumElements != (yyvsp[(3) - (4)].ConstVector)->size()) + GEN_ERROR("Type mismatch: constant sized array initialized with " + + utostr((yyvsp[(3) - (4)].ConstVector)->size()) + " arguments, but has size of " + + utostr(NumElements) + ""); + + // Verify all elements are correct type! + for (unsigned i = 0; i < (yyvsp[(3) - (4)].ConstVector)->size(); i++) { + if (ETy != (*(yyvsp[(3) - (4)].ConstVector))[i]->getType()) + GEN_ERROR("Element #" + utostr(i) + " is not of type '" + + ETy->getDescription() +"' as required!\nIt is of type '"+ + (*(yyvsp[(3) - (4)].ConstVector))[i]->getType()->getDescription() + "'."); + } + + (yyval.ConstVal) = ConstantArray::get(ATy, *(yyvsp[(3) - (4)].ConstVector)); + delete (yyvsp[(1) - (4)].TypeVal); delete (yyvsp[(3) - (4)].ConstVector); + CHECK_FOR_ERROR + ;} + break; + + case 181: +#line 1615 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription()); + const ArrayType *ATy = dyn_cast((yyvsp[(1) - (3)].TypeVal)->get()); + if (ATy == 0) + GEN_ERROR("Cannot make array constant with type: '" + + (*(yyvsp[(1) - (3)].TypeVal))->getDescription() + "'"); + + uint64_t NumElements = ATy->getNumElements(); + if (NumElements != uint64_t(-1) && NumElements != 0) + GEN_ERROR("Type mismatch: constant sized array initialized with 0" + " arguments, but has size of " + utostr(NumElements) +""); + (yyval.ConstVal) = ConstantArray::get(ATy, std::vector()); + delete (yyvsp[(1) - (3)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 182: +#line 1631 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription()); + const ArrayType *ATy = dyn_cast((yyvsp[(1) - (3)].TypeVal)->get()); + if (ATy == 0) + GEN_ERROR("Cannot make array constant with type: '" + + (*(yyvsp[(1) - (3)].TypeVal))->getDescription() + "'"); + + uint64_t NumElements = ATy->getNumElements(); + const Type *ETy = ATy->getElementType(); + if (NumElements != uint64_t(-1) && NumElements != (yyvsp[(3) - (3)].StrVal)->length()) + GEN_ERROR("Can't build string constant of size " + + utostr((yyvsp[(3) - (3)].StrVal)->length()) + + " when array has size " + utostr(NumElements) + ""); + std::vector Vals; + if (ETy == Type::Int8Ty) { + for (uint64_t i = 0; i < (yyvsp[(3) - (3)].StrVal)->length(); ++i) + Vals.push_back(ConstantInt::get(ETy, (*(yyvsp[(3) - (3)].StrVal))[i])); + } else { + delete (yyvsp[(3) - (3)].StrVal); + GEN_ERROR("Cannot build string arrays of non byte sized elements"); + } + delete (yyvsp[(3) - (3)].StrVal); + (yyval.ConstVal) = ConstantArray::get(ATy, Vals); + delete (yyvsp[(1) - (3)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 183: +#line 1658 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Nonempty unsized arr + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (4)].TypeVal))->getDescription()); + const VectorType *PTy = dyn_cast((yyvsp[(1) - (4)].TypeVal)->get()); + if (PTy == 0) + GEN_ERROR("Cannot make packed constant with type: '" + + (*(yyvsp[(1) - (4)].TypeVal))->getDescription() + "'"); + const Type *ETy = PTy->getElementType(); + unsigned NumElements = PTy->getNumElements(); + + // Verify that we have the correct size... + if (NumElements != unsigned(-1) && NumElements != (unsigned)(yyvsp[(3) - (4)].ConstVector)->size()) + GEN_ERROR("Type mismatch: constant sized packed initialized with " + + utostr((yyvsp[(3) - (4)].ConstVector)->size()) + " arguments, but has size of " + + utostr(NumElements) + ""); + + // Verify all elements are correct type! + for (unsigned i = 0; i < (yyvsp[(3) - (4)].ConstVector)->size(); i++) { + if (ETy != (*(yyvsp[(3) - (4)].ConstVector))[i]->getType()) + GEN_ERROR("Element #" + utostr(i) + " is not of type '" + + ETy->getDescription() +"' as required!\nIt is of type '"+ + (*(yyvsp[(3) - (4)].ConstVector))[i]->getType()->getDescription() + "'."); + } + + (yyval.ConstVal) = ConstantVector::get(PTy, *(yyvsp[(3) - (4)].ConstVector)); + delete (yyvsp[(1) - (4)].TypeVal); delete (yyvsp[(3) - (4)].ConstVector); + CHECK_FOR_ERROR + ;} + break; + + case 184: +#line 1686 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + const StructType *STy = dyn_cast((yyvsp[(1) - (4)].TypeVal)->get()); + if (STy == 0) + GEN_ERROR("Cannot make struct constant with type: '" + + (*(yyvsp[(1) - (4)].TypeVal))->getDescription() + "'"); + + if ((yyvsp[(3) - (4)].ConstVector)->size() != STy->getNumContainedTypes()) + GEN_ERROR("Illegal number of initializers for structure type"); + + // Check to ensure that constants are compatible with the type initializer! + for (unsigned i = 0, e = (yyvsp[(3) - (4)].ConstVector)->size(); i != e; ++i) + if ((*(yyvsp[(3) - (4)].ConstVector))[i]->getType() != STy->getElementType(i)) + GEN_ERROR("Expected type '" + + STy->getElementType(i)->getDescription() + + "' for element #" + utostr(i) + + " of structure initializer"); + + // Check to ensure that Type is not packed + if (STy->isPacked()) + GEN_ERROR("Unpacked Initializer to vector type '" + + STy->getDescription() + "'"); + + (yyval.ConstVal) = ConstantStruct::get(STy, *(yyvsp[(3) - (4)].ConstVector)); + delete (yyvsp[(1) - (4)].TypeVal); delete (yyvsp[(3) - (4)].ConstVector); + CHECK_FOR_ERROR + ;} + break; + + case 185: +#line 1712 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription()); + const StructType *STy = dyn_cast((yyvsp[(1) - (3)].TypeVal)->get()); + if (STy == 0) + GEN_ERROR("Cannot make struct constant with type: '" + + (*(yyvsp[(1) - (3)].TypeVal))->getDescription() + "'"); + + if (STy->getNumContainedTypes() != 0) + GEN_ERROR("Illegal number of initializers for structure type"); + + // Check to ensure that Type is not packed + if (STy->isPacked()) + GEN_ERROR("Unpacked Initializer to vector type '" + + STy->getDescription() + "'"); + + (yyval.ConstVal) = ConstantStruct::get(STy, std::vector()); + delete (yyvsp[(1) - (3)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 186: +#line 1732 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + const StructType *STy = dyn_cast((yyvsp[(1) - (6)].TypeVal)->get()); + if (STy == 0) + GEN_ERROR("Cannot make struct constant with type: '" + + (*(yyvsp[(1) - (6)].TypeVal))->getDescription() + "'"); + + if ((yyvsp[(4) - (6)].ConstVector)->size() != STy->getNumContainedTypes()) + GEN_ERROR("Illegal number of initializers for structure type"); + + // Check to ensure that constants are compatible with the type initializer! + for (unsigned i = 0, e = (yyvsp[(4) - (6)].ConstVector)->size(); i != e; ++i) + if ((*(yyvsp[(4) - (6)].ConstVector))[i]->getType() != STy->getElementType(i)) + GEN_ERROR("Expected type '" + + STy->getElementType(i)->getDescription() + + "' for element #" + utostr(i) + + " of structure initializer"); + + // Check to ensure that Type is packed + if (!STy->isPacked()) + GEN_ERROR("Vector initializer to non-vector type '" + + STy->getDescription() + "'"); + + (yyval.ConstVal) = ConstantStruct::get(STy, *(yyvsp[(4) - (6)].ConstVector)); + delete (yyvsp[(1) - (6)].TypeVal); delete (yyvsp[(4) - (6)].ConstVector); + CHECK_FOR_ERROR + ;} + break; + + case 187: +#line 1758 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (5)].TypeVal))->getDescription()); + const StructType *STy = dyn_cast((yyvsp[(1) - (5)].TypeVal)->get()); + if (STy == 0) + GEN_ERROR("Cannot make struct constant with type: '" + + (*(yyvsp[(1) - (5)].TypeVal))->getDescription() + "'"); + + if (STy->getNumContainedTypes() != 0) + GEN_ERROR("Illegal number of initializers for structure type"); + + // Check to ensure that Type is packed + if (!STy->isPacked()) + GEN_ERROR("Vector initializer to non-vector type '" + + STy->getDescription() + "'"); + + (yyval.ConstVal) = ConstantStruct::get(STy, std::vector()); + delete (yyvsp[(1) - (5)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 188: +#line 1778 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription()); + const PointerType *PTy = dyn_cast((yyvsp[(1) - (2)].TypeVal)->get()); + if (PTy == 0) + GEN_ERROR("Cannot make null pointer constant with type: '" + + (*(yyvsp[(1) - (2)].TypeVal))->getDescription() + "'"); + + (yyval.ConstVal) = ConstantPointerNull::get(PTy); + delete (yyvsp[(1) - (2)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 189: +#line 1790 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription()); + (yyval.ConstVal) = UndefValue::get((yyvsp[(1) - (2)].TypeVal)->get()); + delete (yyvsp[(1) - (2)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 190: +#line 1797 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription()); + const PointerType *Ty = dyn_cast((yyvsp[(1) - (2)].TypeVal)->get()); + if (Ty == 0) + GEN_ERROR("Global const reference must be a pointer type " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription()); + + // ConstExprs can exist in the body of a function, thus creating + // GlobalValues whenever they refer to a variable. Because we are in + // the context of a function, getExistingVal will search the functions + // symbol table instead of the module symbol table for the global symbol, + // which throws things all off. To get around this, we just tell + // getExistingVal that we are at global scope here. + // + Function *SavedCurFn = CurFun.CurrentFunction; + CurFun.CurrentFunction = 0; + + Value *V = getExistingVal(Ty, (yyvsp[(2) - (2)].ValIDVal)); + CHECK_FOR_ERROR + + CurFun.CurrentFunction = SavedCurFn; + + // If this is an initializer for a constant pointer, which is referencing a + // (currently) undefined variable, create a stub now that shall be replaced + // in the future with the right type of variable. + // + if (V == 0) { + assert(isa(Ty) && "Globals may only be used as pointers!"); + const PointerType *PT = cast(Ty); + + // First check to see if the forward references value is already created! + PerModuleInfo::GlobalRefsType::iterator I = + CurModule.GlobalRefs.find(std::make_pair(PT, (yyvsp[(2) - (2)].ValIDVal))); + + if (I != CurModule.GlobalRefs.end()) { + V = I->second; // Placeholder already exists, use it... + (yyvsp[(2) - (2)].ValIDVal).destroy(); + } else { + std::string Name; + if ((yyvsp[(2) - (2)].ValIDVal).Type == ValID::GlobalName) + Name = (yyvsp[(2) - (2)].ValIDVal).getName(); + else if ((yyvsp[(2) - (2)].ValIDVal).Type != ValID::GlobalID) + GEN_ERROR("Invalid reference to global"); + + // Create the forward referenced global. + GlobalValue *GV; + if (const FunctionType *FTy = + dyn_cast(PT->getElementType())) { + GV = Function::Create(FTy, GlobalValue::ExternalWeakLinkage, Name, + CurModule.CurrentModule); + } else { + GV = new GlobalVariable(PT->getElementType(), false, + GlobalValue::ExternalWeakLinkage, 0, + Name, CurModule.CurrentModule); + } + + // Keep track of the fact that we have a forward ref to recycle it + CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, (yyvsp[(2) - (2)].ValIDVal)), GV)); + V = GV; + } + } + + (yyval.ConstVal) = cast(V); + delete (yyvsp[(1) - (2)].TypeVal); // Free the type handle + CHECK_FOR_ERROR + ;} + break; + + case 191: +#line 1863 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription()); + if ((yyvsp[(1) - (2)].TypeVal)->get() != (yyvsp[(2) - (2)].ConstVal)->getType()) + GEN_ERROR("Mismatched types for constant expression: " + + (*(yyvsp[(1) - (2)].TypeVal))->getDescription() + " and " + (yyvsp[(2) - (2)].ConstVal)->getType()->getDescription()); + (yyval.ConstVal) = (yyvsp[(2) - (2)].ConstVal); + delete (yyvsp[(1) - (2)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 192: +#line 1873 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription()); + const Type *Ty = (yyvsp[(1) - (2)].TypeVal)->get(); + if (isa(Ty) || Ty == Type::LabelTy || isa(Ty)) + GEN_ERROR("Cannot create a null initialized value of this type"); + (yyval.ConstVal) = Constant::getNullValue(Ty); + delete (yyvsp[(1) - (2)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 193: +#line 1883 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // integral constants + if (!ConstantInt::isValueValidForType((yyvsp[(1) - (2)].PrimType), (yyvsp[(2) - (2)].SInt64Val))) + GEN_ERROR("Constant value doesn't fit in type"); + (yyval.ConstVal) = ConstantInt::get((yyvsp[(1) - (2)].PrimType), (yyvsp[(2) - (2)].SInt64Val), true); + CHECK_FOR_ERROR + ;} + break; + + case 194: +#line 1889 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // arbitrary precision integer constants + uint32_t BitWidth = cast((yyvsp[(1) - (2)].PrimType))->getBitWidth(); + if ((yyvsp[(2) - (2)].APIntVal)->getBitWidth() > BitWidth) { + GEN_ERROR("Constant value does not fit in type"); + } + (yyvsp[(2) - (2)].APIntVal)->sextOrTrunc(BitWidth); + (yyval.ConstVal) = ConstantInt::get(*(yyvsp[(2) - (2)].APIntVal)); + delete (yyvsp[(2) - (2)].APIntVal); + CHECK_FOR_ERROR + ;} + break; + + case 195: +#line 1899 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // integral constants + if (!ConstantInt::isValueValidForType((yyvsp[(1) - (2)].PrimType), (yyvsp[(2) - (2)].UInt64Val))) + GEN_ERROR("Constant value doesn't fit in type"); + (yyval.ConstVal) = ConstantInt::get((yyvsp[(1) - (2)].PrimType), (yyvsp[(2) - (2)].UInt64Val), false); + CHECK_FOR_ERROR + ;} + break; + + case 196: +#line 1905 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // arbitrary precision integer constants + uint32_t BitWidth = cast((yyvsp[(1) - (2)].PrimType))->getBitWidth(); + if ((yyvsp[(2) - (2)].APIntVal)->getBitWidth() > BitWidth) { + GEN_ERROR("Constant value does not fit in type"); + } + (yyvsp[(2) - (2)].APIntVal)->zextOrTrunc(BitWidth); + (yyval.ConstVal) = ConstantInt::get(*(yyvsp[(2) - (2)].APIntVal)); + delete (yyvsp[(2) - (2)].APIntVal); + CHECK_FOR_ERROR + ;} + break; + + case 197: +#line 1915 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Boolean constants + if (cast((yyvsp[(1) - (2)].PrimType))->getBitWidth() != 1) + GEN_ERROR("Constant true must have type i1"); + (yyval.ConstVal) = ConstantInt::getTrue(); + CHECK_FOR_ERROR + ;} + break; + + case 198: +#line 1921 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Boolean constants + if (cast((yyvsp[(1) - (2)].PrimType))->getBitWidth() != 1) + GEN_ERROR("Constant false must have type i1"); + (yyval.ConstVal) = ConstantInt::getFalse(); + CHECK_FOR_ERROR + ;} + break; + + case 199: +#line 1927 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Floating point constants + if (!ConstantFP::isValueValidForType((yyvsp[(1) - (2)].PrimType), *(yyvsp[(2) - (2)].FPVal))) + GEN_ERROR("Floating point constant invalid for type"); + // Lexer has no type info, so builds all float and double FP constants + // as double. Fix this here. Long double is done right. + if (&(yyvsp[(2) - (2)].FPVal)->getSemantics()==&APFloat::IEEEdouble && (yyvsp[(1) - (2)].PrimType)==Type::FloatTy) + (yyvsp[(2) - (2)].FPVal)->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven); + (yyval.ConstVal) = ConstantFP::get(*(yyvsp[(2) - (2)].FPVal)); + delete (yyvsp[(2) - (2)].FPVal); + CHECK_FOR_ERROR + ;} + break; + + case 200: +#line 1940 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(5) - (6)].TypeVal))->getDescription()); + Constant *Val = (yyvsp[(3) - (6)].ConstVal); + const Type *DestTy = (yyvsp[(5) - (6)].TypeVal)->get(); + if (!CastInst::castIsValid((yyvsp[(1) - (6)].CastOpVal), (yyvsp[(3) - (6)].ConstVal), DestTy)) + GEN_ERROR("invalid cast opcode for cast from '" + + Val->getType()->getDescription() + "' to '" + + DestTy->getDescription() + "'"); + (yyval.ConstVal) = ConstantExpr::getCast((yyvsp[(1) - (6)].CastOpVal), (yyvsp[(3) - (6)].ConstVal), DestTy); + delete (yyvsp[(5) - (6)].TypeVal); + ;} + break; + + case 201: +#line 1952 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!isa((yyvsp[(3) - (5)].ConstVal)->getType())) + GEN_ERROR("GetElementPtr requires a pointer operand"); + + const Type *IdxTy = + GetElementPtrInst::getIndexedType((yyvsp[(3) - (5)].ConstVal)->getType(), (yyvsp[(4) - (5)].ValueList)->begin(), (yyvsp[(4) - (5)].ValueList)->end()); + if (!IdxTy) + GEN_ERROR("Index list invalid for constant getelementptr"); + + SmallVector IdxVec; + for (unsigned i = 0, e = (yyvsp[(4) - (5)].ValueList)->size(); i != e; ++i) + if (Constant *C = dyn_cast((*(yyvsp[(4) - (5)].ValueList))[i])) + IdxVec.push_back(C); + else + GEN_ERROR("Indices to constant getelementptr must be constants"); + + delete (yyvsp[(4) - (5)].ValueList); + + (yyval.ConstVal) = ConstantExpr::getGetElementPtr((yyvsp[(3) - (5)].ConstVal), &IdxVec[0], IdxVec.size()); + CHECK_FOR_ERROR + ;} + break; + + case 202: +#line 1973 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if ((yyvsp[(3) - (8)].ConstVal)->getType() != Type::Int1Ty) + GEN_ERROR("Select condition must be of boolean type"); + if ((yyvsp[(5) - (8)].ConstVal)->getType() != (yyvsp[(7) - (8)].ConstVal)->getType()) + GEN_ERROR("Select operand types must match"); + (yyval.ConstVal) = ConstantExpr::getSelect((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal)); + CHECK_FOR_ERROR + ;} + break; + + case 203: +#line 1981 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if ((yyvsp[(3) - (6)].ConstVal)->getType() != (yyvsp[(5) - (6)].ConstVal)->getType()) + GEN_ERROR("Binary operator types must match"); + CHECK_FOR_ERROR; + (yyval.ConstVal) = ConstantExpr::get((yyvsp[(1) - (6)].BinaryOpVal), (yyvsp[(3) - (6)].ConstVal), (yyvsp[(5) - (6)].ConstVal)); + ;} + break; + + case 204: +#line 1987 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if ((yyvsp[(3) - (6)].ConstVal)->getType() != (yyvsp[(5) - (6)].ConstVal)->getType()) + GEN_ERROR("Logical operator types must match"); + if (!(yyvsp[(3) - (6)].ConstVal)->getType()->isInteger()) { + if (!isa((yyvsp[(3) - (6)].ConstVal)->getType()) || + !cast((yyvsp[(3) - (6)].ConstVal)->getType())->getElementType()->isInteger()) + GEN_ERROR("Logical operator requires integral operands"); + } + (yyval.ConstVal) = ConstantExpr::get((yyvsp[(1) - (6)].BinaryOpVal), (yyvsp[(3) - (6)].ConstVal), (yyvsp[(5) - (6)].ConstVal)); + CHECK_FOR_ERROR + ;} + break; + + case 205: +#line 1998 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if ((yyvsp[(4) - (7)].ConstVal)->getType() != (yyvsp[(6) - (7)].ConstVal)->getType()) + GEN_ERROR("icmp operand types must match"); + (yyval.ConstVal) = ConstantExpr::getICmp((yyvsp[(2) - (7)].IPredicate), (yyvsp[(4) - (7)].ConstVal), (yyvsp[(6) - (7)].ConstVal)); + ;} + break; + + case 206: +#line 2003 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if ((yyvsp[(4) - (7)].ConstVal)->getType() != (yyvsp[(6) - (7)].ConstVal)->getType()) + GEN_ERROR("fcmp operand types must match"); + (yyval.ConstVal) = ConstantExpr::getFCmp((yyvsp[(2) - (7)].FPredicate), (yyvsp[(4) - (7)].ConstVal), (yyvsp[(6) - (7)].ConstVal)); + ;} + break; + + case 207: +#line 2008 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if ((yyvsp[(4) - (7)].ConstVal)->getType() != (yyvsp[(6) - (7)].ConstVal)->getType()) + GEN_ERROR("vicmp operand types must match"); + (yyval.ConstVal) = ConstantExpr::getVICmp((yyvsp[(2) - (7)].IPredicate), (yyvsp[(4) - (7)].ConstVal), (yyvsp[(6) - (7)].ConstVal)); + ;} + break; + + case 208: +#line 2013 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if ((yyvsp[(4) - (7)].ConstVal)->getType() != (yyvsp[(6) - (7)].ConstVal)->getType()) + GEN_ERROR("vfcmp operand types must match"); + (yyval.ConstVal) = ConstantExpr::getVFCmp((yyvsp[(2) - (7)].FPredicate), (yyvsp[(4) - (7)].ConstVal), (yyvsp[(6) - (7)].ConstVal)); + ;} + break; + + case 209: +#line 2018 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!ExtractElementInst::isValidOperands((yyvsp[(3) - (6)].ConstVal), (yyvsp[(5) - (6)].ConstVal))) + GEN_ERROR("Invalid extractelement operands"); + (yyval.ConstVal) = ConstantExpr::getExtractElement((yyvsp[(3) - (6)].ConstVal), (yyvsp[(5) - (6)].ConstVal)); + CHECK_FOR_ERROR + ;} + break; + + case 210: +#line 2024 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!InsertElementInst::isValidOperands((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal))) + GEN_ERROR("Invalid insertelement operands"); + (yyval.ConstVal) = ConstantExpr::getInsertElement((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal)); + CHECK_FOR_ERROR + ;} + break; + + case 211: +#line 2030 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!ShuffleVectorInst::isValidOperands((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal))) + GEN_ERROR("Invalid shufflevector operands"); + (yyval.ConstVal) = ConstantExpr::getShuffleVector((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal)); + CHECK_FOR_ERROR + ;} + break; + + case 212: +#line 2036 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!isa((yyvsp[(3) - (5)].ConstVal)->getType()) && !isa((yyvsp[(3) - (5)].ConstVal)->getType())) + GEN_ERROR("ExtractValue requires an aggregate operand"); + + (yyval.ConstVal) = ConstantExpr::getExtractValue((yyvsp[(3) - (5)].ConstVal), &(*(yyvsp[(4) - (5)].ConstantList))[0], (yyvsp[(4) - (5)].ConstantList)->size()); + delete (yyvsp[(4) - (5)].ConstantList); + CHECK_FOR_ERROR + ;} + break; + + case 213: +#line 2044 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!isa((yyvsp[(3) - (7)].ConstVal)->getType()) && !isa((yyvsp[(3) - (7)].ConstVal)->getType())) + GEN_ERROR("InsertValue requires an aggregate operand"); + + (yyval.ConstVal) = ConstantExpr::getInsertValue((yyvsp[(3) - (7)].ConstVal), (yyvsp[(5) - (7)].ConstVal), &(*(yyvsp[(6) - (7)].ConstantList))[0], (yyvsp[(6) - (7)].ConstantList)->size()); + delete (yyvsp[(6) - (7)].ConstantList); + CHECK_FOR_ERROR + ;} + break; + + case 214: +#line 2055 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + ((yyval.ConstVector) = (yyvsp[(1) - (3)].ConstVector))->push_back((yyvsp[(3) - (3)].ConstVal)); + CHECK_FOR_ERROR + ;} + break; + + case 215: +#line 2059 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ConstVector) = new std::vector(); + (yyval.ConstVector)->push_back((yyvsp[(1) - (1)].ConstVal)); + CHECK_FOR_ERROR + ;} + break; + + case 216: +#line 2067 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.BoolVal) = false; ;} + break; + + case 217: +#line 2067 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.BoolVal) = true; ;} + break; + + case 218: +#line 2070 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.BoolVal) = true; ;} + break; + + case 219: +#line 2070 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.BoolVal) = false; ;} + break; + + case 220: +#line 2073 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + const Type* VTy = (yyvsp[(1) - (2)].TypeVal)->get(); + Value *V = getVal(VTy, (yyvsp[(2) - (2)].ValIDVal)); + CHECK_FOR_ERROR + GlobalValue* Aliasee = dyn_cast(V); + if (!Aliasee) + GEN_ERROR("Aliases can be created only to global values"); + + (yyval.ConstVal) = Aliasee; + CHECK_FOR_ERROR + delete (yyvsp[(1) - (2)].TypeVal); + ;} + break; + + case 221: +#line 2085 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + Constant *Val = (yyvsp[(3) - (6)].ConstVal); + const Type *DestTy = (yyvsp[(5) - (6)].TypeVal)->get(); + if (!CastInst::castIsValid((yyvsp[(1) - (6)].CastOpVal), (yyvsp[(3) - (6)].ConstVal), DestTy)) + GEN_ERROR("invalid cast opcode for cast from '" + + Val->getType()->getDescription() + "' to '" + + DestTy->getDescription() + "'"); + + (yyval.ConstVal) = ConstantExpr::getCast((yyvsp[(1) - (6)].CastOpVal), (yyvsp[(3) - (6)].ConstVal), DestTy); + CHECK_FOR_ERROR + delete (yyvsp[(5) - (6)].TypeVal); + ;} + break; + + case 222: +#line 2106 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ModuleVal) = ParserResult = CurModule.CurrentModule; + CurModule.ModuleDone(); + CHECK_FOR_ERROR; + ;} + break; + + case 223: +#line 2111 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ModuleVal) = ParserResult = CurModule.CurrentModule; + CurModule.ModuleDone(); + CHECK_FOR_ERROR; + ;} + break; + + case 226: +#line 2124 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { CurFun.isDeclare = false; ;} + break; + + case 227: +#line 2124 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + CurFun.FunctionDone(); + CHECK_FOR_ERROR + ;} + break; + + case 228: +#line 2128 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { CurFun.isDeclare = true; ;} + break; + + case 229: +#line 2128 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + CHECK_FOR_ERROR + ;} + break; + + case 230: +#line 2131 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + CHECK_FOR_ERROR + ;} + break; + + case 231: +#line 2134 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (3)].TypeVal))->getDescription()); + // Eagerly resolve types. This is not an optimization, this is a + // requirement that is due to the fact that we could have this: + // + // %list = type { %list * } + // %list = type { %list * } ; repeated type decl + // + // If types are not resolved eagerly, then the two types will not be + // determined to be the same type! + // + ResolveTypeTo((yyvsp[(1) - (3)].StrVal), *(yyvsp[(3) - (3)].TypeVal)); + + if (!setTypeName(*(yyvsp[(3) - (3)].TypeVal), (yyvsp[(1) - (3)].StrVal)) && !(yyvsp[(1) - (3)].StrVal)) { + CHECK_FOR_ERROR + // If this is a named type that is not a redefinition, add it to the slot + // table. + CurModule.Types.push_back(*(yyvsp[(3) - (3)].TypeVal)); + } + + delete (yyvsp[(3) - (3)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 232: +#line 2158 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + ResolveTypeTo((yyvsp[(1) - (3)].StrVal), (yyvsp[(3) - (3)].PrimType)); + + if (!setTypeName((yyvsp[(3) - (3)].PrimType), (yyvsp[(1) - (3)].StrVal)) && !(yyvsp[(1) - (3)].StrVal)) { + CHECK_FOR_ERROR + // If this is a named type that is not a redefinition, add it to the slot + // table. + CurModule.Types.push_back((yyvsp[(3) - (3)].PrimType)); + } + CHECK_FOR_ERROR + ;} + break; + + case 233: +#line 2170 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + /* "Externally Visible" Linkage */ + if ((yyvsp[(5) - (6)].ConstVal) == 0) + GEN_ERROR("Global value initializer is not a constant"); + CurGV = ParseGlobalVariable((yyvsp[(1) - (6)].StrVal), GlobalValue::ExternalLinkage, + (yyvsp[(2) - (6)].Visibility), (yyvsp[(4) - (6)].BoolVal), (yyvsp[(5) - (6)].ConstVal)->getType(), (yyvsp[(5) - (6)].ConstVal), (yyvsp[(3) - (6)].BoolVal), (yyvsp[(6) - (6)].UIntVal)); + CHECK_FOR_ERROR + ;} + break; + + case 234: +#line 2177 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + CurGV = 0; + ;} + break; + + case 235: +#line 2181 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if ((yyvsp[(6) - (7)].ConstVal) == 0) + GEN_ERROR("Global value initializer is not a constant"); + CurGV = ParseGlobalVariable((yyvsp[(1) - (7)].StrVal), (yyvsp[(2) - (7)].Linkage), (yyvsp[(3) - (7)].Visibility), (yyvsp[(5) - (7)].BoolVal), (yyvsp[(6) - (7)].ConstVal)->getType(), (yyvsp[(6) - (7)].ConstVal), (yyvsp[(4) - (7)].BoolVal), (yyvsp[(7) - (7)].UIntVal)); + CHECK_FOR_ERROR + ;} + break; + + case 236: +#line 2186 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + CurGV = 0; + ;} + break; + + case 237: +#line 2190 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(6) - (7)].TypeVal))->getDescription()); + CurGV = ParseGlobalVariable((yyvsp[(1) - (7)].StrVal), (yyvsp[(2) - (7)].Linkage), (yyvsp[(3) - (7)].Visibility), (yyvsp[(5) - (7)].BoolVal), *(yyvsp[(6) - (7)].TypeVal), 0, (yyvsp[(4) - (7)].BoolVal), (yyvsp[(7) - (7)].UIntVal)); + CHECK_FOR_ERROR + delete (yyvsp[(6) - (7)].TypeVal); + ;} + break; + + case 238: +#line 2196 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + CurGV = 0; + CHECK_FOR_ERROR + ;} + break; + + case 239: +#line 2200 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + std::string Name; + if ((yyvsp[(1) - (5)].StrVal)) { + Name = *(yyvsp[(1) - (5)].StrVal); + delete (yyvsp[(1) - (5)].StrVal); + } + if (Name.empty()) + GEN_ERROR("Alias name cannot be empty"); + + Constant* Aliasee = (yyvsp[(5) - (5)].ConstVal); + if (Aliasee == 0) + GEN_ERROR(std::string("Invalid aliasee for alias: ") + Name); + + GlobalAlias* GA = new GlobalAlias(Aliasee->getType(), (yyvsp[(4) - (5)].Linkage), Name, Aliasee, + CurModule.CurrentModule); + GA->setVisibility((yyvsp[(2) - (5)].Visibility)); + InsertValue(GA, CurModule.Values); + + + // If there was a forward reference of this alias, resolve it now. + + ValID ID; + if (!Name.empty()) + ID = ValID::createGlobalName(Name); + else + ID = ValID::createGlobalID(CurModule.Values.size()-1); + + if (GlobalValue *FWGV = + CurModule.GetForwardRefForGlobal(GA->getType(), ID)) { + // Replace uses of the fwdref with the actual alias. + FWGV->replaceAllUsesWith(GA); + if (GlobalVariable *GV = dyn_cast(FWGV)) + GV->eraseFromParent(); + else + cast(FWGV)->eraseFromParent(); + } + ID.destroy(); + + CHECK_FOR_ERROR + ;} + break; + + case 240: +#line 2240 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + CHECK_FOR_ERROR + ;} + break; + + case 241: +#line 2243 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + CHECK_FOR_ERROR + ;} + break; + + case 242: +#line 2249 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm(); + if (AsmSoFar.empty()) + CurModule.CurrentModule->setModuleInlineAsm(*(yyvsp[(1) - (1)].StrVal)); + else + CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+*(yyvsp[(1) - (1)].StrVal)); + delete (yyvsp[(1) - (1)].StrVal); + CHECK_FOR_ERROR +;} + break; + + case 243: +#line 2259 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + CurModule.CurrentModule->setTargetTriple(*(yyvsp[(3) - (3)].StrVal)); + delete (yyvsp[(3) - (3)].StrVal); + ;} + break; + + case 244: +#line 2263 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + CurModule.CurrentModule->setDataLayout(*(yyvsp[(3) - (3)].StrVal)); + delete (yyvsp[(3) - (3)].StrVal); + ;} + break; + + case 246: +#line 2270 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + CurModule.CurrentModule->addLibrary(*(yyvsp[(3) - (3)].StrVal)); + delete (yyvsp[(3) - (3)].StrVal); + CHECK_FOR_ERROR + ;} + break; + + case 247: +#line 2275 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + CurModule.CurrentModule->addLibrary(*(yyvsp[(1) - (1)].StrVal)); + delete (yyvsp[(1) - (1)].StrVal); + CHECK_FOR_ERROR + ;} + break; + + case 248: +#line 2280 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + CHECK_FOR_ERROR + ;} + break; + + case 249: +#line 2289 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (5)].TypeVal))->getDescription()); + if (!(*(yyvsp[(3) - (5)].TypeVal))->isFirstClassType()) + GEN_ERROR("Argument types must be first-class"); + ArgListEntry E; E.Attrs = (yyvsp[(4) - (5)].Attributes); E.Ty = (yyvsp[(3) - (5)].TypeVal); E.Name = (yyvsp[(5) - (5)].StrVal); + (yyval.ArgList) = (yyvsp[(1) - (5)].ArgList); + (yyvsp[(1) - (5)].ArgList)->push_back(E); + CHECK_FOR_ERROR + ;} + break; + + case 250: +#line 2299 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription()); + if (!(*(yyvsp[(1) - (3)].TypeVal))->isFirstClassType()) + GEN_ERROR("Argument types must be first-class"); + ArgListEntry E; E.Attrs = (yyvsp[(2) - (3)].Attributes); E.Ty = (yyvsp[(1) - (3)].TypeVal); E.Name = (yyvsp[(3) - (3)].StrVal); + (yyval.ArgList) = new ArgListType; + (yyval.ArgList)->push_back(E); + CHECK_FOR_ERROR + ;} + break; + + case 251: +#line 2310 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ArgList) = (yyvsp[(1) - (1)].ArgList); + CHECK_FOR_ERROR + ;} + break; + + case 252: +#line 2314 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ArgList) = (yyvsp[(1) - (3)].ArgList); + struct ArgListEntry E; + E.Ty = new PATypeHolder(Type::VoidTy); + E.Name = 0; + E.Attrs = Attribute::None; + (yyval.ArgList)->push_back(E); + CHECK_FOR_ERROR + ;} + break; + + case 253: +#line 2323 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ArgList) = new ArgListType; + struct ArgListEntry E; + E.Ty = new PATypeHolder(Type::VoidTy); + E.Name = 0; + E.Attrs = Attribute::None; + (yyval.ArgList)->push_back(E); + CHECK_FOR_ERROR + ;} + break; + + case 254: +#line 2332 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ArgList) = 0; + CHECK_FOR_ERROR + ;} + break; + + case 255: +#line 2338 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + std::string FunctionName(*(yyvsp[(4) - (11)].StrVal)); + delete (yyvsp[(4) - (11)].StrVal); // Free strdup'd memory! + + // Check the function result for abstractness if this is a define. We should + // have no abstract types at this point + if (!CurFun.isDeclare && CurModule.TypeIsUnresolved((yyvsp[(3) - (11)].TypeVal))) + GEN_ERROR("Reference to abstract result: "+ (yyvsp[(3) - (11)].TypeVal)->get()->getDescription()); + + if (!FunctionType::isValidReturnType(*(yyvsp[(3) - (11)].TypeVal))) + GEN_ERROR("Invalid result type for LLVM function"); + + std::vector ParamTypeList; + SmallVector Attrs; + //FIXME : In 3.0, stop accepting zext, sext and inreg as optional function + //attributes. + Attributes RetAttrs = (yyvsp[(2) - (11)].Attributes); + if ((yyvsp[(8) - (11)].Attributes) != Attribute::None) { + if ((yyvsp[(8) - (11)].Attributes) & Attribute::ZExt) { + RetAttrs = RetAttrs | Attribute::ZExt; + (yyvsp[(8) - (11)].Attributes) = (yyvsp[(8) - (11)].Attributes) ^ Attribute::ZExt; + } + if ((yyvsp[(8) - (11)].Attributes) & Attribute::SExt) { + RetAttrs = RetAttrs | Attribute::SExt; + (yyvsp[(8) - (11)].Attributes) = (yyvsp[(8) - (11)].Attributes) ^ Attribute::SExt; + } + if ((yyvsp[(8) - (11)].Attributes) & Attribute::InReg) { + RetAttrs = RetAttrs | Attribute::InReg; + (yyvsp[(8) - (11)].Attributes) = (yyvsp[(8) - (11)].Attributes) ^ Attribute::InReg; + } + } + if (RetAttrs != Attribute::None) + Attrs.push_back(AttributeWithIndex::get(0, RetAttrs)); + if ((yyvsp[(6) - (11)].ArgList)) { // If there are arguments... + unsigned index = 1; + for (ArgListType::iterator I = (yyvsp[(6) - (11)].ArgList)->begin(); I != (yyvsp[(6) - (11)].ArgList)->end(); ++I, ++index) { + const Type* Ty = I->Ty->get(); + if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(I->Ty)) + GEN_ERROR("Reference to abstract argument: " + Ty->getDescription()); + ParamTypeList.push_back(Ty); + if (Ty != Type::VoidTy && I->Attrs != Attribute::None) + Attrs.push_back(AttributeWithIndex::get(index, I->Attrs)); + } + } + if ((yyvsp[(8) - (11)].Attributes) != Attribute::None) + Attrs.push_back(AttributeWithIndex::get(~0, (yyvsp[(8) - (11)].Attributes))); + + bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy; + if (isVarArg) ParamTypeList.pop_back(); + + AttrListPtr PAL; + if (!Attrs.empty()) + PAL = AttrListPtr::get(Attrs.begin(), Attrs.end()); + + FunctionType *FT = FunctionType::get(*(yyvsp[(3) - (11)].TypeVal), ParamTypeList, isVarArg); + const PointerType *PFT = PointerType::getUnqual(FT); + delete (yyvsp[(3) - (11)].TypeVal); + + ValID ID; + if (!FunctionName.empty()) { + ID = ValID::createGlobalName((char*)FunctionName.c_str()); + } else { + ID = ValID::createGlobalID(CurModule.Values.size()); + } + + Function *Fn = 0; + // See if this function was forward referenced. If so, recycle the object. + if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) { + // Move the function to the end of the list, from whereever it was + // previously inserted. + Fn = cast(FWRef); + assert(Fn->getAttributes().isEmpty() && + "Forward reference has parameter attributes!"); + CurModule.CurrentModule->getFunctionList().remove(Fn); + CurModule.CurrentModule->getFunctionList().push_back(Fn); + } else if (!FunctionName.empty() && // Merge with an earlier prototype? + (Fn = CurModule.CurrentModule->getFunction(FunctionName))) { + if (Fn->getFunctionType() != FT ) { + // The existing function doesn't have the same type. This is an overload + // error. + GEN_ERROR("Overload of function '" + FunctionName + "' not permitted."); + } else if (Fn->getAttributes() != PAL) { + // The existing function doesn't have the same parameter attributes. + // This is an overload error. + GEN_ERROR("Overload of function '" + FunctionName + "' not permitted."); + } else if (!CurFun.isDeclare && !Fn->isDeclaration()) { + // Neither the existing or the current function is a declaration and they + // have the same name and same type. Clearly this is a redefinition. + GEN_ERROR("Redefinition of function '" + FunctionName + "'"); + } else if (Fn->isDeclaration()) { + // Make sure to strip off any argument names so we can't get conflicts. + for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end(); + AI != AE; ++AI) + AI->setName(""); + } + } else { // Not already defined? + Fn = Function::Create(FT, GlobalValue::ExternalWeakLinkage, FunctionName, + CurModule.CurrentModule); + InsertValue(Fn, CurModule.Values); + } + + ID.destroy(); + CurFun.FunctionStart(Fn); + + if (CurFun.isDeclare) { + // If we have declaration, always overwrite linkage. This will allow us to + // correctly handle cases, when pointer to function is passed as argument to + // another function. + Fn->setLinkage(CurFun.Linkage); + Fn->setVisibility(CurFun.Visibility); + } + Fn->setCallingConv((yyvsp[(1) - (11)].UIntVal)); + Fn->setAttributes(PAL); + Fn->setAlignment((yyvsp[(10) - (11)].UIntVal)); + if ((yyvsp[(9) - (11)].StrVal)) { + Fn->setSection(*(yyvsp[(9) - (11)].StrVal)); + delete (yyvsp[(9) - (11)].StrVal); + } + if ((yyvsp[(11) - (11)].StrVal)) { + Fn->setGC((yyvsp[(11) - (11)].StrVal)->c_str()); + delete (yyvsp[(11) - (11)].StrVal); + } + + // Add all of the arguments we parsed to the function... + if ((yyvsp[(6) - (11)].ArgList)) { // Is null if empty... + if (isVarArg) { // Nuke the last entry + assert((yyvsp[(6) - (11)].ArgList)->back().Ty->get() == Type::VoidTy && (yyvsp[(6) - (11)].ArgList)->back().Name == 0 && + "Not a varargs marker!"); + delete (yyvsp[(6) - (11)].ArgList)->back().Ty; + (yyvsp[(6) - (11)].ArgList)->pop_back(); // Delete the last entry + } + Function::arg_iterator ArgIt = Fn->arg_begin(); + Function::arg_iterator ArgEnd = Fn->arg_end(); + unsigned Idx = 1; + for (ArgListType::iterator I = (yyvsp[(6) - (11)].ArgList)->begin(); + I != (yyvsp[(6) - (11)].ArgList)->end() && ArgIt != ArgEnd; ++I, ++ArgIt) { + delete I->Ty; // Delete the typeholder... + setValueName(ArgIt, I->Name); // Insert arg into symtab... + CHECK_FOR_ERROR + InsertValue(ArgIt); + Idx++; + } + + delete (yyvsp[(6) - (11)].ArgList); // We're now done with the argument list + } + CHECK_FOR_ERROR +;} + break; + + case 258: +#line 2488 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.FunctionVal) = CurFun.CurrentFunction; + + // Make sure that we keep track of the linkage type even if there was a + // previous "declare". + (yyval.FunctionVal)->setLinkage((yyvsp[(1) - (4)].Linkage)); + (yyval.FunctionVal)->setVisibility((yyvsp[(2) - (4)].Visibility)); +;} + break; + + case 261: +#line 2499 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.FunctionVal) = (yyvsp[(1) - (2)].FunctionVal); + CHECK_FOR_ERROR +;} + break; + + case 262: +#line 2504 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + CurFun.CurrentFunction->setLinkage((yyvsp[(1) - (3)].Linkage)); + CurFun.CurrentFunction->setVisibility((yyvsp[(2) - (3)].Visibility)); + (yyval.FunctionVal) = CurFun.CurrentFunction; + CurFun.FunctionDone(); + CHECK_FOR_ERROR + ;} + break; + + case 263: +#line 2516 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.BoolVal) = false; + CHECK_FOR_ERROR + ;} + break; + + case 264: +#line 2520 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.BoolVal) = true; + CHECK_FOR_ERROR + ;} + break; + + case 265: +#line 2525 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // A reference to a direct constant + (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].SInt64Val)); + CHECK_FOR_ERROR + ;} + break; + + case 266: +#line 2529 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].UInt64Val)); + CHECK_FOR_ERROR + ;} + break; + + case 267: +#line 2533 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // arbitrary precision integer constants + (yyval.ValIDVal) = ValID::create(*(yyvsp[(1) - (1)].APIntVal), true); + delete (yyvsp[(1) - (1)].APIntVal); + CHECK_FOR_ERROR + ;} + break; + + case 268: +#line 2538 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // arbitrary precision integer constants + (yyval.ValIDVal) = ValID::create(*(yyvsp[(1) - (1)].APIntVal), false); + delete (yyvsp[(1) - (1)].APIntVal); + CHECK_FOR_ERROR + ;} + break; + + case 269: +#line 2543 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Perhaps it's an FP constant? + (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].FPVal)); + CHECK_FOR_ERROR + ;} + break; + + case 270: +#line 2547 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ValIDVal) = ValID::create(ConstantInt::getTrue()); + CHECK_FOR_ERROR + ;} + break; + + case 271: +#line 2551 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ValIDVal) = ValID::create(ConstantInt::getFalse()); + CHECK_FOR_ERROR + ;} + break; + + case 272: +#line 2555 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ValIDVal) = ValID::createNull(); + CHECK_FOR_ERROR + ;} + break; + + case 273: +#line 2559 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ValIDVal) = ValID::createUndef(); + CHECK_FOR_ERROR + ;} + break; + + case 274: +#line 2563 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // A vector zero constant. + (yyval.ValIDVal) = ValID::createZeroInit(); + CHECK_FOR_ERROR + ;} + break; + + case 275: +#line 2567 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Nonempty unsized packed vector + const Type *ETy = (*(yyvsp[(2) - (3)].ConstVector))[0]->getType(); + unsigned NumElements = (yyvsp[(2) - (3)].ConstVector)->size(); + + if (!ETy->isInteger() && !ETy->isFloatingPoint()) + GEN_ERROR("Invalid vector element type: " + ETy->getDescription()); + + VectorType* pt = VectorType::get(ETy, NumElements); + PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(pt)); + + // Verify all elements are correct type! + for (unsigned i = 0; i < (yyvsp[(2) - (3)].ConstVector)->size(); i++) { + if (ETy != (*(yyvsp[(2) - (3)].ConstVector))[i]->getType()) + GEN_ERROR("Element #" + utostr(i) + " is not of type '" + + ETy->getDescription() +"' as required!\nIt is of type '" + + (*(yyvsp[(2) - (3)].ConstVector))[i]->getType()->getDescription() + "'."); + } + + (yyval.ValIDVal) = ValID::create(ConstantVector::get(pt, *(yyvsp[(2) - (3)].ConstVector))); + delete PTy; delete (yyvsp[(2) - (3)].ConstVector); + CHECK_FOR_ERROR + ;} + break; + + case 276: +#line 2589 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Nonempty unsized arr + const Type *ETy = (*(yyvsp[(2) - (3)].ConstVector))[0]->getType(); + uint64_t NumElements = (yyvsp[(2) - (3)].ConstVector)->size(); + + if (!ETy->isFirstClassType()) + GEN_ERROR("Invalid array element type: " + ETy->getDescription()); + + ArrayType *ATy = ArrayType::get(ETy, NumElements); + PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(ATy)); + + // Verify all elements are correct type! + for (unsigned i = 0; i < (yyvsp[(2) - (3)].ConstVector)->size(); i++) { + if (ETy != (*(yyvsp[(2) - (3)].ConstVector))[i]->getType()) + GEN_ERROR("Element #" + utostr(i) + " is not of type '" + + ETy->getDescription() +"' as required!\nIt is of type '"+ + (*(yyvsp[(2) - (3)].ConstVector))[i]->getType()->getDescription() + "'."); + } + + (yyval.ValIDVal) = ValID::create(ConstantArray::get(ATy, *(yyvsp[(2) - (3)].ConstVector))); + delete PTy; delete (yyvsp[(2) - (3)].ConstVector); + CHECK_FOR_ERROR + ;} + break; + + case 277: +#line 2611 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + // Use undef instead of an array because it's inconvenient to determine + // the element type at this point, there being no elements to examine. + (yyval.ValIDVal) = ValID::createUndef(); + CHECK_FOR_ERROR + ;} + break; + + case 278: +#line 2617 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + uint64_t NumElements = (yyvsp[(2) - (2)].StrVal)->length(); + const Type *ETy = Type::Int8Ty; + + ArrayType *ATy = ArrayType::get(ETy, NumElements); + + std::vector Vals; + for (unsigned i = 0; i < (yyvsp[(2) - (2)].StrVal)->length(); ++i) + Vals.push_back(ConstantInt::get(ETy, (*(yyvsp[(2) - (2)].StrVal))[i])); + delete (yyvsp[(2) - (2)].StrVal); + (yyval.ValIDVal) = ValID::create(ConstantArray::get(ATy, Vals)); + CHECK_FOR_ERROR + ;} + break; + + case 279: +#line 2630 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + std::vector Elements((yyvsp[(2) - (3)].ConstVector)->size()); + for (unsigned i = 0, e = (yyvsp[(2) - (3)].ConstVector)->size(); i != e; ++i) + Elements[i] = (*(yyvsp[(2) - (3)].ConstVector))[i]->getType(); + + const StructType *STy = StructType::get(Elements); + PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(STy)); + + (yyval.ValIDVal) = ValID::create(ConstantStruct::get(STy, *(yyvsp[(2) - (3)].ConstVector))); + delete PTy; delete (yyvsp[(2) - (3)].ConstVector); + CHECK_FOR_ERROR + ;} + break; + + case 280: +#line 2642 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + const StructType *STy = StructType::get(std::vector()); + (yyval.ValIDVal) = ValID::create(ConstantStruct::get(STy, std::vector())); + CHECK_FOR_ERROR + ;} + break; + + case 281: +#line 2647 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + std::vector Elements((yyvsp[(3) - (5)].ConstVector)->size()); + for (unsigned i = 0, e = (yyvsp[(3) - (5)].ConstVector)->size(); i != e; ++i) + Elements[i] = (*(yyvsp[(3) - (5)].ConstVector))[i]->getType(); + + const StructType *STy = StructType::get(Elements, /*isPacked=*/true); + PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(STy)); + + (yyval.ValIDVal) = ValID::create(ConstantStruct::get(STy, *(yyvsp[(3) - (5)].ConstVector))); + delete PTy; delete (yyvsp[(3) - (5)].ConstVector); + CHECK_FOR_ERROR + ;} + break; + + case 282: +#line 2659 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + const StructType *STy = StructType::get(std::vector(), + /*isPacked=*/true); + (yyval.ValIDVal) = ValID::create(ConstantStruct::get(STy, std::vector())); + CHECK_FOR_ERROR + ;} + break; + + case 283: +#line 2665 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].ConstVal)); + CHECK_FOR_ERROR + ;} + break; + + case 284: +#line 2669 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ValIDVal) = ValID::createInlineAsm(*(yyvsp[(3) - (5)].StrVal), *(yyvsp[(5) - (5)].StrVal), (yyvsp[(2) - (5)].BoolVal)); + delete (yyvsp[(3) - (5)].StrVal); + delete (yyvsp[(5) - (5)].StrVal); + CHECK_FOR_ERROR + ;} + break; + + case 285: +#line 2679 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Is it an integer reference...? + (yyval.ValIDVal) = ValID::createLocalID((yyvsp[(1) - (1)].UIntVal)); + CHECK_FOR_ERROR + ;} + break; + + case 286: +#line 2683 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ValIDVal) = ValID::createGlobalID((yyvsp[(1) - (1)].UIntVal)); + CHECK_FOR_ERROR + ;} + break; + + case 287: +#line 2687 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Is it a named reference...? + (yyval.ValIDVal) = ValID::createLocalName(*(yyvsp[(1) - (1)].StrVal)); + delete (yyvsp[(1) - (1)].StrVal); + CHECK_FOR_ERROR + ;} + break; + + case 288: +#line 2692 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Is it a named reference...? + (yyval.ValIDVal) = ValID::createGlobalName(*(yyvsp[(1) - (1)].StrVal)); + delete (yyvsp[(1) - (1)].StrVal); + CHECK_FOR_ERROR + ;} + break; + + case 291: +#line 2705 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription()); + (yyval.ValueVal) = getVal(*(yyvsp[(1) - (2)].TypeVal), (yyvsp[(2) - (2)].ValIDVal)); + delete (yyvsp[(1) - (2)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 292: +#line 2714 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ValueList) = new std::vector(); + (yyval.ValueList)->push_back((yyvsp[(1) - (1)].ValueVal)); + CHECK_FOR_ERROR + ;} + break; + + case 293: +#line 2719 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + ((yyval.ValueList)=(yyvsp[(1) - (3)].ValueList))->push_back((yyvsp[(3) - (3)].ValueVal)); + CHECK_FOR_ERROR + ;} + break; + + case 294: +#line 2724 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.FunctionVal) = (yyvsp[(1) - (2)].FunctionVal); + CHECK_FOR_ERROR + ;} + break; + + case 295: +#line 2728 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Do not allow functions with 0 basic blocks + (yyval.FunctionVal) = (yyvsp[(1) - (2)].FunctionVal); + CHECK_FOR_ERROR + ;} + break; + + case 296: +#line 2737 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + setValueName((yyvsp[(3) - (3)].TermInstVal), (yyvsp[(2) - (3)].StrVal)); + CHECK_FOR_ERROR + InsertValue((yyvsp[(3) - (3)].TermInstVal)); + (yyvsp[(1) - (3)].BasicBlockVal)->getInstList().push_back((yyvsp[(3) - (3)].TermInstVal)); + (yyval.BasicBlockVal) = (yyvsp[(1) - (3)].BasicBlockVal); + CHECK_FOR_ERROR + ;} + break; + + case 297: +#line 2746 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + CHECK_FOR_ERROR + int ValNum = InsertValue((yyvsp[(3) - (3)].TermInstVal)); + if (ValNum != (int)(yyvsp[(2) - (3)].UIntVal)) + GEN_ERROR("Result value number %" + utostr((yyvsp[(2) - (3)].UIntVal)) + + " is incorrect, expected %" + utostr((unsigned)ValNum)); + + (yyvsp[(1) - (3)].BasicBlockVal)->getInstList().push_back((yyvsp[(3) - (3)].TermInstVal)); + (yyval.BasicBlockVal) = (yyvsp[(1) - (3)].BasicBlockVal); + CHECK_FOR_ERROR +;} + break; + + case 298: +#line 2759 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (CastInst *CI1 = dyn_cast((yyvsp[(2) - (2)].InstVal))) + if (CastInst *CI2 = dyn_cast(CI1->getOperand(0))) + if (CI2->getParent() == 0) + (yyvsp[(1) - (2)].BasicBlockVal)->getInstList().push_back(CI2); + (yyvsp[(1) - (2)].BasicBlockVal)->getInstList().push_back((yyvsp[(2) - (2)].InstVal)); + (yyval.BasicBlockVal) = (yyvsp[(1) - (2)].BasicBlockVal); + CHECK_FOR_ERROR + ;} + break; + + case 299: +#line 2768 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Empty space between instruction lists + (yyval.BasicBlockVal) = defineBBVal(ValID::createLocalID(CurFun.NextValNum)); + CHECK_FOR_ERROR + ;} + break; + + case 300: +#line 2772 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Labelled (named) basic block + (yyval.BasicBlockVal) = defineBBVal(ValID::createLocalName(*(yyvsp[(1) - (1)].StrVal))); + delete (yyvsp[(1) - (1)].StrVal); + CHECK_FOR_ERROR + + ;} + break; + + case 301: +#line 2780 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Return with a result... + ValueList &VL = *(yyvsp[(2) - (2)].ValueList); + assert(!VL.empty() && "Invalid ret operands!"); + const Type *ReturnType = CurFun.CurrentFunction->getReturnType(); + if (VL.size() > 1 || + (isa(ReturnType) && + (VL.empty() || VL[0]->getType() != ReturnType))) { + Value *RV = UndefValue::get(ReturnType); + for (unsigned i = 0, e = VL.size(); i != e; ++i) { + Instruction *I = InsertValueInst::Create(RV, VL[i], i, "mrv"); + ((yyvsp[(-1) - (2)].BasicBlockVal))->getInstList().push_back(I); + RV = I; + } + (yyval.TermInstVal) = ReturnInst::Create(RV); + } else { + (yyval.TermInstVal) = ReturnInst::Create(VL[0]); + } + delete (yyvsp[(2) - (2)].ValueList); + CHECK_FOR_ERROR + ;} + break; + + case 302: +#line 2800 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Return with no result... + (yyval.TermInstVal) = ReturnInst::Create(); + CHECK_FOR_ERROR + ;} + break; + + case 303: +#line 2804 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Unconditional Branch... + BasicBlock* tmpBB = getBBVal((yyvsp[(3) - (3)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.TermInstVal) = BranchInst::Create(tmpBB); + ;} + break; + + case 304: +#line 2809 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (cast((yyvsp[(2) - (9)].PrimType))->getBitWidth() != 1) + GEN_ERROR("Branch condition must have type i1"); + BasicBlock* tmpBBA = getBBVal((yyvsp[(6) - (9)].ValIDVal)); + CHECK_FOR_ERROR + BasicBlock* tmpBBB = getBBVal((yyvsp[(9) - (9)].ValIDVal)); + CHECK_FOR_ERROR + Value* tmpVal = getVal(Type::Int1Ty, (yyvsp[(3) - (9)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.TermInstVal) = BranchInst::Create(tmpBBA, tmpBBB, tmpVal); + ;} + break; + + case 305: +#line 2820 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + Value* tmpVal = getVal((yyvsp[(2) - (9)].PrimType), (yyvsp[(3) - (9)].ValIDVal)); + CHECK_FOR_ERROR + BasicBlock* tmpBB = getBBVal((yyvsp[(6) - (9)].ValIDVal)); + CHECK_FOR_ERROR + SwitchInst *S = SwitchInst::Create(tmpVal, tmpBB, (yyvsp[(8) - (9)].JumpTable)->size()); + (yyval.TermInstVal) = S; + + std::vector >::iterator I = (yyvsp[(8) - (9)].JumpTable)->begin(), + E = (yyvsp[(8) - (9)].JumpTable)->end(); + for (; I != E; ++I) { + if (ConstantInt *CI = dyn_cast(I->first)) + S->addCase(CI, I->second); + else + GEN_ERROR("Switch case is constant, but not a simple integer"); + } + delete (yyvsp[(8) - (9)].JumpTable); + CHECK_FOR_ERROR + ;} + break; + + case 306: +#line 2839 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + Value* tmpVal = getVal((yyvsp[(2) - (8)].PrimType), (yyvsp[(3) - (8)].ValIDVal)); + CHECK_FOR_ERROR + BasicBlock* tmpBB = getBBVal((yyvsp[(6) - (8)].ValIDVal)); + CHECK_FOR_ERROR + SwitchInst *S = SwitchInst::Create(tmpVal, tmpBB, 0); + (yyval.TermInstVal) = S; + CHECK_FOR_ERROR + ;} + break; + + case 307: +#line 2849 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + + // Handle the short syntax + const PointerType *PFTy = 0; + const FunctionType *Ty = 0; + if (!(PFTy = dyn_cast((yyvsp[(4) - (15)].TypeVal)->get())) || + !(Ty = dyn_cast(PFTy->getElementType()))) { + // Pull out the types of all of the arguments... + std::vector ParamTypes; + ParamList::iterator I = (yyvsp[(7) - (15)].ParamList)->begin(), E = (yyvsp[(7) - (15)].ParamList)->end(); + for (; I != E; ++I) { + const Type *Ty = I->Val->getType(); + if (Ty == Type::VoidTy) + GEN_ERROR("Short call syntax cannot be used with varargs"); + ParamTypes.push_back(Ty); + } + + if (!FunctionType::isValidReturnType(*(yyvsp[(4) - (15)].TypeVal))) + GEN_ERROR("Invalid result type for LLVM function"); + + Ty = FunctionType::get((yyvsp[(4) - (15)].TypeVal)->get(), ParamTypes, false); + PFTy = PointerType::getUnqual(Ty); + } + + delete (yyvsp[(4) - (15)].TypeVal); + + Value *V = getVal(PFTy, (yyvsp[(5) - (15)].ValIDVal)); // Get the function we're calling... + CHECK_FOR_ERROR + BasicBlock *Normal = getBBVal((yyvsp[(12) - (15)].ValIDVal)); + CHECK_FOR_ERROR + BasicBlock *Except = getBBVal((yyvsp[(15) - (15)].ValIDVal)); + CHECK_FOR_ERROR + + SmallVector Attrs; + //FIXME : In 3.0, stop accepting zext, sext and inreg as optional function + //attributes. + Attributes RetAttrs = (yyvsp[(3) - (15)].Attributes); + if ((yyvsp[(9) - (15)].Attributes) != Attribute::None) { + if ((yyvsp[(9) - (15)].Attributes) & Attribute::ZExt) { + RetAttrs = RetAttrs | Attribute::ZExt; + (yyvsp[(9) - (15)].Attributes) = (yyvsp[(9) - (15)].Attributes) ^ Attribute::ZExt; + } + if ((yyvsp[(9) - (15)].Attributes) & Attribute::SExt) { + RetAttrs = RetAttrs | Attribute::SExt; + (yyvsp[(9) - (15)].Attributes) = (yyvsp[(9) - (15)].Attributes) ^ Attribute::SExt; + } + if ((yyvsp[(9) - (15)].Attributes) & Attribute::InReg) { + RetAttrs = RetAttrs | Attribute::InReg; + (yyvsp[(9) - (15)].Attributes) = (yyvsp[(9) - (15)].Attributes) ^ Attribute::InReg; + } + } + if (RetAttrs != Attribute::None) + Attrs.push_back(AttributeWithIndex::get(0, RetAttrs)); + + // Check the arguments + ValueList Args; + if ((yyvsp[(7) - (15)].ParamList)->empty()) { // Has no arguments? + // Make sure no arguments is a good thing! + if (Ty->getNumParams() != 0) + GEN_ERROR("No arguments passed to a function that " + "expects arguments"); + } else { // Has arguments? + // Loop through FunctionType's arguments and ensure they are specified + // correctly! + FunctionType::param_iterator I = Ty->param_begin(); + FunctionType::param_iterator E = Ty->param_end(); + ParamList::iterator ArgI = (yyvsp[(7) - (15)].ParamList)->begin(), ArgE = (yyvsp[(7) - (15)].ParamList)->end(); + unsigned index = 1; + + for (; ArgI != ArgE && I != E; ++ArgI, ++I, ++index) { + if (ArgI->Val->getType() != *I) + GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" + + (*I)->getDescription() + "'"); + Args.push_back(ArgI->Val); + if (ArgI->Attrs != Attribute::None) + Attrs.push_back(AttributeWithIndex::get(index, ArgI->Attrs)); + } + + if (Ty->isVarArg()) { + if (I == E) + for (; ArgI != ArgE; ++ArgI, ++index) { + Args.push_back(ArgI->Val); // push the remaining varargs + if (ArgI->Attrs != Attribute::None) + Attrs.push_back(AttributeWithIndex::get(index, ArgI->Attrs)); + } + } else if (I != E || ArgI != ArgE) + GEN_ERROR("Invalid number of parameters detected"); + } + if ((yyvsp[(9) - (15)].Attributes) != Attribute::None) + Attrs.push_back(AttributeWithIndex::get(~0, (yyvsp[(9) - (15)].Attributes))); + AttrListPtr PAL; + if (!Attrs.empty()) + PAL = AttrListPtr::get(Attrs.begin(), Attrs.end()); + + // Create the InvokeInst + InvokeInst *II = InvokeInst::Create(V, Normal, Except, + Args.begin(), Args.end()); + II->setCallingConv((yyvsp[(2) - (15)].UIntVal)); + II->setAttributes(PAL); + (yyval.TermInstVal) = II; + delete (yyvsp[(7) - (15)].ParamList); + CHECK_FOR_ERROR + ;} + break; + + case 308: +#line 2952 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.TermInstVal) = new UnwindInst(); + CHECK_FOR_ERROR + ;} + break; + + case 309: +#line 2956 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.TermInstVal) = new UnreachableInst(); + CHECK_FOR_ERROR + ;} + break; + + case 310: +#line 2963 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.JumpTable) = (yyvsp[(1) - (6)].JumpTable); + Constant *V = cast(getExistingVal((yyvsp[(2) - (6)].PrimType), (yyvsp[(3) - (6)].ValIDVal))); + CHECK_FOR_ERROR + if (V == 0) + GEN_ERROR("May only switch on a constant pool value"); + + BasicBlock* tmpBB = getBBVal((yyvsp[(6) - (6)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB)); + ;} + break; + + case 311: +#line 2974 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.JumpTable) = new std::vector >(); + Constant *V = cast(getExistingVal((yyvsp[(1) - (5)].PrimType), (yyvsp[(2) - (5)].ValIDVal))); + CHECK_FOR_ERROR + + if (V == 0) + GEN_ERROR("May only switch on a constant pool value"); + + BasicBlock* tmpBB = getBBVal((yyvsp[(5) - (5)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB)); + ;} + break; + + case 312: +#line 2987 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + // Is this definition named?? if so, assign the name... + setValueName((yyvsp[(2) - (2)].InstVal), (yyvsp[(1) - (2)].StrVal)); + CHECK_FOR_ERROR + InsertValue((yyvsp[(2) - (2)].InstVal)); + (yyval.InstVal) = (yyvsp[(2) - (2)].InstVal); + CHECK_FOR_ERROR + ;} + break; + + case 313: +#line 2996 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + CHECK_FOR_ERROR + int ValNum = InsertValue((yyvsp[(2) - (2)].InstVal)); + + if (ValNum != (int)(yyvsp[(1) - (2)].UIntVal)) + GEN_ERROR("Result value number %" + utostr((yyvsp[(1) - (2)].UIntVal)) + + " is incorrect, expected %" + utostr((unsigned)ValNum)); + + (yyval.InstVal) = (yyvsp[(2) - (2)].InstVal); + CHECK_FOR_ERROR + ;} + break; + + case 314: +#line 3009 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { // Used for PHI nodes + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (6)].TypeVal))->getDescription()); + (yyval.PHIList) = new std::list >(); + Value* tmpVal = getVal(*(yyvsp[(1) - (6)].TypeVal), (yyvsp[(3) - (6)].ValIDVal)); + CHECK_FOR_ERROR + BasicBlock* tmpBB = getBBVal((yyvsp[(5) - (6)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.PHIList)->push_back(std::make_pair(tmpVal, tmpBB)); + delete (yyvsp[(1) - (6)].TypeVal); + ;} + break; + + case 315: +#line 3020 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.PHIList) = (yyvsp[(1) - (7)].PHIList); + Value* tmpVal = getVal((yyvsp[(1) - (7)].PHIList)->front().first->getType(), (yyvsp[(4) - (7)].ValIDVal)); + CHECK_FOR_ERROR + BasicBlock* tmpBB = getBBVal((yyvsp[(6) - (7)].ValIDVal)); + CHECK_FOR_ERROR + (yyvsp[(1) - (7)].PHIList)->push_back(std::make_pair(tmpVal, tmpBB)); + ;} + break; + + case 316: +#line 3030 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + // FIXME: Remove trailing OptAttributes in LLVM 3.0, it was a mistake in 2.0 + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (4)].TypeVal))->getDescription()); + // Used for call and invoke instructions + (yyval.ParamList) = new ParamList(); + ParamListEntry E; E.Attrs = (yyvsp[(2) - (4)].Attributes) | (yyvsp[(4) - (4)].Attributes); E.Val = getVal((yyvsp[(1) - (4)].TypeVal)->get(), (yyvsp[(3) - (4)].ValIDVal)); + (yyval.ParamList)->push_back(E); + delete (yyvsp[(1) - (4)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 317: +#line 3041 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + // FIXME: Remove trailing OptAttributes in LLVM 3.0, it was a mistake in 2.0 + // Labels are only valid in ASMs + (yyval.ParamList) = new ParamList(); + ParamListEntry E; E.Attrs = (yyvsp[(2) - (4)].Attributes) | (yyvsp[(4) - (4)].Attributes); E.Val = getBBVal((yyvsp[(3) - (4)].ValIDVal)); + (yyval.ParamList)->push_back(E); + CHECK_FOR_ERROR + ;} + break; + + case 318: +#line 3049 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + // FIXME: Remove trailing OptAttributes in LLVM 3.0, it was a mistake in 2.0 + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription()); + (yyval.ParamList) = (yyvsp[(1) - (6)].ParamList); + ParamListEntry E; E.Attrs = (yyvsp[(4) - (6)].Attributes) | (yyvsp[(6) - (6)].Attributes); E.Val = getVal((yyvsp[(3) - (6)].TypeVal)->get(), (yyvsp[(5) - (6)].ValIDVal)); + (yyval.ParamList)->push_back(E); + delete (yyvsp[(3) - (6)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 319: +#line 3059 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + // FIXME: Remove trailing OptAttributes in LLVM 3.0, it was a mistake in 2.0 + (yyval.ParamList) = (yyvsp[(1) - (6)].ParamList); + ParamListEntry E; E.Attrs = (yyvsp[(4) - (6)].Attributes) | (yyvsp[(6) - (6)].Attributes); E.Val = getBBVal((yyvsp[(5) - (6)].ValIDVal)); + (yyval.ParamList)->push_back(E); + CHECK_FOR_ERROR + ;} + break; + + case 320: +#line 3066 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.ParamList) = new ParamList(); ;} + break; + + case 321: +#line 3069 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { (yyval.ValueList) = new std::vector(); ;} + break; + + case 322: +#line 3070 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ValueList) = (yyvsp[(1) - (3)].ValueList); + (yyval.ValueList)->push_back((yyvsp[(3) - (3)].ValueVal)); + CHECK_FOR_ERROR + ;} + break; + + case 323: +#line 3078 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ConstantList) = new std::vector(); + if ((unsigned)(yyvsp[(2) - (2)].UInt64Val) != (yyvsp[(2) - (2)].UInt64Val)) + GEN_ERROR("Index " + utostr((yyvsp[(2) - (2)].UInt64Val)) + " is not valid for insertvalue or extractvalue."); + (yyval.ConstantList)->push_back((yyvsp[(2) - (2)].UInt64Val)); + ;} + break; + + case 324: +#line 3084 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.ConstantList) = (yyvsp[(1) - (3)].ConstantList); + if ((unsigned)(yyvsp[(3) - (3)].UInt64Val) != (yyvsp[(3) - (3)].UInt64Val)) + GEN_ERROR("Index " + utostr((yyvsp[(3) - (3)].UInt64Val)) + " is not valid for insertvalue or extractvalue."); + (yyval.ConstantList)->push_back((yyvsp[(3) - (3)].UInt64Val)); + CHECK_FOR_ERROR + ;} + break; + + case 325: +#line 3093 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.BoolVal) = true; + CHECK_FOR_ERROR + ;} + break; + + case 326: +#line 3097 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.BoolVal) = false; + CHECK_FOR_ERROR + ;} + break; + + case 327: +#line 3102 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (5)].TypeVal))->getDescription()); + if (!(*(yyvsp[(2) - (5)].TypeVal))->isInteger() && !(*(yyvsp[(2) - (5)].TypeVal))->isFloatingPoint() && + !isa((*(yyvsp[(2) - (5)].TypeVal)).get())) + GEN_ERROR( + "Arithmetic operator requires integer, FP, or packed operands"); + Value* val1 = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(3) - (5)].ValIDVal)); + CHECK_FOR_ERROR + Value* val2 = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(5) - (5)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.InstVal) = BinaryOperator::Create((yyvsp[(1) - (5)].BinaryOpVal), val1, val2); + if ((yyval.InstVal) == 0) + GEN_ERROR("binary operator returned null"); + delete (yyvsp[(2) - (5)].TypeVal); + ;} + break; + + case 328: +#line 3118 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (5)].TypeVal))->getDescription()); + if (!(*(yyvsp[(2) - (5)].TypeVal))->isInteger()) { + if (!isa((yyvsp[(2) - (5)].TypeVal)->get()) || + !cast((yyvsp[(2) - (5)].TypeVal)->get())->getElementType()->isInteger()) + GEN_ERROR("Logical operator requires integral operands"); + } + Value* tmpVal1 = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(3) - (5)].ValIDVal)); + CHECK_FOR_ERROR + Value* tmpVal2 = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(5) - (5)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.InstVal) = BinaryOperator::Create((yyvsp[(1) - (5)].BinaryOpVal), tmpVal1, tmpVal2); + if ((yyval.InstVal) == 0) + GEN_ERROR("binary operator returned null"); + delete (yyvsp[(2) - (5)].TypeVal); + ;} + break; + + case 329: +#line 3135 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription()); + Value* tmpVal1 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(4) - (6)].ValIDVal)); + CHECK_FOR_ERROR + Value* tmpVal2 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(6) - (6)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.InstVal) = CmpInst::Create((yyvsp[(1) - (6)].OtherOpVal), (yyvsp[(2) - (6)].IPredicate), tmpVal1, tmpVal2); + if ((yyval.InstVal) == 0) + GEN_ERROR("icmp operator returned null"); + delete (yyvsp[(3) - (6)].TypeVal); + ;} + break; + + case 330: +#line 3147 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription()); + Value* tmpVal1 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(4) - (6)].ValIDVal)); + CHECK_FOR_ERROR + Value* tmpVal2 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(6) - (6)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.InstVal) = CmpInst::Create((yyvsp[(1) - (6)].OtherOpVal), (yyvsp[(2) - (6)].FPredicate), tmpVal1, tmpVal2); + if ((yyval.InstVal) == 0) + GEN_ERROR("fcmp operator returned null"); + delete (yyvsp[(3) - (6)].TypeVal); + ;} + break; + + case 331: +#line 3159 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription()); + if (!isa((*(yyvsp[(3) - (6)].TypeVal)).get())) + GEN_ERROR("Scalar types not supported by vicmp instruction"); + Value* tmpVal1 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(4) - (6)].ValIDVal)); + CHECK_FOR_ERROR + Value* tmpVal2 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(6) - (6)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.InstVal) = CmpInst::Create((yyvsp[(1) - (6)].OtherOpVal), (yyvsp[(2) - (6)].IPredicate), tmpVal1, tmpVal2); + if ((yyval.InstVal) == 0) + GEN_ERROR("vicmp operator returned null"); + delete (yyvsp[(3) - (6)].TypeVal); + ;} + break; + + case 332: +#line 3173 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription()); + if (!isa((*(yyvsp[(3) - (6)].TypeVal)).get())) + GEN_ERROR("Scalar types not supported by vfcmp instruction"); + Value* tmpVal1 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(4) - (6)].ValIDVal)); + CHECK_FOR_ERROR + Value* tmpVal2 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(6) - (6)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.InstVal) = CmpInst::Create((yyvsp[(1) - (6)].OtherOpVal), (yyvsp[(2) - (6)].FPredicate), tmpVal1, tmpVal2); + if ((yyval.InstVal) == 0) + GEN_ERROR("vfcmp operator returned null"); + delete (yyvsp[(3) - (6)].TypeVal); + ;} + break; + + case 333: +#line 3187 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(4) - (4)].TypeVal))->getDescription()); + Value* Val = (yyvsp[(2) - (4)].ValueVal); + const Type* DestTy = (yyvsp[(4) - (4)].TypeVal)->get(); + if (!CastInst::castIsValid((yyvsp[(1) - (4)].CastOpVal), Val, DestTy)) + GEN_ERROR("invalid cast opcode for cast from '" + + Val->getType()->getDescription() + "' to '" + + DestTy->getDescription() + "'"); + (yyval.InstVal) = CastInst::Create((yyvsp[(1) - (4)].CastOpVal), Val, DestTy); + delete (yyvsp[(4) - (4)].TypeVal); + ;} + break; + + case 334: +#line 3199 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (isa((yyvsp[(2) - (6)].ValueVal)->getType())) { + // vector select + if (!isa((yyvsp[(4) - (6)].ValueVal)->getType()) + || !isa((yyvsp[(6) - (6)].ValueVal)->getType()) ) + GEN_ERROR("vector select value types must be vector types"); + const VectorType* cond_type = cast((yyvsp[(2) - (6)].ValueVal)->getType()); + const VectorType* select_type = cast((yyvsp[(4) - (6)].ValueVal)->getType()); + if (cond_type->getElementType() != Type::Int1Ty) + GEN_ERROR("vector select condition element type must be boolean"); + if (cond_type->getNumElements() != select_type->getNumElements()) + GEN_ERROR("vector select number of elements must be the same"); + } else { + if ((yyvsp[(2) - (6)].ValueVal)->getType() != Type::Int1Ty) + GEN_ERROR("select condition must be boolean"); + } + if ((yyvsp[(4) - (6)].ValueVal)->getType() != (yyvsp[(6) - (6)].ValueVal)->getType()) + GEN_ERROR("select value types must match"); + (yyval.InstVal) = SelectInst::Create((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal)); + CHECK_FOR_ERROR + ;} + break; + + case 335: +#line 3220 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(4) - (4)].TypeVal))->getDescription()); + (yyval.InstVal) = new VAArgInst((yyvsp[(2) - (4)].ValueVal), *(yyvsp[(4) - (4)].TypeVal)); + delete (yyvsp[(4) - (4)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 336: +#line 3227 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!ExtractElementInst::isValidOperands((yyvsp[(2) - (4)].ValueVal), (yyvsp[(4) - (4)].ValueVal))) + GEN_ERROR("Invalid extractelement operands"); + (yyval.InstVal) = new ExtractElementInst((yyvsp[(2) - (4)].ValueVal), (yyvsp[(4) - (4)].ValueVal)); + CHECK_FOR_ERROR + ;} + break; + + case 337: +#line 3233 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!InsertElementInst::isValidOperands((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal))) + GEN_ERROR("Invalid insertelement operands"); + (yyval.InstVal) = InsertElementInst::Create((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal)); + CHECK_FOR_ERROR + ;} + break; + + case 338: +#line 3239 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!ShuffleVectorInst::isValidOperands((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal))) + GEN_ERROR("Invalid shufflevector operands"); + (yyval.InstVal) = new ShuffleVectorInst((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal)); + CHECK_FOR_ERROR + ;} + break; + + case 339: +#line 3245 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + const Type *Ty = (yyvsp[(2) - (2)].PHIList)->front().first->getType(); + if (!Ty->isFirstClassType()) + GEN_ERROR("PHI node operands must be of first class type"); + (yyval.InstVal) = PHINode::Create(Ty); + ((PHINode*)(yyval.InstVal))->reserveOperandSpace((yyvsp[(2) - (2)].PHIList)->size()); + while ((yyvsp[(2) - (2)].PHIList)->begin() != (yyvsp[(2) - (2)].PHIList)->end()) { + if ((yyvsp[(2) - (2)].PHIList)->front().first->getType() != Ty) + GEN_ERROR("All elements of a PHI node must be of the same type"); + cast((yyval.InstVal))->addIncoming((yyvsp[(2) - (2)].PHIList)->front().first, (yyvsp[(2) - (2)].PHIList)->front().second); + (yyvsp[(2) - (2)].PHIList)->pop_front(); + } + delete (yyvsp[(2) - (2)].PHIList); // Free the list... + CHECK_FOR_ERROR + ;} + break; + + case 340: +#line 3261 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + + // Handle the short syntax + const PointerType *PFTy = 0; + const FunctionType *Ty = 0; + if (!(PFTy = dyn_cast((yyvsp[(4) - (9)].TypeVal)->get())) || + !(Ty = dyn_cast(PFTy->getElementType()))) { + // Pull out the types of all of the arguments... + std::vector ParamTypes; + ParamList::iterator I = (yyvsp[(7) - (9)].ParamList)->begin(), E = (yyvsp[(7) - (9)].ParamList)->end(); + for (; I != E; ++I) { + const Type *Ty = I->Val->getType(); + if (Ty == Type::VoidTy) + GEN_ERROR("Short call syntax cannot be used with varargs"); + ParamTypes.push_back(Ty); + } + + if (!FunctionType::isValidReturnType(*(yyvsp[(4) - (9)].TypeVal))) + GEN_ERROR("Invalid result type for LLVM function"); + + Ty = FunctionType::get((yyvsp[(4) - (9)].TypeVal)->get(), ParamTypes, false); + PFTy = PointerType::getUnqual(Ty); + } + + Value *V = getVal(PFTy, (yyvsp[(5) - (9)].ValIDVal)); // Get the function we're calling... + CHECK_FOR_ERROR + + // Check for call to invalid intrinsic to avoid crashing later. + if (Function *theF = dyn_cast(V)) { + if (theF->hasName() && (theF->getValueName()->getKeyLength() >= 5) && + (0 == strncmp(theF->getValueName()->getKeyData(), "llvm.", 5)) && + !theF->getIntrinsicID(true)) + GEN_ERROR("Call to invalid LLVM intrinsic function '" + + theF->getName() + "'"); + } + + // Set up the Attributes for the function + SmallVector Attrs; + //FIXME : In 3.0, stop accepting zext, sext and inreg as optional function + //attributes. + Attributes RetAttrs = (yyvsp[(3) - (9)].Attributes); + if ((yyvsp[(9) - (9)].Attributes) != Attribute::None) { + if ((yyvsp[(9) - (9)].Attributes) & Attribute::ZExt) { + RetAttrs = RetAttrs | Attribute::ZExt; + (yyvsp[(9) - (9)].Attributes) = (yyvsp[(9) - (9)].Attributes) ^ Attribute::ZExt; + } + if ((yyvsp[(9) - (9)].Attributes) & Attribute::SExt) { + RetAttrs = RetAttrs | Attribute::SExt; + (yyvsp[(9) - (9)].Attributes) = (yyvsp[(9) - (9)].Attributes) ^ Attribute::SExt; + } + if ((yyvsp[(9) - (9)].Attributes) & Attribute::InReg) { + RetAttrs = RetAttrs | Attribute::InReg; + (yyvsp[(9) - (9)].Attributes) = (yyvsp[(9) - (9)].Attributes) ^ Attribute::InReg; + } + } + if (RetAttrs != Attribute::None) + Attrs.push_back(AttributeWithIndex::get(0, RetAttrs)); + + // Check the arguments + ValueList Args; + if ((yyvsp[(7) - (9)].ParamList)->empty()) { // Has no arguments? + // Make sure no arguments is a good thing! + if (Ty->getNumParams() != 0) + GEN_ERROR("No arguments passed to a function that " + "expects arguments"); + } else { // Has arguments? + // Loop through FunctionType's arguments and ensure they are specified + // correctly. Also, gather any parameter attributes. + FunctionType::param_iterator I = Ty->param_begin(); + FunctionType::param_iterator E = Ty->param_end(); + ParamList::iterator ArgI = (yyvsp[(7) - (9)].ParamList)->begin(), ArgE = (yyvsp[(7) - (9)].ParamList)->end(); + unsigned index = 1; + + for (; ArgI != ArgE && I != E; ++ArgI, ++I, ++index) { + if (ArgI->Val->getType() != *I) + GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" + + (*I)->getDescription() + "'"); + Args.push_back(ArgI->Val); + if (ArgI->Attrs != Attribute::None) + Attrs.push_back(AttributeWithIndex::get(index, ArgI->Attrs)); + } + if (Ty->isVarArg()) { + if (I == E) + for (; ArgI != ArgE; ++ArgI, ++index) { + Args.push_back(ArgI->Val); // push the remaining varargs + if (ArgI->Attrs != Attribute::None) + Attrs.push_back(AttributeWithIndex::get(index, ArgI->Attrs)); + } + } else if (I != E || ArgI != ArgE) + GEN_ERROR("Invalid number of parameters detected"); + } + if ((yyvsp[(9) - (9)].Attributes) != Attribute::None) + Attrs.push_back(AttributeWithIndex::get(~0, (yyvsp[(9) - (9)].Attributes))); + + // Finish off the Attributes and check them + AttrListPtr PAL; + if (!Attrs.empty()) + PAL = AttrListPtr::get(Attrs.begin(), Attrs.end()); + + // Create the call node + CallInst *CI = CallInst::Create(V, Args.begin(), Args.end()); + CI->setTailCall((yyvsp[(1) - (9)].BoolVal)); + CI->setCallingConv((yyvsp[(2) - (9)].UIntVal)); + CI->setAttributes(PAL); + (yyval.InstVal) = CI; + delete (yyvsp[(7) - (9)].ParamList); + delete (yyvsp[(4) - (9)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 341: +#line 3370 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.InstVal) = (yyvsp[(1) - (1)].InstVal); + CHECK_FOR_ERROR + ;} + break; + + case 342: +#line 3375 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.BoolVal) = true; + CHECK_FOR_ERROR + ;} + break; + + case 343: +#line 3379 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + (yyval.BoolVal) = false; + CHECK_FOR_ERROR + ;} + break; + + case 344: +#line 3386 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (3)].TypeVal))->getDescription()); + (yyval.InstVal) = new MallocInst(*(yyvsp[(2) - (3)].TypeVal), 0, (yyvsp[(3) - (3)].UIntVal)); + delete (yyvsp[(2) - (3)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 345: +#line 3393 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (6)].TypeVal))->getDescription()); + if ((yyvsp[(4) - (6)].PrimType) != Type::Int32Ty) + GEN_ERROR("Malloc array size is not a 32-bit integer!"); + Value* tmpVal = getVal((yyvsp[(4) - (6)].PrimType), (yyvsp[(5) - (6)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.InstVal) = new MallocInst(*(yyvsp[(2) - (6)].TypeVal), tmpVal, (yyvsp[(6) - (6)].UIntVal)); + delete (yyvsp[(2) - (6)].TypeVal); + ;} + break; + + case 346: +#line 3403 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (3)].TypeVal))->getDescription()); + (yyval.InstVal) = new AllocaInst(*(yyvsp[(2) - (3)].TypeVal), 0, (yyvsp[(3) - (3)].UIntVal)); + delete (yyvsp[(2) - (3)].TypeVal); + CHECK_FOR_ERROR + ;} + break; + + case 347: +#line 3410 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (6)].TypeVal))->getDescription()); + if ((yyvsp[(4) - (6)].PrimType) != Type::Int32Ty) + GEN_ERROR("Alloca array size is not a 32-bit integer!"); + Value* tmpVal = getVal((yyvsp[(4) - (6)].PrimType), (yyvsp[(5) - (6)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.InstVal) = new AllocaInst(*(yyvsp[(2) - (6)].TypeVal), tmpVal, (yyvsp[(6) - (6)].UIntVal)); + delete (yyvsp[(2) - (6)].TypeVal); + ;} + break; + + case 348: +#line 3420 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!isa((yyvsp[(2) - (2)].ValueVal)->getType())) + GEN_ERROR("Trying to free nonpointer type " + + (yyvsp[(2) - (2)].ValueVal)->getType()->getDescription() + ""); + (yyval.InstVal) = new FreeInst((yyvsp[(2) - (2)].ValueVal)); + CHECK_FOR_ERROR + ;} + break; + + case 349: +#line 3428 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (5)].TypeVal))->getDescription()); + if (!isa((yyvsp[(3) - (5)].TypeVal)->get())) + GEN_ERROR("Can't load from nonpointer type: " + + (*(yyvsp[(3) - (5)].TypeVal))->getDescription()); + if (!cast((yyvsp[(3) - (5)].TypeVal)->get())->getElementType()->isFirstClassType()) + GEN_ERROR("Can't load from pointer of non-first-class type: " + + (*(yyvsp[(3) - (5)].TypeVal))->getDescription()); + Value* tmpVal = getVal(*(yyvsp[(3) - (5)].TypeVal), (yyvsp[(4) - (5)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.InstVal) = new LoadInst(tmpVal, "", (yyvsp[(1) - (5)].BoolVal), (yyvsp[(5) - (5)].UIntVal)); + delete (yyvsp[(3) - (5)].TypeVal); + ;} + break; + + case 350: +#line 3442 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(5) - (7)].TypeVal))->getDescription()); + const PointerType *PT = dyn_cast((yyvsp[(5) - (7)].TypeVal)->get()); + if (!PT) + GEN_ERROR("Can't store to a nonpointer type: " + + (*(yyvsp[(5) - (7)].TypeVal))->getDescription()); + const Type *ElTy = PT->getElementType(); + if (ElTy != (yyvsp[(3) - (7)].ValueVal)->getType()) + GEN_ERROR("Can't store '" + (yyvsp[(3) - (7)].ValueVal)->getType()->getDescription() + + "' into space of type '" + ElTy->getDescription() + "'"); + + Value* tmpVal = getVal(*(yyvsp[(5) - (7)].TypeVal), (yyvsp[(6) - (7)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.InstVal) = new StoreInst((yyvsp[(3) - (7)].ValueVal), tmpVal, (yyvsp[(1) - (7)].BoolVal), (yyvsp[(7) - (7)].UIntVal)); + delete (yyvsp[(5) - (7)].TypeVal); + ;} + break; + + case 351: +#line 3459 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (5)].TypeVal))->getDescription()); + if (!isa((yyvsp[(2) - (5)].TypeVal)->get()) && !isa((yyvsp[(2) - (5)].TypeVal)->get())) + GEN_ERROR("getresult insn requires an aggregate operand"); + if (!ExtractValueInst::getIndexedType(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(5) - (5)].UInt64Val))) + GEN_ERROR("Invalid getresult index for type '" + + (*(yyvsp[(2) - (5)].TypeVal))->getDescription()+ "'"); + + Value *tmpVal = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(3) - (5)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.InstVal) = ExtractValueInst::Create(tmpVal, (yyvsp[(5) - (5)].UInt64Val)); + delete (yyvsp[(2) - (5)].TypeVal); + ;} + break; + + case 352: +#line 3473 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (4)].TypeVal))->getDescription()); + if (!isa((yyvsp[(2) - (4)].TypeVal)->get())) + GEN_ERROR("getelementptr insn requires pointer operand"); + + if (!GetElementPtrInst::getIndexedType(*(yyvsp[(2) - (4)].TypeVal), (yyvsp[(4) - (4)].ValueList)->begin(), (yyvsp[(4) - (4)].ValueList)->end())) + GEN_ERROR("Invalid getelementptr indices for type '" + + (*(yyvsp[(2) - (4)].TypeVal))->getDescription()+ "'"); + Value* tmpVal = getVal(*(yyvsp[(2) - (4)].TypeVal), (yyvsp[(3) - (4)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.InstVal) = GetElementPtrInst::Create(tmpVal, (yyvsp[(4) - (4)].ValueList)->begin(), (yyvsp[(4) - (4)].ValueList)->end()); + delete (yyvsp[(2) - (4)].TypeVal); + delete (yyvsp[(4) - (4)].ValueList); + ;} + break; + + case 353: +#line 3488 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (4)].TypeVal))->getDescription()); + if (!isa((yyvsp[(2) - (4)].TypeVal)->get()) && !isa((yyvsp[(2) - (4)].TypeVal)->get())) + GEN_ERROR("extractvalue insn requires an aggregate operand"); + + if (!ExtractValueInst::getIndexedType(*(yyvsp[(2) - (4)].TypeVal), (yyvsp[(4) - (4)].ConstantList)->begin(), (yyvsp[(4) - (4)].ConstantList)->end())) + GEN_ERROR("Invalid extractvalue indices for type '" + + (*(yyvsp[(2) - (4)].TypeVal))->getDescription()+ "'"); + Value* tmpVal = getVal(*(yyvsp[(2) - (4)].TypeVal), (yyvsp[(3) - (4)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.InstVal) = ExtractValueInst::Create(tmpVal, (yyvsp[(4) - (4)].ConstantList)->begin(), (yyvsp[(4) - (4)].ConstantList)->end()); + delete (yyvsp[(2) - (4)].TypeVal); + delete (yyvsp[(4) - (4)].ConstantList); + ;} + break; + + case 354: +#line 3503 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + { + if (!UpRefs.empty()) + GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (7)].TypeVal))->getDescription()); + if (!isa((yyvsp[(2) - (7)].TypeVal)->get()) && !isa((yyvsp[(2) - (7)].TypeVal)->get())) + GEN_ERROR("extractvalue insn requires an aggregate operand"); + + if (ExtractValueInst::getIndexedType(*(yyvsp[(2) - (7)].TypeVal), (yyvsp[(7) - (7)].ConstantList)->begin(), (yyvsp[(7) - (7)].ConstantList)->end()) != (yyvsp[(5) - (7)].TypeVal)->get()) + GEN_ERROR("Invalid insertvalue indices for type '" + + (*(yyvsp[(2) - (7)].TypeVal))->getDescription()+ "'"); + Value* aggVal = getVal(*(yyvsp[(2) - (7)].TypeVal), (yyvsp[(3) - (7)].ValIDVal)); + Value* tmpVal = getVal(*(yyvsp[(5) - (7)].TypeVal), (yyvsp[(6) - (7)].ValIDVal)); + CHECK_FOR_ERROR + (yyval.InstVal) = InsertValueInst::Create(aggVal, tmpVal, (yyvsp[(7) - (7)].ConstantList)->begin(), (yyvsp[(7) - (7)].ConstantList)->end()); + delete (yyvsp[(2) - (7)].TypeVal); + delete (yyvsp[(5) - (7)].TypeVal); + delete (yyvsp[(7) - (7)].ConstantList); + ;} + break; + + +/* Line 1267 of yacc.c. */ +#line 7031 "llvmAsmParser.tab.c" + default: break; + } + YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); + + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + + *++yyvsp = yyval; + + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if ! YYERROR_VERBOSE + yyerror (YY_("syntax error")); +#else + { + YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); + if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) + { + YYSIZE_T yyalloc = 2 * yysize; + if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) + yyalloc = YYSTACK_ALLOC_MAXIMUM; + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = (char *) YYSTACK_ALLOC (yyalloc); + if (yymsg) + yymsg_alloc = yyalloc; + else + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + } + } + + if (0 < yysize && yysize <= yymsg_alloc) + { + (void) yysyntax_error (yymsg, yystate, yychar); + yyerror (yymsg); + } + else + { + yyerror (YY_("syntax error")); + if (yysize != 0) + goto yyexhaustedlab; + } + } +#endif + } + + + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse look-ahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse look-ahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + + /* Pacify compilers like GCC when the user code never invokes + YYERROR and the label yyerrorlab therefore never appears in user + code. */ + if (/*CONSTCOND*/ 0) + goto yyerrorlab; + + /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (yyn != YYPACT_NINF) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + + yydestruct ("Error: popping", + yystos[yystate], yyvsp); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + if (yyn == YYFINAL) + YYACCEPT; + + *++yyvsp = yylval; + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#ifndef yyoverflow +/*-------------------------------------------------. +| yyexhaustedlab -- memory exhaustion comes here. | +`-------------------------------------------------*/ +yyexhaustedlab: + yyerror (YY_("memory exhausted")); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: + if (yychar != YYEOF && yychar != YYEMPTY) + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval); + /* Do not reclaim the symbols of the rule which action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + yystos[*yyssp], yyvsp); + YYPOPSTACK (1); + } +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif +#if YYERROR_VERBOSE + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); +#endif + /* Make sure YYID is used. */ + return YYID (yyresult); +} + + +#line 3522 "/home/arthur/llvm/llvm-2.4/lib/AsmParser/llvmAsmParser.y" + + +// common code from the two 'RunVMAsmParser' functions +static Module* RunParser(Module * M) { + CurModule.CurrentModule = M; + // Check to make sure the parser succeeded + if (yyparse()) { + if (ParserResult) + delete ParserResult; + return 0; + } + + // Emit an error if there are any unresolved types left. + if (!CurModule.LateResolveTypes.empty()) { + const ValID &DID = CurModule.LateResolveTypes.begin()->first; + if (DID.Type == ValID::LocalName) { + GenerateError("Undefined type remains at eof: '"+DID.getName() + "'"); + } else { + GenerateError("Undefined type remains at eof: #" + itostr(DID.Num)); + } + if (ParserResult) + delete ParserResult; + return 0; + } + + // Emit an error if there are any unresolved values left. + if (!CurModule.LateResolveValues.empty()) { + Value *V = CurModule.LateResolveValues.back(); + std::map >::iterator I = + CurModule.PlaceHolderInfo.find(V); + + if (I != CurModule.PlaceHolderInfo.end()) { + ValID &DID = I->second.first; + if (DID.Type == ValID::LocalName) { + GenerateError("Undefined value remains at eof: "+DID.getName() + "'"); + } else { + GenerateError("Undefined value remains at eof: #" + itostr(DID.Num)); + } + if (ParserResult) + delete ParserResult; + return 0; + } + } + + // Check to make sure that parsing produced a result + if (!ParserResult) + return 0; + + // Reset ParserResult variable while saving its value for the result. + Module *Result = ParserResult; + ParserResult = 0; + + return Result; +} + +void llvm::GenerateError(const std::string &message, int LineNo) { + if (LineNo == -1) LineNo = LLLgetLineNo(); + // TODO: column number in exception + if (TheParseError) + TheParseError->setError(LLLgetFilename(), message, LineNo); + TriggerError = 1; +} + +int yyerror(const char *ErrorMsg) { + std::string where = LLLgetFilename() + ":" + utostr(LLLgetLineNo()) + ": "; + std::string errMsg = where + "error: " + std::string(ErrorMsg); + if (yychar != YYEMPTY && yychar != 0) { + errMsg += " while reading token: '"; + errMsg += std::string(LLLgetTokenStart(), + LLLgetTokenStart()+LLLgetTokenLength()) + "'"; + } + GenerateError(errMsg); + return 0; +} +