Compare View
Commits (2)
Diff
Showing 6 changed files Side-by-side Diff
ast_decl.cc
View file @
992208e
... | ... | @@ -70,8 +70,17 @@ void FnDecl::PrintChildren(int indentLevel) { |
70 | 70 | llvm::Value* VarDecl::Emit() { |
71 | 71 | llvm::BasicBlock* b = irgen.GetBasicBlock(); |
72 | 72 | llvm::Value* val; |
73 | + //locals | |
73 | 74 | if(b) { |
74 | - val = new llvm::AllocaInst(convertType(type), id->GetName(), b); | |
75 | + if(dynamic_cast<ArrayType *>(type) !=NULL){ | |
76 | + llvm::Value* val2 = llvm::ConstantInt::get(irgen.GetIntType(), dynamic_cast<ArrayType*>(type)->GetElemCount()); | |
77 | + llvm::Type* thisType = convertType(dynamic_cast<ArrayType*>(type)->GetElemType()); | |
78 | + llvm::ArrayType* arrType = llvm::ArrayType::get(thisType, dynamic_cast<ArrayType*>(type)->GetElemCount()); | |
79 | + val = new llvm::AllocaInst(arrType, val2, id->GetName(), irgen.GetBasicBlock()); | |
80 | + } | |
81 | + else{ | |
82 | + val = new llvm::AllocaInst(convertType(type), id->GetName(), b); | |
83 | + } | |
75 | 84 | if(assignTo) new llvm::StoreInst(assignTo->Emit(), val, false, irgen.GetBasicBlock()); |
76 | 85 | } |
77 | 86 | else { |
ast_expr.cc
View file @
992208e
... | ... | @@ -9,6 +9,7 @@ |
9 | 9 | #include "ast_decl.h" |
10 | 10 | #include "symtable.h" |
11 | 11 | |
12 | + | |
12 | 13 | IntConstant::IntConstant(yyltype loc, int val) : Expr(loc) { |
13 | 14 | value = val; |
14 | 15 | } |
... | ... | @@ -314,122 +315,184 @@ llvm::Value* CompoundExpr::Emit() { |
314 | 315 | //---------------------------------------------------------------------------------------- |
315 | 316 | //---------------------------------------------------------------------------------------- |
316 | 317 | |
317 | -llvm::Value * AssignExpr::Emit(){ | |
318 | - llvm::Value * leftval; | |
319 | - llvm::Value * rightval; | |
320 | - | |
321 | - FieldAccess * f = dynamic_cast<FieldAccess *>(left); | |
322 | - if (f){ | |
323 | - return this->AssignField(); | |
318 | +llvm::Value* AssignExpr::Emit(){ | |
319 | + llvm::Value * leftval= left->Emit(); | |
320 | + llvm::Value * rightval=right->Emit(); | |
321 | + llvm::LoadInst* leftLookup= llvm::cast<llvm::LoadInst>(leftval); | |
322 | + llvm::BasicBlock* basicBlock= irgen.GetBasicBlock(); | |
323 | + llvm::Value *targetL = leftLookup->getPointerOperand(); | |
324 | + llvm::Value * retVal = NULL; | |
325 | + llvm::Value *binOp = NULL; | |
326 | + | |
327 | + if(dynamic_cast<FieldAccess*>(left)!=NULL){ | |
328 | + return (dynamic_cast<FieldAccess*>(left)->FieldStore(rightval,op->getToken()[0])); | |
324 | 329 | } |
325 | - leftval = left->Emit(); | |
326 | - rightval = right->Emit(); | |
327 | - | |
328 | - string operationStr(op->getToken()); | |
329 | - | |
330 | - VarExpr * vd = dynamic_cast<VarExpr *>(left); | |
331 | - | |
332 | - llvm::Value * storeInst = NULL; | |
333 | - if ( operationStr.compare("+=") == 0 ){ | |
334 | - if (leftval->getType()->isIntegerTy()){ | |
335 | - storeInst = llvm::BinaryOperator::CreateAdd(leftval, rightval, "", irgen.GetBasicBlock()); | |
336 | - if (vd){ | |
337 | - vd->AddressStore(storeInst); | |
338 | - return storeInst; | |
339 | - } | |
330 | + if(op->IsOp("=")){ | |
331 | + new llvm::StoreInst(rightval,targetL,basicBlock); | |
332 | + retVal=targetL; | |
333 | + } | |
334 | + else if(op->IsOp("+=")){ | |
335 | + if( leftval->getType()== convertType(Type::intType)){ | |
336 | + binOp=llvm::BinaryOperator::CreateAdd(leftval,rightval,"BinaryInt AddEqual", basicBlock); | |
337 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
340 | 338 | } |
341 | - else if (leftval->getType()->isFloatingPointTy() || rightval->getType()->isVectorTy()){ | |
342 | - storeInst = llvm::BinaryOperator::CreateFAdd(leftval, rightval, "", irgen.GetBasicBlock()); | |
343 | - if (vd){ | |
344 | - vd->AddressStore(storeInst); | |
345 | - return storeInst; | |
346 | - } | |
339 | + if(leftval->getType()==convertType(Type::floatType)){ | |
340 | + binOp=llvm::BinaryOperator::CreateFAdd(leftval,rightval,"BinaryFloat AddEqual", basicBlock); | |
341 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
347 | 342 | } |
348 | - else{ | |
349 | - storeInst = convert(leftval, rightval, 0); | |
350 | - if (vd){ | |
351 | - vd->AddressStore(storeInst); | |
352 | - return storeInst; | |
353 | - } | |
343 | + if(leftval->getType()==convertType(Type::vec2Type)){ | |
344 | + binOp=llvm::BinaryOperator::CreateFAdd(leftval,rightval,"Vec2 AddEqual", basicBlock); | |
345 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
346 | + } | |
347 | + if(leftval->getType()==convertType(Type::vec3Type)){ | |
348 | + binOp=llvm::BinaryOperator::CreateFAdd(leftval,rightval,"Vec3 AddEqual", basicBlock); | |
349 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
350 | + } | |
351 | + if(leftval->getType()==convertType(Type::vec4Type)){ | |
352 | + binOp=llvm::BinaryOperator::CreateFAdd(leftval,rightval,"Vec4 AddEqual", basicBlock); | |
353 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
354 | 354 | } |
355 | 355 | } |
356 | - else if ( operationStr.compare("=") == 0 ){ | |
357 | - if (vd){ | |
358 | - vd->AddressStore(rightval); | |
359 | - return rightval; | |
356 | + else if(op->IsOp("-=")){ | |
357 | + if(leftval->getType()==convertType(Type::intType)){ | |
358 | + binOp=llvm::BinaryOperator::CreateSub(leftval,rightval,"BinaryInt SubEqual", basicBlock); | |
359 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
360 | + } | |
361 | + if(leftval->getType()==convertType(Type::floatType)){ | |
362 | + binOp=llvm::BinaryOperator::CreateFSub(leftval,rightval,"BinaryFloat SubEqual", basicBlock); | |
363 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
364 | + } | |
365 | + if(leftval->getType()==convertType(Type::vec2Type)){ | |
366 | + binOp=llvm::BinaryOperator::CreateFSub(leftval,rightval,"Vec2 SubEqual", basicBlock); | |
367 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
368 | + } | |
369 | + if(leftval->getType()==convertType(Type::vec3Type)){ | |
370 | + binOp=llvm::BinaryOperator::CreateFSub(leftval,rightval,"Vec3 SubEqual", basicBlock); | |
371 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
372 | + } | |
373 | + if(leftval->getType()==convertType(Type::vec4Type)){ | |
374 | + binOp=llvm::BinaryOperator::CreateSub(leftval,rightval,"Vec4 SubEqual", basicBlock); | |
375 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
360 | 376 | } |
361 | - return ((VarExpr *) left)->AddressStore(rightval); | |
362 | 377 | } |
363 | - else if ( operationStr.compare("-=") == 0 ){ | |
364 | - if (leftval->getType()->isIntegerTy()){ | |
365 | - storeInst = llvm::BinaryOperator::CreateSub(leftval, rightval, "", irgen.GetBasicBlock()); | |
366 | - if (vd){ | |
367 | - vd->AddressStore(storeInst); | |
368 | - return storeInst; | |
369 | - } | |
378 | + else if(op->IsOp("*=")){ | |
379 | + if(leftval->getType()==convertType(Type::intType)){ | |
380 | + binOp=llvm::BinaryOperator::CreateMul(leftval,rightval,"BinaryInt MulEqual", basicBlock); | |
381 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
370 | 382 | } |
371 | - else if (leftval->getType()->isFloatingPointTy() || rightval->getType()->isVectorTy()){ | |
372 | - storeInst = llvm::BinaryOperator::CreateFSub(leftval, rightval, "", irgen.GetBasicBlock()); | |
373 | - if (vd){ | |
374 | - vd->AddressStore(storeInst); | |
375 | - return storeInst; | |
376 | - } | |
383 | + if(leftval->getType()==convertType(Type::floatType)){ | |
384 | + binOp=llvm::BinaryOperator::CreateFMul(leftval,rightval,"BinaryFloat MulEqual", basicBlock); | |
385 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
377 | 386 | } |
378 | - else{ | |
379 | - storeInst = convert(leftval, rightval, 1); | |
380 | - if (vd){ | |
381 | - vd->AddressStore(storeInst); | |
382 | - return storeInst; | |
383 | - } | |
387 | + if(leftval->getType()==convertType(Type::vec2Type)){ | |
388 | + binOp=llvm::BinaryOperator::CreateFMul(leftval,rightval,"Vec2 MulEqual", basicBlock); | |
389 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
390 | + } | |
391 | + if(leftval->getType()==convertType(Type::vec3Type)){ | |
392 | + binOp=llvm::BinaryOperator::CreateFMul(leftval,rightval,"Vec3 MulEqual", basicBlock); | |
393 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
394 | + } | |
395 | + if(leftval->getType()==convertType(Type::vec4Type)){ | |
396 | + binOp=llvm::BinaryOperator::CreateFMul(leftval,rightval,"Vec4 MulEqual", basicBlock); | |
397 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
384 | 398 | } |
385 | 399 | } |
386 | - else if ( operationStr.compare("/=") == 0 ){ | |
387 | - if (leftval->getType()->isIntegerTy()){ | |
388 | - storeInst = llvm::BinaryOperator::CreateSDiv(leftval, rightval, "", irgen.GetBasicBlock()); | |
389 | - if (vd){ | |
390 | - vd->AddressStore(storeInst); | |
391 | - return storeInst; | |
392 | - } | |
400 | + else if(op->IsOp("/=")){ | |
401 | + if(leftval->getType()==convertType(Type::intType)){ | |
402 | + binOp=llvm::BinaryOperator::CreateSDiv(leftval,rightval,"BinaryInt DivEqual", basicBlock); | |
403 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
393 | 404 | } |
394 | - else if (leftval->getType()->isFloatingPointTy() || rightval->getType()->isVectorTy()){ | |
395 | - storeInst = llvm::BinaryOperator::CreateFDiv(leftval, rightval, "", irgen.GetBasicBlock()); | |
396 | - if (vd){ | |
397 | - vd->AddressStore(storeInst); | |
398 | - return storeInst; | |
399 | - } | |
405 | + if(leftval->getType()==convertType(Type::floatType)){ | |
406 | + binOp=llvm::BinaryOperator::CreateFDiv(leftval,rightval,"BinaryFloat DivEqual", basicBlock); | |
407 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
400 | 408 | } |
401 | - else{ | |
402 | - storeInst = convert(leftval, rightval, 2); | |
403 | - if (vd){ | |
404 | - vd->AddressStore(storeInst); | |
405 | - return storeInst; | |
406 | - } | |
409 | + if(leftval->getType()==convertType(Type::vec2Type)){ | |
410 | + binOp=llvm::BinaryOperator::CreateFDiv(leftval,rightval,"Vec2 DivEqual", basicBlock); | |
411 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
412 | + } | |
413 | + if(leftval->getType()==convertType(Type::vec3Type)){ | |
414 | + binOp=llvm::BinaryOperator::CreateFDiv(leftval,rightval,"Vec3 DivEqual", basicBlock); | |
415 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
416 | + } | |
417 | + if(leftval->getType()==convertType(Type::vec4Type)){ | |
418 | + binOp=llvm::BinaryOperator::CreateFDiv(leftval,rightval,"Vec4 DivEqual", basicBlock); | |
419 | + new llvm::StoreInst(binOp,targetL,basicBlock); | |
407 | 420 | } |
408 | 421 | } |
409 | - else if ( operationStr.compare("*=") == 0 ){ | |
410 | - if (leftval->getType()->isIntegerTy()){ | |
411 | - storeInst = llvm::BinaryOperator::CreateMul(leftval, rightval, "", irgen.GetBasicBlock()); | |
412 | - if (vd){ | |
413 | - vd->AddressStore(storeInst); | |
414 | - return storeInst; | |
415 | - } | |
422 | + | |
423 | + return rightval; | |
424 | +} | |
425 | + | |
426 | +llvm::Value * FieldAccess::FieldStore(llvm::Value* val, char oper){ | |
427 | + llvm::Value* baseVal = getBase()->Emit(); | |
428 | + string fieldName = getField()->GetName(); | |
429 | + llvm::Constant* constVal=NULL; | |
430 | + llvm::Value* exLeftElmt= NULL; | |
431 | + llvm::Value* exRightElmt= NULL; | |
432 | + llvm::Value* operVal = NULL; | |
433 | + if(fieldName.length()==1){ | |
434 | + char charVal=fieldName.at(0); | |
435 | + exLeftElmt= llvm::ExtractElementInst::Create(baseVal,FindChar(charVal),"ExtractedVal",irgen.GetBasicBlock()); | |
436 | + if(oper=='+'){ | |
437 | + operVal=llvm::BinaryOperator::CreateFAdd(exLeftElmt,val,"Field FAdd",irgen.GetBasicBlock()); | |
416 | 438 | } |
417 | - else if (leftval->getType()->isFloatingPointTy() || rightval->getType()->isVectorTy()){ | |
418 | - storeInst = llvm::BinaryOperator::CreateFMul(leftval, rightval, "", irgen.GetBasicBlock()); | |
419 | - if (vd){ | |
420 | - vd->AddressStore(storeInst); | |
421 | - return storeInst; | |
422 | - } | |
439 | + else if(oper=='-'){ | |
440 | + operVal=llvm::BinaryOperator::CreateFSub(exLeftElmt,val,"Field FSub",irgen.GetBasicBlock()); | |
441 | + } | |
442 | + else if(oper=='*'){ | |
443 | + operVal=llvm::BinaryOperator::CreateFMul(exLeftElmt,val,"Field FMul",irgen.GetBasicBlock()); | |
444 | + } | |
445 | + else if(oper=='/'){ | |
446 | + operVal=llvm::BinaryOperator::CreateFDiv(exLeftElmt,val,"Field FDiv",irgen.GetBasicBlock()); | |
423 | 447 | } |
424 | 448 | else{ |
425 | - storeInst = convert(leftval, rightval, 3); | |
426 | - if (vd){ | |
427 | - vd->AddressStore(storeInst); | |
428 | - return storeInst; | |
449 | + operVal=val; | |
450 | + } | |
451 | + baseVal= llvm::InsertElementInst::Create(baseVal,operVal,FindChar(charVal),"Base",irgen.GetBasicBlock()); | |
452 | + } | |
453 | + else{ | |
454 | + for(int i=0; i<fieldName.length();i++){ | |
455 | + char charVal= fieldName.at(i); | |
456 | + constVal = llvm::ConstantInt::get(irgen.GetIntType(),i, false); | |
457 | + exRightElmt=llvm::ExtractElementInst::Create(val,constVal,"ExtractedRightVal",irgen.GetBasicBlock()); | |
458 | + exLeftElmt=llvm::ExtractElementInst::Create(baseVal,constVal,"ExtractedVal",irgen.GetBasicBlock()); | |
459 | + if(oper=='+'){ | |
460 | + operVal=llvm::BinaryOperator::CreateFAdd(exLeftElmt,val,"Field FAdd",irgen.GetBasicBlock()); | |
461 | + } | |
462 | + else if(oper=='-'){ | |
463 | + operVal=llvm::BinaryOperator::CreateFSub(exLeftElmt,val,"Field FSub",irgen.GetBasicBlock()); | |
429 | 464 | } |
465 | + else if(oper=='*'){ | |
466 | + operVal=llvm::BinaryOperator::CreateFMul(exLeftElmt,val,"Field FMul",irgen.GetBasicBlock()); | |
467 | + } | |
468 | + else if(oper=='/'){ | |
469 | + operVal=llvm::BinaryOperator::CreateFDiv(exLeftElmt,val,"Field FDiv",irgen.GetBasicBlock()); | |
470 | + } | |
471 | + else{ | |
472 | + operVal=exRightElmt; | |
473 | + } | |
474 | + baseVal=llvm::InsertElementInst::Create(baseVal,operVal,FindChar(charVal),"Base",irgen.GetBasicBlock()); | |
430 | 475 | } |
431 | 476 | } |
432 | - return NULL; | |
477 | + //dynamic_cast<VarExpr*>(base)->StoreVal(baseVal); | |
478 | + return val; | |
479 | +} | |
480 | + | |
481 | +llvm::Value* FieldAccess::FindChar(char c){ | |
482 | + llvm::Value* CharValue=NULL; | |
483 | + if(c=='x'){ | |
484 | + CharValue=llvm::ConstantInt::get(irgen.GetIntType(),0); | |
485 | + } | |
486 | + else if(c=='y'){ | |
487 | + CharValue=llvm::ConstantInt::get(irgen.GetIntType(),1); | |
488 | + } | |
489 | + else if(c=='z'){ | |
490 | + CharValue=llvm::ConstantInt::get(irgen.GetIntType(),2); | |
491 | + } | |
492 | + else if(c=='w'){ | |
493 | + CharValue=llvm::ConstantInt::get(irgen.GetIntType(),3); | |
494 | + } | |
495 | + return CharValue; | |
433 | 496 | } |
434 | 497 | |
435 | 498 | llvm::Value * AssignExpr::convert(llvm::Value * vec, llvm::Value * val, int status ){ |
... | ... | @@ -558,15 +621,15 @@ llvm::Value * FieldAccess::Emit(){ |
558 | 621 | maskI.push_back(llvm::ConstantInt::get(intTyp, 0)); |
559 | 622 | valNum=0; |
560 | 623 | } |
561 | - else if(*ptr='y'){ | |
624 | + else if(*ptr=='y'){ | |
562 | 625 | maskI.push_back(llvm::ConstantInt::get(intTyp, 1)); |
563 | 626 | valNum=1; |
564 | 627 | } |
565 | - else if(*ptr='z'){ | |
628 | + else if(*ptr=='z'){ | |
566 | 629 | maskI.push_back(llvm::ConstantInt::get(intTyp, 2)); |
567 | 630 | valNum=2; |
568 | 631 | } |
569 | - else if(*ptr='w'){ | |
632 | + else if(*ptr=='w'){ | |
570 | 633 | maskI.push_back(llvm::ConstantInt::get(intTyp, 3)); |
571 | 634 | valNum=3; |
572 | 635 | } |
... | ... | @@ -582,3 +645,28 @@ llvm::Value * FieldAccess::Emit(){ |
582 | 645 | llvm::Value * val = new llvm::ShuffleVectorInst(baseF,llvm::UndefValue::get(baseF->getType()), masky,"",irgen.GetBasicBlock()); |
583 | 646 | return val; |
584 | 647 | } |
648 | + | |
649 | +llvm::Value * ArrayAccess::Emit(){ | |
650 | + Expr * base= GetBase(); | |
651 | + Expr * sub= GetSubScript(); | |
652 | + std::cerr<< "arrayAccess"<<"\n"; | |
653 | + | |
654 | + if(isInCurrentScope( dynamic_cast< VarExpr* >(base)->GetIdentifier()->GetName())){ | |
655 | + std::cerr<< "arrayAccess2"<<"\n"; | |
656 | + | |
657 | + llvm::Value * val= findSymbol(dynamic_cast< VarExpr* >(base)->GetIdentifier()->GetName()).second; | |
658 | + llvm::Value * subscrVal = sub->Emit(); | |
659 | + std::vector <llvm::Value*> vect; | |
660 | + vect.push_back(llvm::ConstantInt::get(irgen.GetIntType(),0)); | |
661 | + vect.push_back((llvm::Value *const &) subscrVal); | |
662 | + llvm::ArrayRef<llvm::Value *> valList(vect); | |
663 | + llvm::Value *elmt= llvm::GetElementPtrInst::Create(val,valList,"ARRAYACCESS",irgen.GetBasicBlock()); | |
664 | + | |
665 | + return new llvm::LoadInst(elmt,"ARRAYACCESS",irgen.GetBasicBlock()); | |
666 | + } | |
667 | + else{ | |
668 | + return NULL; | |
669 | + } | |
670 | +} | |
671 | + | |
672 | + |
ast_expr.h
View file @
992208e
... | ... | @@ -199,6 +199,11 @@ class ArrayAccess : public LValue |
199 | 199 | ArrayAccess(yyltype loc, Expr *base, Expr *subscript); |
200 | 200 | const char *GetPrintNameForNode() { return "ArrayAccess"; } |
201 | 201 | void PrintChildren(int indentLevel); |
202 | + Expr *GetBase(){ return base; } | |
203 | + Expr *GetSubScript(){ return subscript;} | |
204 | + llvm::Value *Emit(); | |
205 | + | |
206 | + llvm::Value *EmitHelper(llvm::Value* rightH); | |
202 | 207 | }; |
203 | 208 | |
204 | 209 | /* Note that field access is used both for qualified names |
... | ... | @@ -219,6 +224,10 @@ class FieldAccess : public LValue |
219 | 224 | Expr * getBase(){ return base; } |
220 | 225 | Identifier * getField(){return field;} |
221 | 226 | llvm::Value *Emit(); |
227 | + | |
228 | + llvm::Value * FieldStore(llvm::Value* val, char oper); | |
229 | + | |
230 | + llvm::Value *FindChar(char c); | |
222 | 231 | }; |
223 | 232 | |
224 | 233 | /* Like field access, call is used both for qualified base.field() |
ast_stmt.cc
View file @
992208e
... | ... | @@ -259,6 +259,7 @@ llvm::Value * WhileStmt::Emit(){ |
259 | 259 | |
260 | 260 | //if statement |
261 | 261 | llvm::Value * IfStmt::Emit(){ |
262 | + | |
262 | 263 | llvm::LLVMContext * context = irgen.GetContext(); |
263 | 264 | llvm::Function * func = irgen.GetFunction(); |
264 | 265 | llvm::BasicBlock * elseBlock = NULL; |
... | ... | @@ -266,6 +267,7 @@ llvm::Value * IfStmt::Emit(){ |
266 | 267 | llvm::BasicBlock * footBlock = llvm::BasicBlock::Create(*context, "footBlock", func); |
267 | 268 | llvm::Value * val; |
268 | 269 | llvm::Value * condition = test->Emit(); |
270 | + | |
269 | 271 | if(elseBody) |
270 | 272 | { |
271 | 273 | elseBlock = llvm::BasicBlock::Create(*context, "elseBlock", func); |
... | ... | @@ -280,6 +282,7 @@ llvm::Value * IfStmt::Emit(){ |
280 | 282 | { |
281 | 283 | val = llvm::BranchInst::Create(footBlock, irgen.GetBasicBlock()); |
282 | 284 | } |
285 | + | |
283 | 286 | popScope(); |
284 | 287 | |
285 | 288 | if(elseBody) |
ast_type.h
View file @
992208e
... | ... | @@ -90,6 +90,7 @@ class ArrayType : public Type |
90 | 90 | void PrintChildren(int indentLevel); |
91 | 91 | void PrintToStream(ostream& out) { out << elemType << "[]"; } |
92 | 92 | Type *GetElemType() {return elemType;} |
93 | + int GetElemCount(){return elemCount;} | |
93 | 94 | }; |
94 | 95 | |
95 | 96 | llvm::Type* convertType(Type* t); |