1 //===-- ConstantsContext.h - Constants-related Context Interals -----------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines various helper methods and classes used by
11 // LLVMContextImpl for creating and managing constants.
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_CONSTANTSCONTEXT_H
16 #define LLVM_CONSTANTSCONTEXT_H
18 #include "llvm/InlineAsm.h"
19 #include "llvm/Instructions.h"
20 #include "llvm/Operator.h"
21 #include "llvm/Support/Debug.h"
22 #include "llvm/Support/ErrorHandling.h"
23 #include "llvm/Support/raw_ostream.h"
27 template<class ValType>
28 struct ConstantTraits;
30 /// UnaryConstantExpr - This class is private to Constants.cpp, and is used
31 /// behind the scenes to implement unary constant exprs.
32 class UnaryConstantExpr : public ConstantExpr {
33 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
35 // allocate space for exactly one operand
36 void *operator new(size_t s) {
37 return User::operator new(s, 1);
39 UnaryConstantExpr(unsigned Opcode, Constant *C, Type *Ty)
40 : ConstantExpr(Ty, Opcode, &Op<0>(), 1) {
43 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
46 /// BinaryConstantExpr - This class is private to Constants.cpp, and is used
47 /// behind the scenes to implement binary constant exprs.
48 class BinaryConstantExpr : public ConstantExpr {
49 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
51 // allocate space for exactly two operands
52 void *operator new(size_t s) {
53 return User::operator new(s, 2);
55 BinaryConstantExpr(unsigned Opcode, Constant *C1, Constant *C2,
57 : ConstantExpr(C1->getType(), Opcode, &Op<0>(), 2) {
60 SubclassOptionalData = Flags;
62 /// Transparently provide more efficient getOperand methods.
63 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
66 /// SelectConstantExpr - This class is private to Constants.cpp, and is used
67 /// behind the scenes to implement select constant exprs.
68 class SelectConstantExpr : public ConstantExpr {
69 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
71 // allocate space for exactly three operands
72 void *operator new(size_t s) {
73 return User::operator new(s, 3);
75 SelectConstantExpr(Constant *C1, Constant *C2, Constant *C3)
76 : ConstantExpr(C2->getType(), Instruction::Select, &Op<0>(), 3) {
81 /// Transparently provide more efficient getOperand methods.
82 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
85 /// ExtractElementConstantExpr - This class is private to
86 /// Constants.cpp, and is used behind the scenes to implement
87 /// extractelement constant exprs.
88 class ExtractElementConstantExpr : public ConstantExpr {
89 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
91 // allocate space for exactly two operands
92 void *operator new(size_t s) {
93 return User::operator new(s, 2);
95 ExtractElementConstantExpr(Constant *C1, Constant *C2)
96 : ConstantExpr(cast<VectorType>(C1->getType())->getElementType(),
97 Instruction::ExtractElement, &Op<0>(), 2) {
101 /// Transparently provide more efficient getOperand methods.
102 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
105 /// InsertElementConstantExpr - This class is private to
106 /// Constants.cpp, and is used behind the scenes to implement
107 /// insertelement constant exprs.
108 class InsertElementConstantExpr : public ConstantExpr {
109 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
111 // allocate space for exactly three operands
112 void *operator new(size_t s) {
113 return User::operator new(s, 3);
115 InsertElementConstantExpr(Constant *C1, Constant *C2, Constant *C3)
116 : ConstantExpr(C1->getType(), Instruction::InsertElement,
122 /// Transparently provide more efficient getOperand methods.
123 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
126 /// ShuffleVectorConstantExpr - This class is private to
127 /// Constants.cpp, and is used behind the scenes to implement
128 /// shufflevector constant exprs.
129 class ShuffleVectorConstantExpr : public ConstantExpr {
130 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
132 // allocate space for exactly three operands
133 void *operator new(size_t s) {
134 return User::operator new(s, 3);
136 ShuffleVectorConstantExpr(Constant *C1, Constant *C2, Constant *C3)
137 : ConstantExpr(VectorType::get(
138 cast<VectorType>(C1->getType())->getElementType(),
139 cast<VectorType>(C3->getType())->getNumElements()),
140 Instruction::ShuffleVector,
146 /// Transparently provide more efficient getOperand methods.
147 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
150 /// ExtractValueConstantExpr - This class is private to
151 /// Constants.cpp, and is used behind the scenes to implement
152 /// extractvalue constant exprs.
153 class ExtractValueConstantExpr : public ConstantExpr {
154 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
156 // allocate space for exactly one operand
157 void *operator new(size_t s) {
158 return User::operator new(s, 1);
160 ExtractValueConstantExpr(Constant *Agg,
161 const SmallVector<unsigned, 4> &IdxList,
163 : ConstantExpr(DestTy, Instruction::ExtractValue, &Op<0>(), 1),
168 /// Indices - These identify which value to extract.
169 const SmallVector<unsigned, 4> Indices;
171 /// Transparently provide more efficient getOperand methods.
172 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
175 /// InsertValueConstantExpr - This class is private to
176 /// Constants.cpp, and is used behind the scenes to implement
177 /// insertvalue constant exprs.
178 class InsertValueConstantExpr : public ConstantExpr {
179 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
181 // allocate space for exactly one operand
182 void *operator new(size_t s) {
183 return User::operator new(s, 2);
185 InsertValueConstantExpr(Constant *Agg, Constant *Val,
186 const SmallVector<unsigned, 4> &IdxList,
188 : ConstantExpr(DestTy, Instruction::InsertValue, &Op<0>(), 2),
194 /// Indices - These identify the position for the insertion.
195 const SmallVector<unsigned, 4> Indices;
197 /// Transparently provide more efficient getOperand methods.
198 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
202 /// GetElementPtrConstantExpr - This class is private to Constants.cpp, and is
203 /// used behind the scenes to implement getelementpr constant exprs.
204 class GetElementPtrConstantExpr : public ConstantExpr {
205 GetElementPtrConstantExpr(Constant *C, const std::vector<Constant*> &IdxList,
208 static GetElementPtrConstantExpr *Create(Constant *C,
209 const std::vector<Constant*>&IdxList,
212 GetElementPtrConstantExpr *Result =
213 new(IdxList.size() + 1) GetElementPtrConstantExpr(C, IdxList, DestTy);
214 Result->SubclassOptionalData = Flags;
217 /// Transparently provide more efficient getOperand methods.
218 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
221 // CompareConstantExpr - This class is private to Constants.cpp, and is used
222 // behind the scenes to implement ICmp and FCmp constant expressions. This is
223 // needed in order to store the predicate value for these instructions.
224 struct CompareConstantExpr : public ConstantExpr {
225 void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
226 // allocate space for exactly two operands
227 void *operator new(size_t s) {
228 return User::operator new(s, 2);
230 unsigned short predicate;
231 CompareConstantExpr(Type *ty, Instruction::OtherOps opc,
232 unsigned short pred, Constant* LHS, Constant* RHS)
233 : ConstantExpr(ty, opc, &Op<0>(), 2), predicate(pred) {
237 /// Transparently provide more efficient getOperand methods.
238 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
242 struct OperandTraits<UnaryConstantExpr> :
243 public FixedNumOperandTraits<UnaryConstantExpr, 1> {
245 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(UnaryConstantExpr, Value)
248 struct OperandTraits<BinaryConstantExpr> :
249 public FixedNumOperandTraits<BinaryConstantExpr, 2> {
251 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BinaryConstantExpr, Value)
254 struct OperandTraits<SelectConstantExpr> :
255 public FixedNumOperandTraits<SelectConstantExpr, 3> {
257 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(SelectConstantExpr, Value)
260 struct OperandTraits<ExtractElementConstantExpr> :
261 public FixedNumOperandTraits<ExtractElementConstantExpr, 2> {
263 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractElementConstantExpr, Value)
266 struct OperandTraits<InsertElementConstantExpr> :
267 public FixedNumOperandTraits<InsertElementConstantExpr, 3> {
269 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertElementConstantExpr, Value)
272 struct OperandTraits<ShuffleVectorConstantExpr> :
273 public FixedNumOperandTraits<ShuffleVectorConstantExpr, 3> {
275 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ShuffleVectorConstantExpr, Value)
278 struct OperandTraits<ExtractValueConstantExpr> :
279 public FixedNumOperandTraits<ExtractValueConstantExpr, 1> {
281 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractValueConstantExpr, Value)
284 struct OperandTraits<InsertValueConstantExpr> :
285 public FixedNumOperandTraits<InsertValueConstantExpr, 2> {
287 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertValueConstantExpr, Value)
290 struct OperandTraits<GetElementPtrConstantExpr> :
291 public VariadicOperandTraits<GetElementPtrConstantExpr, 1> {
294 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GetElementPtrConstantExpr, Value)
298 struct OperandTraits<CompareConstantExpr> :
299 public FixedNumOperandTraits<CompareConstantExpr, 2> {
301 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CompareConstantExpr, Value)
303 struct ExprMapKeyType {
304 ExprMapKeyType(unsigned opc,
305 ArrayRef<Constant*> ops,
306 unsigned short flags = 0,
307 unsigned short optionalflags = 0,
308 ArrayRef<unsigned> inds = ArrayRef<unsigned>())
309 : opcode(opc), subclassoptionaldata(optionalflags), subclassdata(flags),
310 operands(ops.begin(), ops.end()), indices(inds.begin(), inds.end()) {}
312 uint8_t subclassoptionaldata;
313 uint16_t subclassdata;
314 std::vector<Constant*> operands;
315 SmallVector<unsigned, 4> indices;
316 bool operator==(const ExprMapKeyType& that) const {
317 return this->opcode == that.opcode &&
318 this->subclassdata == that.subclassdata &&
319 this->subclassoptionaldata == that.subclassoptionaldata &&
320 this->operands == that.operands &&
321 this->indices == that.indices;
323 bool operator<(const ExprMapKeyType & that) const {
324 if (this->opcode != that.opcode) return this->opcode < that.opcode;
325 if (this->operands != that.operands) return this->operands < that.operands;
326 if (this->subclassdata != that.subclassdata)
327 return this->subclassdata < that.subclassdata;
328 if (this->subclassoptionaldata != that.subclassoptionaldata)
329 return this->subclassoptionaldata < that.subclassoptionaldata;
330 if (this->indices != that.indices) return this->indices < that.indices;
334 bool operator!=(const ExprMapKeyType& that) const {
335 return !(*this == that);
339 struct InlineAsmKeyType {
340 InlineAsmKeyType(StringRef AsmString,
341 StringRef Constraints, bool hasSideEffects,
343 : asm_string(AsmString), constraints(Constraints),
344 has_side_effects(hasSideEffects), is_align_stack(isAlignStack) {}
345 std::string asm_string;
346 std::string constraints;
347 bool has_side_effects;
349 bool operator==(const InlineAsmKeyType& that) const {
350 return this->asm_string == that.asm_string &&
351 this->constraints == that.constraints &&
352 this->has_side_effects == that.has_side_effects &&
353 this->is_align_stack == that.is_align_stack;
355 bool operator<(const InlineAsmKeyType& that) const {
356 if (this->asm_string != that.asm_string)
357 return this->asm_string < that.asm_string;
358 if (this->constraints != that.constraints)
359 return this->constraints < that.constraints;
360 if (this->has_side_effects != that.has_side_effects)
361 return this->has_side_effects < that.has_side_effects;
362 if (this->is_align_stack != that.is_align_stack)
363 return this->is_align_stack < that.is_align_stack;
367 bool operator!=(const InlineAsmKeyType& that) const {
368 return !(*this == that);
372 // The number of operands for each ConstantCreator::create method is
373 // determined by the ConstantTraits template.
374 // ConstantCreator - A class that is used to create constants by
375 // ConstantUniqueMap*. This class should be partially specialized if there is
376 // something strange that needs to be done to interface to the ctor for the
379 template<typename T, typename Alloc>
380 struct ConstantTraits< std::vector<T, Alloc> > {
381 static unsigned uses(const std::vector<T, Alloc>& v) {
387 struct ConstantTraits<Constant *> {
388 static unsigned uses(Constant * const & v) {
393 template<class ConstantClass, class TypeClass, class ValType>
394 struct ConstantCreator {
395 static ConstantClass *create(TypeClass *Ty, const ValType &V) {
396 return new(ConstantTraits<ValType>::uses(V)) ConstantClass(Ty, V);
400 template<class ConstantClass>
401 struct ConstantKeyData {
402 typedef void ValType;
403 static ValType getValType(ConstantClass *C) {
404 llvm_unreachable("Unknown Constant type!");
409 struct ConstantCreator<ConstantExpr, Type, ExprMapKeyType> {
410 static ConstantExpr *create(Type *Ty, const ExprMapKeyType &V,
411 unsigned short pred = 0) {
412 if (Instruction::isCast(V.opcode))
413 return new UnaryConstantExpr(V.opcode, V.operands[0], Ty);
414 if ((V.opcode >= Instruction::BinaryOpsBegin &&
415 V.opcode < Instruction::BinaryOpsEnd))
416 return new BinaryConstantExpr(V.opcode, V.operands[0], V.operands[1],
417 V.subclassoptionaldata);
418 if (V.opcode == Instruction::Select)
419 return new SelectConstantExpr(V.operands[0], V.operands[1],
421 if (V.opcode == Instruction::ExtractElement)
422 return new ExtractElementConstantExpr(V.operands[0], V.operands[1]);
423 if (V.opcode == Instruction::InsertElement)
424 return new InsertElementConstantExpr(V.operands[0], V.operands[1],
426 if (V.opcode == Instruction::ShuffleVector)
427 return new ShuffleVectorConstantExpr(V.operands[0], V.operands[1],
429 if (V.opcode == Instruction::InsertValue)
430 return new InsertValueConstantExpr(V.operands[0], V.operands[1],
432 if (V.opcode == Instruction::ExtractValue)
433 return new ExtractValueConstantExpr(V.operands[0], V.indices, Ty);
434 if (V.opcode == Instruction::GetElementPtr) {
435 std::vector<Constant*> IdxList(V.operands.begin()+1, V.operands.end());
436 return GetElementPtrConstantExpr::Create(V.operands[0], IdxList, Ty,
437 V.subclassoptionaldata);
440 // The compare instructions are weird. We have to encode the predicate
441 // value and it is combined with the instruction opcode by multiplying
442 // the opcode by one hundred. We must decode this to get the predicate.
443 if (V.opcode == Instruction::ICmp)
444 return new CompareConstantExpr(Ty, Instruction::ICmp, V.subclassdata,
445 V.operands[0], V.operands[1]);
446 if (V.opcode == Instruction::FCmp)
447 return new CompareConstantExpr(Ty, Instruction::FCmp, V.subclassdata,
448 V.operands[0], V.operands[1]);
449 llvm_unreachable("Invalid ConstantExpr!");
455 struct ConstantKeyData<ConstantExpr> {
456 typedef ExprMapKeyType ValType;
457 static ValType getValType(ConstantExpr *CE) {
458 std::vector<Constant*> Operands;
459 Operands.reserve(CE->getNumOperands());
460 for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i)
461 Operands.push_back(cast<Constant>(CE->getOperand(i)));
462 return ExprMapKeyType(CE->getOpcode(), Operands,
463 CE->isCompare() ? CE->getPredicate() : 0,
464 CE->getRawSubclassOptionalData(),
466 CE->getIndices() : ArrayRef<unsigned>());
470 // ConstantAggregateZero does not take extra "value" argument...
471 template<class ValType>
472 struct ConstantCreator<ConstantAggregateZero, Type, ValType> {
473 static ConstantAggregateZero *create(Type *Ty, const ValType &V){
474 return new ConstantAggregateZero(Ty);
479 struct ConstantKeyData<ConstantVector> {
480 typedef std::vector<Constant*> ValType;
481 static ValType getValType(ConstantVector *CP) {
482 std::vector<Constant*> Elements;
483 Elements.reserve(CP->getNumOperands());
484 for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i)
485 Elements.push_back(CP->getOperand(i));
491 struct ConstantKeyData<ConstantAggregateZero> {
492 typedef char ValType;
493 static ValType getValType(ConstantAggregateZero *C) {
499 struct ConstantKeyData<ConstantArray> {
500 typedef std::vector<Constant*> ValType;
501 static ValType getValType(ConstantArray *CA) {
502 std::vector<Constant*> Elements;
503 Elements.reserve(CA->getNumOperands());
504 for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i)
505 Elements.push_back(cast<Constant>(CA->getOperand(i)));
511 struct ConstantKeyData<ConstantStruct> {
512 typedef std::vector<Constant*> ValType;
513 static ValType getValType(ConstantStruct *CS) {
514 std::vector<Constant*> Elements;
515 Elements.reserve(CS->getNumOperands());
516 for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i)
517 Elements.push_back(cast<Constant>(CS->getOperand(i)));
522 // ConstantPointerNull does not take extra "value" argument...
523 template<class ValType>
524 struct ConstantCreator<ConstantPointerNull, PointerType, ValType> {
525 static ConstantPointerNull *create(PointerType *Ty, const ValType &V){
526 return new ConstantPointerNull(Ty);
531 struct ConstantKeyData<ConstantPointerNull> {
532 typedef char ValType;
533 static ValType getValType(ConstantPointerNull *C) {
538 // UndefValue does not take extra "value" argument...
539 template<class ValType>
540 struct ConstantCreator<UndefValue, Type, ValType> {
541 static UndefValue *create(Type *Ty, const ValType &V) {
542 return new UndefValue(Ty);
547 struct ConstantKeyData<UndefValue> {
548 typedef char ValType;
549 static ValType getValType(UndefValue *C) {
555 struct ConstantCreator<InlineAsm, PointerType, InlineAsmKeyType> {
556 static InlineAsm *create(PointerType *Ty, const InlineAsmKeyType &Key) {
557 return new InlineAsm(Ty, Key.asm_string, Key.constraints,
558 Key.has_side_effects, Key.is_align_stack);
563 struct ConstantKeyData<InlineAsm> {
564 typedef InlineAsmKeyType ValType;
565 static ValType getValType(InlineAsm *Asm) {
566 return InlineAsmKeyType(Asm->getAsmString(), Asm->getConstraintString(),
567 Asm->hasSideEffects(), Asm->isAlignStack());
571 template<class ValType, class ValRefType, class TypeClass, class ConstantClass,
572 bool HasLargeKey = false /*true for arrays and structs*/ >
573 class ConstantUniqueMap {
575 typedef std::pair<TypeClass*, ValType> MapKey;
576 typedef std::map<MapKey, ConstantClass *> MapTy;
577 typedef std::map<ConstantClass *, typename MapTy::iterator> InverseMapTy;
579 /// Map - This is the main map from the element descriptor to the Constants.
580 /// This is the primary way we avoid creating two of the same shape
584 /// InverseMap - If "HasLargeKey" is true, this contains an inverse mapping
585 /// from the constants to their element in Map. This is important for
586 /// removal of constants from the array, which would otherwise have to scan
587 /// through the map with very large keys.
588 InverseMapTy InverseMap;
591 typename MapTy::iterator map_begin() { return Map.begin(); }
592 typename MapTy::iterator map_end() { return Map.end(); }
594 void freeConstants() {
595 for (typename MapTy::iterator I=Map.begin(), E=Map.end();
597 // Asserts that use_empty().
602 /// InsertOrGetItem - Return an iterator for the specified element.
603 /// If the element exists in the map, the returned iterator points to the
604 /// entry and Exists=true. If not, the iterator points to the newly
605 /// inserted entry and returns Exists=false. Newly inserted entries have
606 /// I->second == 0, and should be filled in.
607 typename MapTy::iterator InsertOrGetItem(std::pair<MapKey, ConstantClass *>
610 std::pair<typename MapTy::iterator, bool> IP = Map.insert(InsertVal);
616 typename MapTy::iterator FindExistingElement(ConstantClass *CP) {
618 typename InverseMapTy::iterator IMI = InverseMap.find(CP);
619 assert(IMI != InverseMap.end() && IMI->second != Map.end() &&
620 IMI->second->second == CP &&
621 "InverseMap corrupt!");
625 typename MapTy::iterator I =
626 Map.find(MapKey(static_cast<TypeClass*>(CP->getType()),
627 ConstantKeyData<ConstantClass>::getValType(CP)));
628 if (I == Map.end() || I->second != CP) {
629 // FIXME: This should not use a linear scan. If this gets to be a
630 // performance problem, someone should look at this.
631 for (I = Map.begin(); I != Map.end() && I->second != CP; ++I)
637 ConstantClass *Create(TypeClass *Ty, ValRefType V,
638 typename MapTy::iterator I) {
639 ConstantClass* Result =
640 ConstantCreator<ConstantClass,TypeClass,ValType>::create(Ty, V);
642 assert(Result->getType() == Ty && "Type specified is not correct!");
643 I = Map.insert(I, std::make_pair(MapKey(Ty, V), Result));
645 if (HasLargeKey) // Remember the reverse mapping if needed.
646 InverseMap.insert(std::make_pair(Result, I));
652 /// getOrCreate - Return the specified constant from the map, creating it if
654 ConstantClass *getOrCreate(TypeClass *Ty, ValRefType V) {
655 MapKey Lookup(Ty, V);
656 ConstantClass* Result = 0;
658 typename MapTy::iterator I = Map.find(Lookup);
664 // If no preexisting value, create one now...
665 Result = Create(Ty, V, I);
671 void remove(ConstantClass *CP) {
672 typename MapTy::iterator I = FindExistingElement(CP);
673 assert(I != Map.end() && "Constant not found in constant table!");
674 assert(I->second == CP && "Didn't find correct element?");
676 if (HasLargeKey) // Remember the reverse mapping if needed.
677 InverseMap.erase(CP);
682 /// MoveConstantToNewSlot - If we are about to change C to be the element
683 /// specified by I, update our internal data structures to reflect this
685 void MoveConstantToNewSlot(ConstantClass *C, typename MapTy::iterator I) {
686 // First, remove the old location of the specified constant in the map.
687 typename MapTy::iterator OldI = FindExistingElement(C);
688 assert(OldI != Map.end() && "Constant not found in constant table!");
689 assert(OldI->second == C && "Didn't find correct element?");
691 // Remove the old entry from the map.
694 // Update the inverse map so that we know that this constant is now
695 // located at descriptor I.
697 assert(I->second == C && "Bad inversemap entry!");
703 DEBUG(dbgs() << "Constant.cpp: ConstantUniqueMap\n");