Index: src/ResolvExpr/AlternativeFinder.cc
===================================================================
--- src/ResolvExpr/AlternativeFinder.cc	(revision c20b0fea8f80f6ab679ab88acb8c39346313f093)
+++ src/ResolvExpr/AlternativeFinder.cc	(revision d55d7a68246b165aeaa9e161109032ddd07146d8)
@@ -252,5 +252,5 @@
 				std::cerr << "No reasonable alternatives for expression " << expr << std::endl;
 			)
-			throw SemanticError( "No reasonable alternatives for expression ", expr );
+			throw SemanticError( expr, "No reasonable alternatives for expression " );
 		}
 		if ( prune ) {
@@ -270,5 +270,5 @@
 				stream << "Alternatives are:\n";
 				printAlts( winners, stream, 1 );
-				throw SemanticError( stream.str() );
+				throw SemanticError( expr->location, stream.str() );
 			}
 			alternatives = move(pruned);
@@ -507,5 +507,5 @@
 				return;
 			} else if ( level >= recursionLimit ) {
-				throw SemanticError( "Too many recursive assertions" );
+				throw SemanticError( newAlt.expr->location, "Too many recursive assertions" );
 			} else {
 				AssertionSet newerNeed;
@@ -1421,5 +1421,5 @@
 			findMinCost( finder.alternatives.begin(), finder.alternatives.end(), back_inserter( winners ) );
 			if ( winners.size() != 1 ) {
-				throw SemanticError( "Ambiguous expression in sizeof operand: ", sizeofExpr->get_expr() );
+				throw SemanticError( sizeofExpr->get_expr(), "Ambiguous expression in sizeof operand: " );
 			} // if
 			// return the lowest cost alternative for the argument
@@ -1442,5 +1442,5 @@
 			findMinCost( finder.alternatives.begin(), finder.alternatives.end(), back_inserter( winners ) );
 			if ( winners.size() != 1 ) {
-				throw SemanticError( "Ambiguous expression in alignof operand: ", alignofExpr->get_expr() );
+				throw SemanticError( alignofExpr->get_expr(), "Ambiguous expression in alignof operand: " );
 			} // if
 			// return the lowest cost alternative for the argument
Index: src/ResolvExpr/CurrentObject.cc
===================================================================
--- src/ResolvExpr/CurrentObject.cc	(revision c20b0fea8f80f6ab679ab88acb8c39346313f093)
+++ src/ResolvExpr/CurrentObject.cc	(revision d55d7a68246b165aeaa9e161109032ddd07146d8)
@@ -141,5 +141,5 @@
 			base = at->get_base();
 			memberIter = createMemberIterator( base );
-			if ( at->isVarLen ) throw SemanticError( "VLA initialization does not support @=", at );
+			if ( at->isVarLen ) throw SemanticError( at, "VLA initialization does not support @=" );
 			setSize( at->get_dimension() );
 		}
@@ -156,5 +156,5 @@
 					PRINT( std::cerr << "array type with size: " << size << std::endl; )
 				} catch ( SemanticError & ) {
-					throw SemanticError( "Constant expression of non-integral type in array dimension: ", expr );
+					throw SemanticError( expr, "Constant expression of non-integral type in array dimension: " );
 				}
 			}	else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
@@ -179,5 +179,5 @@
 					index = constExpr->intValue();
 				} catch( SemanticError & ) {
-					throw SemanticError( "Constant expression of non-integral type in array designator: ", expr );
+					throw SemanticError( expr, "Constant expression of non-integral type in array designator: " );
 				}
 			} else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
@@ -532,7 +532,7 @@
 		} // for
 		if ( desigAlts.size() > 1 ) {
-			throw SemanticError( toString("Too many alternatives (", desigAlts.size(), ") for designation: "), designation );
+			throw SemanticError( designation, toString("Too many alternatives (", desigAlts.size(), ") for designation: ") );
 		} else if ( desigAlts.size() == 0 ) {
-			throw SemanticError( "No reasonable alternatives for designation: ", designation );
+			throw SemanticError( designation, "No reasonable alternatives for designation: " );
 		}
 		DesignatorChain & d = desigAlts.back();
Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision c20b0fea8f80f6ab679ab88acb8c39346313f093)
+++ src/ResolvExpr/Resolver.cc	(revision d55d7a68246b165aeaa9e161109032ddd07146d8)
@@ -188,5 +188,5 @@
 			findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
 			if ( winners.size() == 0 ) {
-				throw SemanticError( "No reasonable alternatives for " + kindStr + " expression: ", untyped );
+				throw SemanticError( untyped, "No reasonable alternatives for " + kindStr + " expression: " );
 			} else if ( winners.size() != 1 ) {
 				std::ostringstream stream;
@@ -195,5 +195,5 @@
 				stream << "Alternatives are:\n";
 				printAlts( winners, stream, 1 );
-				throw SemanticError( stream.str() );
+				throw SemanticError( untyped->location, stream.str() );
 			}
 
@@ -429,5 +429,5 @@
 				ss << strict_dynamic_cast<NameExpr*>( clause.target.function )->name;
 				ss << "' in call to waitfor";
-				throw SemanticError( ss.str() );
+				throw SemanticError( stmt->location, ss.str() );
 			}
 
@@ -451,10 +451,10 @@
 					PointerType * pointer = dynamic_cast< PointerType* >( func.expr->get_result()->stripReferences() );
 					if( !pointer ) {
-						throw SemanticError( "candidate not viable: not a pointer type\n", func.expr->get_result() );
+						throw SemanticError( func.expr->get_result(), "candidate not viable: not a pointer type\n" );
 					}
 
 					FunctionType * function = dynamic_cast< FunctionType* >( pointer->get_base() );
 					if( !function ) {
-						throw SemanticError( "candidate not viable: not a function type\n", pointer->get_base() );
+						throw SemanticError( pointer->get_base(), "candidate not viable: not a function type\n" );
 					}
 
@@ -465,5 +465,5 @@
 
 						if( !advance_to_mutex( param, param_end ) ) {
-							throw SemanticError("candidate function not viable: no mutex parameters\n", function);
+							throw SemanticError(function, "candidate function not viable: no mutex parameters\n");
 						}
 					}
@@ -504,5 +504,5 @@
 									// We ran out of parameters but still have arguments
 									// this function doesn't match
-									throw SemanticError("candidate function not viable: too many mutex arguments\n", function);
+									throw SemanticError( function, "candidate function not viable: too many mutex arguments\n" );
 								}
 
@@ -516,5 +516,5 @@
 									(*param)->get_type()->print( ss );
 									ss << "'\n";
-									throw SemanticError(ss.str(), function);
+									throw SemanticError( function, ss.str() );
 								}
 
@@ -528,5 +528,5 @@
 								// We ran out of arguments but still have parameters left
 								// this function doesn't match
-								throw SemanticError("candidate function not viable: too few mutex arguments\n", function);
+								throw SemanticError( function, "candidate function not viable: too few mutex arguments\n" );
 							}
 
@@ -555,8 +555,8 @@
 
 			// Make sure we got the right number of arguments
-			if( func_candidates.empty() )    { SemanticError top( "No alternatives for function in call to waitfor"  ); top.append( errors ); throw top; }
-			if( args_candidates.empty() )    { SemanticError top( "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
-			if( func_candidates.size() > 1 ) { SemanticError top( "Ambiguous function in call to waitfor"            ); top.append( errors ); throw top; }
-			if( args_candidates.size() > 1 ) { SemanticError top( "Ambiguous arguments in call to waitfor"           ); top.append( errors ); throw top; }
+			if( func_candidates.empty() )    { SemanticError top( stmt->location, "No alternatives for function in call to waitfor"  ); top.append( errors ); throw top; }
+			if( args_candidates.empty() )    { SemanticError top( stmt->location, "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
+			if( func_candidates.size() > 1 ) { SemanticError top( stmt->location, "Ambiguous function in call to waitfor"            ); top.append( errors ); throw top; }
+			if( args_candidates.size() > 1 ) { SemanticError top( stmt->location, "Ambiguous arguments in call to waitfor"           ); top.append( errors ); throw top; }