Context Navigation

source: src/ResolvExpr/ConversionCost.cc @ e37db112

ADTast-experimentalenumforall-pointer-decayjacob/cs343-translationpthread-emulationqualifiedEnum

Last change on this file since e37db112 was 3e5dd913, checked in by Fangren Yu <f37yu@…>, 4 years ago
reimplement function type and eliminate deep copy
Property mode set to `100644`
File size: 40.8 KB

Rev	Line
[a32b204]	1	//
	2	// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
	3	//
	4	// The contents of this file are covered under the licence agreement in the
	5	// file "LICENCE" distributed with Cforall.
	6	//
[a436947]	7	// ConversionCost.cc --
[a32b204]	8	//
	9	// Author : Richard C. Bilson
	10	// Created On : Sun May 17 07:06:19 2015
[fb2bde4]	11	// Last Modified By : Andrew Beach
[1d17939]	12	// Last Modified On : Wed Jul 29 16:11:00 2020
[cf32116]	13	// Update Count : 28
[a32b204]	14	//
[51b7345]	15
	16	#include "ConversionCost.h"
[ea6332d]	17
	18	#include <cassert> // for assert
	19	#include <list> // for list, list<>::const_iterator
	20	#include <string> // for operator==, string
	21
	22	#include "ResolvExpr/Cost.h" // for Cost
	23	#include "ResolvExpr/TypeEnvironment.h" // for EqvClass, TypeEnvironment
	24	#include "SymTab/Indexer.h" // for Indexer
	25	#include "SynTree/Declaration.h" // for TypeDecl, NamedTypeDecl
	26	#include "SynTree/Type.h" // for Type, BasicType, TypeInstType
	27	#include "typeops.h" // for typesCompatibleIgnoreQualifiers
[51b7345]	28
	29	namespace ResolvExpr {
[c378e5e]	30	#if 0
[cdcddfe1]	31	const Cost Cost::zero = Cost{ 0, 0, 0, 0, 0, 0, 0 };
	32	const Cost Cost::infinity = Cost{ -1, -1, -1, -1, -1, 1, -1 };
	33	const Cost Cost::unsafe = Cost{ 1, 0, 0, 0, 0, 0, 0 };
	34	const Cost Cost::poly = Cost{ 0, 1, 0, 0, 0, 0, 0 };
	35	const Cost Cost::safe = Cost{ 0, 0, 1, 0, 0, 0, 0 };
	36	const Cost Cost::sign = Cost{ 0, 0, 0, 1, 0, 0, 0 };
	37	const Cost Cost::var = Cost{ 0, 0, 0, 0, 1, 0, 0 };
	38	const Cost Cost::spec = Cost{ 0, 0, 0, 0, 0, -1, 0 };
	39	const Cost Cost::reference = Cost{ 0, 0, 0, 0, 0, 0, 1 };
[c378e5e]	40	#endif
[b46e3bd]	41
[5ccb10d]	42	#if 0
	43	#define PRINT(x) x
	44	#else
	45	#define PRINT(x)
	46	#endif
[ada4575]	47
[7d01cf44]	48	Cost conversionCost( const Type * src, const Type * dest, bool srcIsLvalue,
	49	const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
[7870799]	50	if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType * >( dest ) ) {
[eb0aedb]	51	PRINT( std::cerr << "type inst " << destAsTypeInst->name; )
[ef5b828]	52	if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->name ) ) {
[00ac42e]	53	if ( eqvClass->type ) {
[7d01cf44]	54	return conversionCost( src, eqvClass->type, srcIsLvalue, indexer, env );
[0b150ec]	55	} else {
	56	return Cost::infinity;
	57	}
[7870799]	58	} else if ( const NamedTypeDecl * namedType = indexer.lookupType( destAsTypeInst->name ) ) {
[5ccb10d]	59	PRINT( std::cerr << " found" << std::endl; )
[ef5b828]	60	const TypeDecl * type = dynamic_cast< const TypeDecl * >( namedType );
[a32b204]	61	// all typedefs should be gone by this point
	62	assert( type );
[eb0aedb]	63	if ( type->base ) {
[7d01cf44]	64	return conversionCost( src, type->base, srcIsLvalue, indexer, env )
	65	+ Cost::safe;
[a32b204]	66	} // if
	67	} // if
[5ccb10d]	68	PRINT( std::cerr << " not found" << std::endl; )
[a32b204]	69	} // if
[5ccb10d]	70	PRINT(
	71	std::cerr << "src is ";
	72	src->print( std::cerr );
	73	std::cerr << std::endl << "dest is ";
	74	dest->print( std::cerr );
	75	std::cerr << std::endl << "env is" << std::endl;
	76	env.print( std::cerr, 8 );
	77	)
[a32b204]	78	if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
[5ccb10d]	79	PRINT( std::cerr << "compatible!" << std::endl; )
[89be1c68]	80	return Cost::zero;
[7870799]	81	} else if ( dynamic_cast< const VoidType * >( dest ) ) {
[89be1c68]	82	return Cost::safe;
[7870799]	83	} else if ( const ReferenceType * refType = dynamic_cast< const ReferenceType * > ( dest ) ) {
[5ccb10d]	84	PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
[7d01cf44]	85	return convertToReferenceCost( src, refType, srcIsLvalue, indexer, env, [](const Type * const t1, const Type * t2, const SymTab::Indexer &, const TypeEnvironment & env ){
[0c6596f]	86	return ptrsAssignable( t1, t2, env );
	87	});
[a32b204]	88	} else {
[7870799]	89	PassVisitor<ConversionCost> converter(
[7d01cf44]	90	dest, srcIsLvalue, indexer, env,
	91	(Cost ()(const Type , const Type *, bool, const SymTab::Indexer&, const TypeEnvironment&))
[9d5089e]	92	conversionCost );
[a32b204]	93	src->accept( converter );
[bd0b6b62]	94	if ( converter.pass.get_cost() == Cost::infinity ) {
[a32b204]	95	return Cost::infinity;
	96	} else {
[bd0b6b62]	97	return converter.pass.get_cost() + Cost::zero;
[a32b204]	98	} // if
	99	} // if
	100	}
	101
[7d01cf44]	102	static Cost convertToReferenceCost( const Type * src, const Type * dest, bool srcIsLvalue,
	103	int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
[6e027d6]	104	PRINT( std::cerr << "convert to reference cost... diff " << diff << " " << src << " / " << dest << std::endl; )
[89be1c68]	105	if ( diff > 0 ) {
	106	// TODO: document this
[7d01cf44]	107	Cost cost = convertToReferenceCost(
	108	strict_dynamic_cast< const ReferenceType * >( src )->base, dest, srcIsLvalue,
	109	diff-1, indexer, env, func );
[7ebaa56]	110	cost.incReference();
[89be1c68]	111	return cost;
	112	} else if ( diff < -1 ) {
	113	// TODO: document this
[7d01cf44]	114	Cost cost = convertToReferenceCost(
	115	src, strict_dynamic_cast< const ReferenceType * >( dest )->base, srcIsLvalue,
	116	diff+1, indexer, env, func );
[7ebaa56]	117	cost.incReference();
[89be1c68]	118	return cost;
	119	} else if ( diff == 0 ) {
[7870799]	120	const ReferenceType * srcAsRef = dynamic_cast< const ReferenceType * >( src );
	121	const ReferenceType * destAsRef = dynamic_cast< const ReferenceType * >( dest );
[89be1c68]	122	if ( srcAsRef && destAsRef ) { // pointer-like conversions between references
[5ccb10d]	123	PRINT( std::cerr << "converting between references" << std::endl; )
[7870799]	124	Type::Qualifiers tq1 = srcAsRef->base->tq;
	125	Type::Qualifiers tq2 = destAsRef->base->tq;
[eb0aedb]	126	if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->base, destAsRef->base, indexer, env ) ) {
[6e027d6]	127	PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
	128	if ( tq1 == tq2 ) {
	129	// types are the same
	130	return Cost::zero;
	131	} else {
	132	// types are the same, except otherPointer has more qualifiers
	133	return Cost::safe;
	134	}
[89be1c68]	135	} else { // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
[721cd19f]	136	int assignResult = func( srcAsRef->base, destAsRef->base, indexer, env );
[5ccb10d]	137	PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; )
[b0837e4]	138	if ( assignResult > 0 ) {
[89be1c68]	139	return Cost::safe;
[b0837e4]	140	} else if ( assignResult < 0 ) {
[89be1c68]	141	return Cost::unsafe;
	142	} // if
[2463d0e]	143	} // if
	144	} else {
[5ccb10d]	145	PRINT( std::cerr << "reference to rvalue conversion" << std::endl; )
[7870799]	146	PassVisitor<ConversionCost> converter(
[7d01cf44]	147	dest, srcIsLvalue, indexer, env,
	148	(Cost ()(const Type , const Type *, bool, const SymTab::Indexer&, const TypeEnvironment&))
[9d5089e]	149	conversionCost );
[89be1c68]	150	src->accept( converter );
[bd0b6b62]	151	return converter.pass.get_cost();
[89be1c68]	152	} // if
[2463d0e]	153	} else {
[7870799]	154	const ReferenceType * destAsRef = dynamic_cast< const ReferenceType * >( dest );
[89be1c68]	155	assert( diff == -1 && destAsRef );
[108f3cdb]	156	PRINT( std::cerr << "dest is: " << dest << " / src is: " << src << std::endl; )
[eb0aedb]	157	if ( typesCompatibleIgnoreQualifiers( src, destAsRef->base, indexer, env ) ) {
[5ccb10d]	158	PRINT( std::cerr << "converting compatible base type" << std::endl; )
[7d01cf44]	159	if ( srcIsLvalue ) {
[5ccb10d]	160	PRINT(
	161	std::cerr << "lvalue to reference conversion" << std::endl;
	162	std::cerr << src << " => " << destAsRef << std::endl;
	163	)
[89be1c68]	164	// lvalue-to-reference conversion: cv lvalue T => cv T &
[7870799]	165	if ( src->tq == destAsRef->base->tq ) {
[7ebaa56]	166	return Cost::reference; // cost needs to be non-zero to add cast
[7870799]	167	} if ( src->tq < destAsRef->base->tq ) {
[7ebaa56]	168	return Cost::safe; // cost needs to be higher than previous cast to differentiate adding qualifiers vs. keeping same
[89be1c68]	169	} else {
	170	return Cost::unsafe;
	171	} // if
[eb0aedb]	172	} else if ( destAsRef->base->get_const() ) {
[5ccb10d]	173	PRINT( std::cerr << "rvalue to const ref conversion" << std::endl; )
[89be1c68]	174	// rvalue-to-const-reference conversion: T => const T &
	175	return Cost::safe;
	176	} else {
[5ccb10d]	177	PRINT( std::cerr << "rvalue to non-const reference conversion" << std::endl; )
[89be1c68]	178	// rvalue-to-reference conversion: T => T &
	179	return Cost::unsafe;
	180	} // if
	181	} // if
[5ccb10d]	182	PRINT( std::cerr << "attempting to convert from incompatible base type -- fail" << std::endl; )
[2463d0e]	183	}
	184	return Cost::infinity;
	185	}
	186
[7d01cf44]	187	Cost convertToReferenceCost( const Type * src, const ReferenceType * dest, bool srcIsLvalue,
	188	const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
[89be1c68]	189	int sdepth = src->referenceDepth(), ddepth = dest->referenceDepth();
[7d01cf44]	190	Cost cost = convertToReferenceCost( src, dest, srcIsLvalue, sdepth-ddepth, indexer, env, func );
[eddb399]	191	PRINT( std::cerr << "convertToReferenceCost result: " << cost << std::endl; )
	192	return cost;
[89be1c68]	193	}
	194
[7d01cf44]	195	ConversionCost::ConversionCost( const Type * dest, bool srcIsLvalue, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
	196	: dest( dest ), srcIsLvalue( srcIsLvalue ), indexer( indexer ), cost( Cost::infinity ), env( env ), costFunc( costFunc ) {
[a32b204]	197	}
[4ee3b0c1]	198
[e15853c]	199	// GENERATED START, DO NOT EDIT
[6fd1955]	200	// GENERATED BY BasicTypes-gen.cc
[cdcddfe1]	201	/* EXTENDED INTEGRAL RANK HIERARCHY (root to leaves)
[e15853c]	202	_Bool
[7870799]	203	char signed char unsigned char
	204	signed short int unsigned short int
	205	signed int unsigned int
	206	signed long int unsigned long int
	207	signed long long int unsigned long long int
	208	__int128 unsigned __int128
	209	_Float16 _Float16 _Complex
	210	_Float32 _Float32 _Complex
	211	float float _Complex
	212	_Float32x _Float32x _Complex
	213	_Float64 _Float64 _Complex
	214	double double _Complex
	215	_Float64x _Float64x _Complex
[e15853c]	216	__float80
[7870799]	217	_Float128 _Float128 _Complex
[e15853c]	218	__float128
[7870799]	219	long double long double _Complex
	220	_Float128x _Float128x _Complex
[cdcddfe1]	221	*/
[e15853c]	222	// GENERATED END
[cdcddfe1]	223
[e15853c]	224	// GENERATED START, DO NOT EDIT
[6fd1955]	225	// GENERATED BY BasicTypes-gen.cc
[cdcddfe1]	226	static const int costMatrix[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // path length from root to node
[3a55d9f]	227	/* B C SC UC SI SUI I UI LI LUI LLI LLUI IB UIB _FH _FH _F _FC F FC _FX _FXC FD _FDC D DC F80X_FDXC F80 _FB_FLDC FB LD LDC _FBX_FLDXC */
	228	/* B */ { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 17, 16, 18, 17, },
	229	/* C */ { -1, 0, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 16, 15, 17, 16, },
	230	/* SC */ { -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 16, 15, 17, 16, },
	231	/* UC */ { -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 16, 15, 17, 16, },
	232	/* SI */ { -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 15, 14, 16, 15, },
	233	/* SUI */ { -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 15, 14, 16, 15, },
	234	/* I */ { -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 14, 13, 15, 14, },
	235	/* UI */ { -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 14, 13, 15, 14, },
	236	/* LI */ { -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 13, 12, 14, 13, },
	237	/* LUI */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 13, 12, 14, 13, },
	238	/* LLI */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 12, 11, 13, 12, },
	239	/* LLUI */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 12, 11, 13, 12, },
	240	/* IB */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 11, 10, 12, 11, },
	241	/* UIB */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 11, 10, 12, 11, },
	242	/* _FH */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 10, 9, 11, 10, },
	243	/* _FH */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, 3, -1, 4, -1, 5, -1, 6, -1, -1, 7, -1, -1, 8, -1, 9, },
	244	/* _F */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 9, 8, 10, 9, },
	245	/* _FC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, 3, -1, 4, -1, 5, -1, -1, 6, -1, -1, 7, -1, 8, },
	246	/* F */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 8, 7, 9, 8, },
	247	/* FC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, 3, -1, 4, -1, -1, 5, -1, -1, 6, -1, 7, },
	248	/* _FX */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 6, 8, 7, },
	249	/* _FXC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, 3, -1, -1, 4, -1, -1, 5, -1, 6, },
	250	/* FD */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 6, 5, 7, 6, },
	251	/* _FDC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 1, -1, 2, -1, -1, 3, -1, -1, 4, -1, 5, },
	252	/* D */ { -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, 1, 1, 2, 2, 3, 3, 4, 5, 4, 6, 5, },
	253	/* DC */ { -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, -1, 1, -1, -1, 2, -1, -1, 3, -1, 4, },
	254	/* F80X */ { -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, 1, 1, 2, 2, 3, 4, 3, 5, 4, },
	255	/* _FDXC */ { -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, -1, -1, 1, -1, -1, 2, -1, 3, },
	256	/* F80 */ { -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, 1, 2, 2, 3, 3, 4, 4, },
	257	/* _FB */ { -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, 1, 1, 2, 2, 3, 3, },
	258	/* _FLDC */ { -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, -1, -1, 1, -1, 2, },
	259	/* FB */ { -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, 1, 2, 2, 3, },
	260	/* LD */ { -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, 1, 1, 2, },
	261	/* LDC */ { -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, -1, 1, },
	262	/* _FBX */ { -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, 1, },
[ef5b828]	263	/* _FLDXC */ { -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, },
[e15853c]	264	}; // costMatrix
[1c9568f0]	265	static const int maxIntCost = 15;
[e15853c]	266	// GENERATED END
[cdcddfe1]	267	static_assert(
[ef5b828]	268	sizeof(costMatrix)/sizeof(costMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES * BasicType::NUMBER_OF_BASIC_TYPES,
[cdcddfe1]	269	"Missing row in the cost matrix"
	270	);
	271
[e15853c]	272	// GENERATED START, DO NOT EDIT
[6fd1955]	273	// GENERATED BY BasicTypes-gen.cc
[cdcddfe1]	274	static const int signMatrix[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion
[3a55d9f]	275	/* B C SC UC SI SUI I UI LI LUI LLI LLUI IB UIB _FH _FH _F _FC F FC _FX _FXC FD _FDC D DC F80X_FDXC F80 _FB_FLDC FB LD LDC _FBX_FLDXC */
	276	/* B */ { 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	277	/* C */ { -1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	278	/* SC */ { -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	279	/* UC */ { -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	280	/* SI */ { -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	281	/* SUI */ { -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	282	/* I */ { -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	283	/* UI */ { -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	284	/* LI */ { -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	285	/* LUI */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	286	/* LLI */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	287	/* LLUI */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	288	/* IB */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	289	/* UIB */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	290	/* _FH */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	291	/* _FH */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, },
	292	/* _F */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	293	/* _FC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, },
	294	/* F */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	295	/* FC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, },
	296	/* _FX */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	297	/* _FXC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, },
	298	/* FD */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	299	/* _FDC */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 0, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, },
	300	/* D */ { -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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	301	/* DC */ { -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, -1, 0, -1, -1, 0, -1, -1, 0, -1, 0, },
	302	/* F80X */ { -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, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
	303	/* _FDXC */ { -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, -1, -1, 0, -1, -1, 0, -1, 0, },
	304	/* F80 */ { -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, 0, 0, 0, 0, 0, 0, 0, 0, },
	305	/* _FB */ { -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, 0, 0, 0, 0, 0, 0, },
	306	/* _FLDC */ { -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, -1, -1, 0, -1, 0, },
	307	/* FB */ { -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, 0, 0, 0, 0, 0, },
	308	/* LD */ { -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, 0, 0, 0, },
	309	/* LDC */ { -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, -1, 0, },
	310	/* _FBX */ { -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, 0, },
[ef5b828]	311	/* _FLDXC */ { -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, },
[e15853c]	312	}; // signMatrix
	313	// GENERATED END
[cdcddfe1]	314	static_assert(
[ef5b828]	315	sizeof(signMatrix)/sizeof(signMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES * BasicType::NUMBER_OF_BASIC_TYPES,
[cdcddfe1]	316	"Missing row in the sign matrix"
	317	);
[a32b204]	318
[7870799]	319	void ConversionCost::postvisit( const VoidType * ) {
[a32b204]	320	cost = Cost::infinity;
	321	}
	322
[ef5b828]	323	void ConversionCost::postvisit(const BasicType * basicType) {
	324	if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
[7870799]	325	int tableResult = costMatrix[ basicType->kind ][ destAsBasic->kind ];
[a32b204]	326	if ( tableResult == -1 ) {
[89be1c68]	327	cost = Cost::unsafe;
[a32b204]	328	} else {
[89be1c68]	329	cost = Cost::zero;
	330	cost.incSafe( tableResult );
[7870799]	331	cost.incSign( signMatrix[ basicType->kind ][ destAsBasic->kind ] );
[a32b204]	332	} // if
[7870799]	333	} else if ( dynamic_cast< const EnumInstType * >( dest ) ) {
[a436947]	334	// xxx - not positive this is correct, but appears to allow casting int => enum
[89be1c68]	335	cost = Cost::unsafe;
[89e6ffc]	336	} // if
[98278b3a]	337	// no cases for zero_t/one_t because it should not be possible to convert int, etc. to zero_t/one_t.
[a32b204]	338	}
	339
[7870799]	340	void ConversionCost::postvisit( const PointerType * pointerType ) {
[ef5b828]	341	if ( const PointerType * destAsPtr = dynamic_cast< const PointerType * >( dest ) ) {
[6e027d6]	342	PRINT( std::cerr << pointerType << " ===> " << destAsPtr << std::endl; )
[7870799]	343	Type::Qualifiers tq1 = pointerType->base->tq;
	344	Type::Qualifiers tq2 = destAsPtr->base->tq;
[eb0aedb]	345	if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
[6e027d6]	346	PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
[cb43451]	347	if ( tq1 == tq2 ) {
	348	// types are the same
	349	cost = Cost::zero;
	350	} else {
	351	// types are the same, except otherPointer has more qualifiers
	352	cost = Cost::safe;
[cdcddfe1]	353	} // if
[b8b075cd]	354	} else {
[b0837e4]	355	int assignResult = ptrsAssignable( pointerType->base, destAsPtr->base, env );
[5ccb10d]	356	PRINT( std::cerr << " :: " << assignResult << std::endl; )
[b8b075cd]	357	if ( assignResult > 0 && tq1 <= tq2 ) {
	358	// xxx - want the case where qualifiers are added to be more expensive than the case where qualifiers are the same. Is 1 safe vs. 2 safe correct?
	359	if ( tq1 == tq2 ) {
	360	cost = Cost::safe;
	361	} else if ( tq1 < tq2 ) {
	362	cost = Cost::safe+Cost::safe;
	363	}
[b0837e4]	364	} else if ( assignResult < 0 ) {
[89be1c68]	365	cost = Cost::unsafe;
[a32b204]	366	} // if
[cb43451]	367	// assignResult == 0 means Cost::Infinity
[a32b204]	368	} // if
[98278b3a]	369	// case case for zero_t because it should not be possible to convert pointers to zero_t.
[a32b204]	370	} // if
	371	}
	372
[7870799]	373	void ConversionCost::postvisit( const ArrayType * ) {}
[2463d0e]	374
[7870799]	375	void ConversionCost::postvisit( const ReferenceType * refType ) {
[2463d0e]	376	// Note: dest can never be a reference, since it would have been caught in an earlier check
[7870799]	377	assert( ! dynamic_cast< const ReferenceType * >( dest ) );
[2463d0e]	378	// convert reference to rvalue: cv T1 & => T2
	379	// recursively compute conversion cost from T1 to T2.
	380	// cv can be safely dropped because of 'implicit dereference' behavior.
[7d01cf44]	381	cost = costFunc( refType->base, dest, srcIsLvalue, indexer, env );
[7870799]	382	if ( refType->base->tq == dest->tq ) {
[cb43451]	383	cost.incReference(); // prefer exact qualifiers
[7870799]	384	} else if ( refType->base->tq < dest->tq ) {
[cb43451]	385	cost.incSafe(); // then gaining qualifiers
	386	} else {
	387	cost.incUnsafe(); // lose qualifiers as last resort
	388	}
[5ccb10d]	389	PRINT( std::cerr << refType << " ==> " << dest << " " << cost << std::endl; )
[2463d0e]	390	}
	391
[7870799]	392	void ConversionCost::postvisit( const FunctionType * ) {}
[a32b204]	393
[7870799]	394	void ConversionCost::postvisit( const EnumInstType * ) {
[a32b204]	395	static Type::Qualifiers q;
	396	static BasicType integer( q, BasicType::SignedInt );
[7d01cf44]	397	cost = costFunc( &integer, dest, srcIsLvalue, indexer, env ); // safe if dest >= int
[89be1c68]	398	if ( cost < Cost::unsafe ) {
[a32b204]	399	cost.incSafe();
	400	} // if
	401	}
	402
[7870799]	403	void ConversionCost::postvisit( const TraitInstType * ) {}
[a32b204]	404
[ef5b828]	405	void ConversionCost::postvisit( const TypeInstType * inst ) {
	406	if ( const EqvClass * eqvClass = env.lookup( inst->name ) ) {
[7d01cf44]	407	cost = costFunc( eqvClass->type, dest, srcIsLvalue, indexer, env );
[ef5b828]	408	} else if ( const TypeInstType * destAsInst = dynamic_cast< const TypeInstType * >( dest ) ) {
[eb0aedb]	409	if ( inst->name == destAsInst->name ) {
[a32b204]	410	cost = Cost::zero;
	411	}
[ef5b828]	412	} else if ( const NamedTypeDecl * namedType = indexer.lookupType( inst->name ) ) {
	413	const TypeDecl * type = dynamic_cast< const TypeDecl * >( namedType );
[a32b204]	414	// all typedefs should be gone by this point
	415	assert( type );
[eb0aedb]	416	if ( type->base ) {
[7d01cf44]	417	cost = costFunc( type->base, dest, srcIsLvalue, indexer, env ) + Cost::safe;
[a32b204]	418	} // if
	419	} // if
	420	}
	421
[7870799]	422	void ConversionCost::postvisit( const TupleType * tupleType ) {
[89be1c68]	423	Cost c = Cost::zero;
[7870799]	424	if ( const TupleType * destAsTuple = dynamic_cast< const TupleType * >( dest ) ) {
[eb0aedb]	425	std::list< Type * >::const_iterator srcIt = tupleType->types.begin();
	426	std::list< Type * >::const_iterator destIt = destAsTuple->types.begin();
	427	while ( srcIt != tupleType->types.end() && destIt != destAsTuple->types.end() ) {
[7d01cf44]	428	Cost newCost = costFunc( * srcIt++, * destIt++, srcIsLvalue, indexer, env );
[a32b204]	429	if ( newCost == Cost::infinity ) {
	430	return;
	431	} // if
	432	c += newCost;
	433	} // while
[eb0aedb]	434	if ( destIt != destAsTuple->types.end() ) {
[a32b204]	435	cost = Cost::infinity;
	436	} else {
	437	cost = c;
	438	} // if
	439	} // if
	440	}
[44b7088]	441
[7870799]	442	void ConversionCost::postvisit( const VarArgsType * ) {
[ef5b828]	443	if ( dynamic_cast< const VarArgsType * >( dest ) ) {
[44b7088]	444	cost = Cost::zero;
	445	}
	446	}
[89e6ffc]	447
[7870799]	448	void ConversionCost::postvisit( const ZeroType * ) {
	449	if ( dynamic_cast< const ZeroType * >( dest ) ) {
[89e6ffc]	450	cost = Cost::zero;
[ef5b828]	451	} else if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
	452	// copied from visit(BasicType *) for signed int, but +1 for safe conversions
[7870799]	453	int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->kind ];
[89e6ffc]	454	if ( tableResult == -1 ) {
[89be1c68]	455	cost = Cost::unsafe;
[89e6ffc]	456	} else {
[89be1c68]	457	cost = Cost::zero;
	458	cost.incSafe( tableResult + 1 );
[7870799]	459	cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->kind ] );
[cdcddfe1]	460	} // if
[ef5b828]	461	} else if ( dynamic_cast< const PointerType * >( dest ) ) {
[1c9568f0]	462	cost = Cost::zero;
	463	cost.incSafe( maxIntCost + 2 ); // +1 for zero_t -> int, +1 for disambiguation
[cdcddfe1]	464	} // if
[89e6ffc]	465	}
	466
[7870799]	467	void ConversionCost::postvisit( const OneType * ) {
	468	if ( dynamic_cast< const OneType * >( dest ) ) {
[89e6ffc]	469	cost = Cost::zero;
[7870799]	470	} else if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
[ef5b828]	471	// copied from visit(BasicType *) for signed int, but +1 for safe conversions
[7870799]	472	int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->kind ];
[89e6ffc]	473	if ( tableResult == -1 ) {
[89be1c68]	474	cost = Cost::unsafe;
[89e6ffc]	475	} else {
[89be1c68]	476	cost = Cost::zero;
	477	cost.incSafe( tableResult + 1 );
[7870799]	478	cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->kind ] );
[cdcddfe1]	479	} // if
	480	} // if
[89e6ffc]	481	}
[9d5089e]	482
[cf32116]	483	namespace {
	484	# warning For overload resolution between the two versions.
	485	int localPtrsAssignable(const ast::Type * t1, const ast::Type * t2,
	486	const ast::SymbolTable &, const ast::TypeEnvironment & env ) {
	487	return ptrsAssignable( t1, t2, env );
	488	}
	489	Cost localConversionCost(
	490	const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
	491	const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
	492	) { return conversionCost( src, dst, srcIsLvalue, symtab, env ); }
[fb2bde4]	493	}
	494
	495	Cost conversionCost(
[cf32116]	496	const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
	497	const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
[fb2bde4]	498	) {
	499	if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
[3e5dd913]	500	if ( const ast::EqvClass * eqv = env.lookup( *inst ) ) {
[fb2bde4]	501	if ( eqv->bound ) {
[cf32116]	502	return conversionCost(src, eqv->bound, srcIsLvalue, symtab, env );
[fb2bde4]	503	} else {
	504	return Cost::infinity;
	505	}
	506	} else if ( const ast::NamedTypeDecl * named = symtab.lookupType( inst->name ) ) {
	507	const ast::TypeDecl * type = dynamic_cast< const ast::TypeDecl * >( named );
	508	assertf( type, "Unexpected typedef." );
	509	if ( type->base ) {
[cf32116]	510	return conversionCost( src, type->base, srcIsLvalue, symtab, env ) + Cost::safe;
[fb2bde4]	511	}
	512	}
	513	}
	514	if ( typesCompatibleIgnoreQualifiers( src, dst, symtab, env ) ) {
[9d5089e]	515	return Cost::zero;
[fb2bde4]	516	} else if ( dynamic_cast< const ast::VoidType * >( dst ) ) {
	517	return Cost::safe;
	518	} else if ( const ast::ReferenceType * refType =
	519	dynamic_cast< const ast::ReferenceType * >( dst ) ) {
[cf32116]	520	return convertToReferenceCost( src, refType, srcIsLvalue, symtab, env, localPtrsAssignable );
[fb2bde4]	521	} else {
[e6b42e7]	522	return ast::Pass<ConversionCost_new>::read( src, dst, srcIsLvalue, symtab, env, localConversionCost );
[fb2bde4]	523	}
	524	}
	525
[cf32116]	526	static Cost convertToReferenceCost( const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
[0f19f5e5]	527	int diff, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
[cf32116]	528	PtrsCalculation func ) {
[fb2bde4]	529	if ( 0 < diff ) {
	530	Cost cost = convertToReferenceCost(
[cf32116]	531	strict_dynamic_cast< const ast::ReferenceType * >( src )->base, dst,
	532	srcIsLvalue, (diff - 1), symtab, env, func );
[fb2bde4]	533	cost.incReference();
	534	return cost;
	535	} else if ( diff < -1 ) {
	536	Cost cost = convertToReferenceCost(
	537	src, strict_dynamic_cast< const ast::ReferenceType * >( dst )->base,
[cf32116]	538	srcIsLvalue, (diff + 1), symtab, env, func );
[fb2bde4]	539	cost.incReference();
	540	return cost;
	541	} else if ( 0 == diff ) {
	542	const ast::ReferenceType * srcAsRef = dynamic_cast< const ast::ReferenceType * >( src );
	543	const ast::ReferenceType * dstAsRef = dynamic_cast< const ast::ReferenceType * >( dst );
	544	if ( srcAsRef && dstAsRef ) {
	545	ast::CV::Qualifiers tq1 = srcAsRef->base->qualifiers;
	546	ast::CV::Qualifiers tq2 = dstAsRef->base->qualifiers;
	547	if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers(
	548	srcAsRef->base, dstAsRef->base, symtab, env ) ) {
	549	if ( tq1 == tq2 ) {
	550	return Cost::zero;
	551	} else {
	552	return Cost::safe;
	553	}
	554	} else {
	555	int assignResult = func( srcAsRef->base, dstAsRef->base, symtab, env );
	556	if ( 0 < assignResult ) {
	557	return Cost::safe;
	558	} else if ( assignResult < 0 ) {
	559	return Cost::unsafe;
	560	}
	561	}
	562	} else {
[e6b42e7]	563	return ast::Pass<ConversionCost_new>::read( src, dst, srcIsLvalue, symtab, env, localConversionCost );
[fb2bde4]	564	}
	565	} else {
	566	assert( -1 == diff );
	567	const ast::ReferenceType * dstAsRef = dynamic_cast< const ast::ReferenceType * >( dst );
	568	assert( dstAsRef );
	569	if ( typesCompatibleIgnoreQualifiers( src, dstAsRef->base, symtab, env ) ) {
[cf32116]	570	if ( srcIsLvalue ) {
[fb2bde4]	571	if ( src->qualifiers == dstAsRef->base->qualifiers ) {
	572	return Cost::reference;
	573	} else if ( src->qualifiers < dstAsRef->base->qualifiers ) {
	574	return Cost::safe;
	575	} else {
	576	return Cost::unsafe;
	577	}
	578	} else if ( dstAsRef->base->is_const() ) {
	579	return Cost::safe;
	580	} else {
	581	return Cost::unsafe;
	582	}
	583	}
	584	}
	585	return Cost::infinity;
	586	}
	587
	588	Cost convertToReferenceCost( const ast::Type * src, const ast::ReferenceType * dst,
[cf32116]	589	bool srcIsLvalue, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
	590	PtrsCalculation func ) {
[fb2bde4]	591	int sdepth = src->referenceDepth(), ddepth = dst->referenceDepth();
[cf32116]	592	return convertToReferenceCost( src, dst, srcIsLvalue, sdepth - ddepth, symtab, env, func );
[fb2bde4]	593	}
	594
	595	void ConversionCost_new::postvisit( const ast::VoidType * voidType ) {
	596	(void)voidType;
	597	cost = Cost::infinity;
	598	}
	599
	600	void ConversionCost_new::postvisit( const ast::BasicType * basicType ) {
	601	if ( const ast::BasicType * dstAsBasic = dynamic_cast< const ast::BasicType * >( dst ) ) {
	602	int tableResult = costMatrix[ basicType->kind ][ dstAsBasic->kind ];
	603	if ( tableResult == -1 ) {
	604	cost = Cost::unsafe;
	605	} else {
	606	cost = Cost::zero;
	607	cost.incSafe( tableResult );
	608	cost.incSign( signMatrix[ basicType->kind ][ dstAsBasic->kind ] );
	609	}
	610	} else if ( dynamic_cast< const ast::EnumInstType * >( dst ) ) {
	611	// xxx - not positive this is correct, but appears to allow casting int => enum
	612	cost = Cost::unsafe;
	613	}
	614	}
	615
	616	void ConversionCost_new::postvisit( const ast::PointerType * pointerType ) {
	617	if ( const ast::PointerType * dstAsPtr = dynamic_cast< const ast::PointerType * >( dst ) ) {
	618	ast::CV::Qualifiers tq1 = pointerType->base->qualifiers;
	619	ast::CV::Qualifiers tq2 = dstAsPtr->base->qualifiers;
	620	if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers(
	621	pointerType->base, dstAsPtr->base, symtab, env ) ) {
	622	if ( tq1 == tq2 ) {
	623	cost = Cost::zero;
	624	} else {
	625	cost = Cost::safe;
	626	}
	627	} else {
	628	int assignResult = ptrsAssignable( pointerType->base, dstAsPtr->base, env );
	629	if ( 0 < assignResult && tq1 <= tq2 ) {
	630	if ( tq1 == tq2 ) {
	631	cost = Cost::safe;
	632	} else {
	633	cost = Cost::safe + Cost::safe;
	634	}
	635	} else if ( assignResult < 0 ) {
	636	cost = Cost::unsafe;
	637	} // else Cost::infinity
	638	}
	639	}
	640	}
	641
	642	void ConversionCost_new::postvisit( const ast::ArrayType * arrayType ) {
	643	(void)arrayType;
	644	}
	645
	646	void ConversionCost_new::postvisit( const ast::ReferenceType * refType ) {
	647	assert( nullptr == dynamic_cast< const ast::ReferenceType * >( dst ) );
	648
[cf32116]	649	cost = costCalc( refType->base, dst, srcIsLvalue, symtab, env );
[fb2bde4]	650	if ( refType->base->qualifiers == dst->qualifiers ) {
	651	cost.incReference();
	652	} else if ( refType->base->qualifiers < dst->qualifiers ) {
	653	cost.incSafe();
	654	} else {
	655	cost.incUnsafe();
	656	}
	657	}
	658
	659	void ConversionCost_new::postvisit( const ast::FunctionType * functionType ) {
	660	(void)functionType;
	661	}
	662
	663	void ConversionCost_new::postvisit( const ast::EnumInstType * enumInstType ) {
	664	(void)enumInstType;
[504eb72]	665	static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
[cf32116]	666	cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
[fb2bde4]	667	if ( cost < Cost::unsafe ) {
	668	cost.incSafe();
	669	}
	670	}
	671
	672	void ConversionCost_new::postvisit( const ast::TraitInstType * traitInstType ) {
	673	(void)traitInstType;
	674	}
	675
	676	void ConversionCost_new::postvisit( const ast::TypeInstType * typeInstType ) {
[3e5dd913]	677	if ( const ast::EqvClass * eqv = env.lookup( *typeInstType ) ) {
[cf32116]	678	cost = costCalc( eqv->bound, dst, srcIsLvalue, symtab, env );
[fb2bde4]	679	} else if ( const ast::TypeInstType * dstAsInst =
	680	dynamic_cast< const ast::TypeInstType * >( dst ) ) {
[3e5dd913]	681	if ( typeInstType == dstAsInst ) {
[fb2bde4]	682	cost = Cost::zero;
	683	}
	684	} else if ( const ast::NamedTypeDecl * namedType = symtab.lookupType( typeInstType->name ) ) {
	685	const ast::TypeDecl * type = dynamic_cast< const ast::TypeDecl * >( namedType );
	686	assertf( type, "Unexpected typedef.");
	687	if ( type->base ) {
[cf32116]	688	cost = costCalc( type->base, dst, srcIsLvalue, symtab, env ) + Cost::safe;
[fb2bde4]	689	}
	690	}
	691	}
	692
	693	void ConversionCost_new::postvisit( const ast::TupleType * tupleType ) {
	694	Cost c = Cost::zero;
	695	if ( const ast::TupleType * dstAsTuple = dynamic_cast< const ast::TupleType * >( dst ) ) {
	696	auto srcIt = tupleType->types.begin();
	697	auto dstIt = dstAsTuple->types.begin();
	698	auto srcEnd = tupleType->types.end();
	699	auto dstEnd = dstAsTuple->types.end();
	700	while ( srcIt != srcEnd && dstIt != dstEnd ) {
[cf32116]	701	Cost newCost = costCalc( * srcIt++, * dstIt++, srcIsLvalue, symtab, env );
[fb2bde4]	702	if ( newCost == Cost::infinity ) {
	703	return;
	704	}
	705	c += newCost;
	706	}
	707	if ( dstIt != dstEnd ) {
	708	cost = Cost::infinity;
	709	} else {
	710	cost = c;
	711	}
	712	}
	713	}
	714
	715	void ConversionCost_new::postvisit( const ast::VarArgsType * varArgsType ) {
	716	(void)varArgsType;
	717	if ( dynamic_cast< const ast::VarArgsType * >( dst ) ) {
	718	cost = Cost::zero;
	719	}
	720	}
	721
	722	void ConversionCost_new::postvisit( const ast::ZeroType * zeroType ) {
	723	(void)zeroType;
	724	if ( dynamic_cast< const ast::ZeroType * >( dst ) ) {
	725	cost = Cost::zero;
	726	} else if ( const ast::BasicType * dstAsBasic =
	727	dynamic_cast< const ast::BasicType * >( dst ) ) {
	728	int tableResult = costMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ];
	729	if ( -1 == tableResult ) {
	730	cost = Cost::unsafe;
	731	} else {
	732	cost = Cost::zero;
	733	cost.incSafe( tableResult + 1 );
	734	cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
	735	}
[2f98fb2]	736	} else if ( dynamic_cast< const ast::PointerType * >( dst ) ) {
	737	cost = Cost::zero;
	738	// +1 for zero_t ->, +1 for disambiguation
	739	cost.incSafe( maxIntCost + 2 );
[fb2bde4]	740	}
	741	}
	742
	743	void ConversionCost_new::postvisit( const ast::OneType * oneType ) {
	744	(void)oneType;
	745	if ( dynamic_cast< const ast::OneType * >( dst ) ) {
	746	cost = Cost::zero;
	747	} else if ( const ast::BasicType * dstAsBasic =
	748	dynamic_cast< const ast::BasicType * >( dst ) ) {
	749	int tableResult = costMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ];
	750	if ( -1 == tableResult ) {
	751	cost = Cost::unsafe;
	752	} else {
	753	cost = Cost::zero;
	754	cost.incSafe( tableResult + 1 );
	755	cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
	756	}
[9d5089e]	757	}
[fb2bde4]	758	}
[0d070ca]	759	// size_t ConversionCost_new::traceId = Stats::Heap::new_stacktrace_id("ConversionCost");
[fb2bde4]	760
[51b7345]	761	} // namespace ResolvExpr
[a32b204]	762
	763	// Local Variables: //
	764	// tab-width: 4 //
	765	// mode: c++ //
	766	// compile-command: "make install" //
	767	// End: //

Note: See TracBrowser for help on using the repository browser.

Download in other formats: