9 unsigned TypeComparer::next_tag = 1;
11 TypeComparer::TypeComparer():
18 void TypeComparer::compare(Node &node1, Node &node2)
30 T *TypeComparer::multi_visit(T &node)
32 static unsigned tag = next_tag++;
42 else if(!first || tag!=first_tag)
46 T *f = static_cast<T *>(first);
54 void TypeComparer::visit(Literal &literal)
56 if(Literal *lit1 = multi_visit(literal))
58 if(!lit1->type || !literal.type)
62 compare(*lit1->type, *literal.type);
64 r_result = (literal.value.check_type<int>() && lit1->value.value<int>()==literal.value.value<int>());
69 void TypeComparer::visit(VariableReference &var)
71 if(VariableReference *var1 = multi_visit(var))
73 if(!var1->declaration || !var.declaration)
75 else if(!var1->declaration->constant || !var.declaration->constant)
77 else if(!var1->declaration->init_expression || !var.declaration->init_expression)
80 compare(*var1->declaration->init_expression, *var.declaration->init_expression);
84 void TypeComparer::visit(BasicTypeDeclaration &basic)
86 if(BasicTypeDeclaration *basic1 = multi_visit(basic))
88 if(basic1->kind!=basic.kind || basic1->size!=basic.size)
90 else if(basic1->base_type && basic.base_type)
91 compare(*basic1->base_type, *basic.base_type);
93 r_result = (!basic1->base_type && !basic.base_type);
97 void TypeComparer::visit(ImageTypeDeclaration &image)
99 if(ImageTypeDeclaration *image1 = multi_visit(image))
101 if(image1->dimensions!=image.dimensions || image1->array!=image.array)
103 else if(image1->sampled!=image.sampled || image1->shadow!=image.shadow)
105 else if(image1->base_type && image.base_type)
106 compare(*image1->base_type, *image.base_type);
108 r_result = (!image1->base_type && !image.base_type);
112 void TypeComparer::visit(StructDeclaration &strct)
114 if(StructDeclaration *strct1 = multi_visit(strct))
116 if(strct1->members.body.size()!=strct.members.body.size())
121 NodeList<Statement>::const_iterator i = strct1->members.body.begin();
122 NodeList<Statement>::const_iterator j = strct.members.body.begin();
123 for(; (r_result && i!=strct1->members.body.end()); ++i, ++j)
129 void TypeComparer::visit(VariableDeclaration &var)
131 if(VariableDeclaration *var1 = multi_visit(var))
133 if(var1->name!=var.name || var1->array!=var.array)
135 else if(!var1->type_declaration || !var.type_declaration)
142 if(var1->array_size && var.array_size)
143 compare(*var1->array_size, *var.array_size);
145 if(r_result && var1->type_declaration!=var.type_declaration)
146 compare(*var1->type_declaration, *var.type_declaration);
147 // TODO Compare layout qualifiers for interface block members
153 LocationCounter::LocationCounter():
157 void LocationCounter::visit(BasicTypeDeclaration &basic)
159 r_count = basic.kind==BasicTypeDeclaration::MATRIX ? basic.size>>16 : 1;
162 void LocationCounter::visit(ImageTypeDeclaration &)
167 void LocationCounter::visit(StructDeclaration &strct)
170 for(NodeList<Statement>::const_iterator i=strct.members.body.begin(); i!=strct.members.body.end(); ++i)
179 void LocationCounter::visit(VariableDeclaration &var)
182 if(var.type_declaration)
183 var.type_declaration->visit(*this);
185 if(const Literal *literal = dynamic_cast<const Literal *>(var.array_size.get()))
186 if(literal->value.check_type<int>())
187 r_count *= literal->value.value<int>();
191 void MemoryRequirementsCalculator::visit(BasicTypeDeclaration &basic)
193 if(basic.kind==BasicTypeDeclaration::BOOL)
198 else if(basic.kind==BasicTypeDeclaration::INT || basic.kind==BasicTypeDeclaration::FLOAT)
200 r_size = basic.size/8;
201 r_alignment = r_size;
203 else if(basic.kind==BasicTypeDeclaration::VECTOR || basic.kind==BasicTypeDeclaration::MATRIX)
205 basic.base_type->visit(*this);
206 unsigned n_elem = basic.size&0xFFFF;
208 if(basic.kind==BasicTypeDeclaration::VECTOR)
209 r_alignment *= (n_elem==3 ? 4 : n_elem);
211 else if(basic.kind==BasicTypeDeclaration::ARRAY)
212 basic.base_type->visit(*this);
215 void MemoryRequirementsCalculator::visit(StructDeclaration &strct)
218 unsigned max_align = 1;
219 for(NodeList<Statement>::iterator i=strct.members.body.begin(); i!=strct.members.body.end(); ++i)
227 total += r_alignment-1;
228 total -= total%r_alignment;
230 max_align = max(max_align, r_alignment);
233 r_alignment = max_align;
236 void MemoryRequirementsCalculator::visit(VariableDeclaration &var)
240 const vector<Layout::Qualifier> qualifiers = var.layout->qualifiers;
241 for(vector<Layout::Qualifier>::const_iterator i=qualifiers.begin(); (r_offset<0 && i!=qualifiers.end()); ++i)
242 if(i->name=="offset")
246 if(var.type_declaration)
247 var.type_declaration->visit(*this);
249 if(const Literal *literal = dynamic_cast<const Literal *>(var.array_size.get()))
250 if(literal->value.check_type<int>())
251 r_size += r_alignment*(literal->value.value<int>()-1);
255 set<Node *> DependencyCollector::apply(FunctionDeclaration &func)
261 void DependencyCollector::visit(VariableReference &var)
263 if(var.declaration && !locals.count(var.declaration))
265 dependencies.insert(var.declaration);
266 var.declaration->visit(*this);
270 void DependencyCollector::visit(InterfaceBlockReference &iface)
272 if(iface.declaration)
274 dependencies.insert(iface.declaration);
275 iface.declaration->visit(*this);
279 void DependencyCollector::visit(FunctionCall &call)
283 dependencies.insert(call.declaration);
284 call.declaration->visit(*this);
286 TraversingVisitor::visit(call);
289 void DependencyCollector::visit(VariableDeclaration &var)
292 if(var.type_declaration)
294 dependencies.insert(var.type_declaration);
295 var.type_declaration->visit(*this);
298 TraversingVisitor::visit(var);
301 void DependencyCollector::visit(FunctionDeclaration &func)
303 if(!visited_functions.count(&func))
305 visited_functions.insert(&func);
306 TraversingVisitor::visit(func);