Austin Sun / CSE131-PA4

Compare View

switch
from
...
to
 
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);
irgen.h View file @ 992208e
... ... @@ -54,7 +54,7 @@ class IRGenerator {
54 54  
55 55 llvm::Type *GetMat4Type() const;
56 56  
57   - private:
  57 +private:
58 58 llvm::LLVMContext *context;
59 59 llvm::Module *module;
60 60