Austin Sun / CSE131-PA4

Download as
Browse Code ยป

Commit 521d50fcc059a8c7793f8535f7e88a0cfb7b2009

Authored by Austin Sun
1 parent 1b3210488e
Exists in master

wol

Showing 2 changed files with 124 additions and 85 deletions Side-by-side Diff

ast_expr.cc View file @ 521d50f
... ... @@ -12,21 +12,21 @@
12 12 IntConstant::IntConstant(yyltype loc, int val) : Expr(loc) {
13 13 value = val;
14 14 }
15   -void IntConstant::PrintChildren(int indentLevel) {
  15 +void IntConstant::PrintChildren(int indentLevel) {
16 16 printf("%d", value);
17 17 }
18 18  
19 19 FloatConstant::FloatConstant(yyltype loc, double val) : Expr(loc) {
20 20 value = val;
21 21 }
22   -void FloatConstant::PrintChildren(int indentLevel) {
  22 +void FloatConstant::PrintChildren(int indentLevel) {
23 23 printf("%g", value);
24 24 }
25 25  
26 26 BoolConstant::BoolConstant(yyltype loc, bool val) : Expr(loc) {
27 27 value = val;
28 28 }
29   -void BoolConstant::PrintChildren(int indentLevel) {
  29 +void BoolConstant::PrintChildren(int indentLevel) {
30 30 printf("%s", value ? "true" : "false");
31 31 }
32 32  
... ... @@ -104,7 +104,7 @@
104 104 subscript->Print(indentLevel+1, "(subscript) ");
105 105 }
106 106  
107   -FieldAccess::FieldAccess(Expr *b, Identifier *f)
  107 +FieldAccess::FieldAccess(Expr *b, Identifier *f)
108 108 : LValue(b? Join(b->GetLocation(), f->GetLocation()) : *f->GetLocation()) {
109 109 Assert(f != NULL); // b can be be NULL (just means no explicit base)
110 110 base = b;
111 111  
... ... @@ -246,72 +246,7 @@
246 246  
247 247 //----------------------------------------------------------------------------------------
248 248 //----------------------------------------------------------------------------------------
249   -llvm::Value * AssignExpr::AssignField(){
250   - FieldAccess * f = (FieldAccess *) left;
251   - llvm::Value * rightval = right->Emit();
252   - string operationStr(op->getToken());
253   - bool isFloat = rightval->getType()->isFloatingPointTy();
254   - llvm::Type * intTyp = irgen.GetIntType();
255   - char * ptr = f->getField()->GetName();;
256 249  
257   - std::vector<llvm::Constant *> maskI;
258   - for(; *ptr; ptr++){
259   - switch(*ptr){
260   - case 'x':
261   - maskI.push_back(llvm::ConstantInt::get(intTyp, 0));
262   - break;
263   - case 'y':
264   - maskI.push_back(llvm::ConstantInt::get(intTyp, 1));
265   - break;
266   - case 'z':
267   - maskI.push_back(llvm::ConstantInt::get(intTyp, 2));
268   - break;
269   - case 'w':
270   - maskI.push_back(llvm::ConstantInt::get(intTyp, 3));
271   - break;
272   - default:
273   - break;
274   - }
275   - }
276   - llvm::Value * element;
277   - llvm::Value * rightop = rightval;
278   - llvm::Value * base_field = f->getBase()->Emit();
279   - llvm::Value * storeInst = f->getBase()->Emit();
280   -
281   -
282   - for (int i = 0; i < maskI.size(); i++){
283   - element = llvm::ExtractElementInst::Create (base_field, maskI[i], "", irgen.GetBasicBlock());
284   - if (rightval->getType()->isVectorTy()){
285   - rightop = llvm::ExtractElementInst::Create(rightval, llvm::ConstantInt::get(intTyp, i), "", irgen.GetBasicBlock());
286   - }
287   - if (!operationStr.compare("=")){
288   - storeInst = llvm::InsertElementInst::Create (storeInst, rightop, maskI[i], "", irgen.GetBasicBlock());
289   - }
290   - if (!operationStr.compare("+=")){
291   - element = llvm::BinaryOperator::CreateFAdd(element, rightop, "", irgen.GetBasicBlock());
292   - storeInst = llvm::InsertElementInst::Create (storeInst, element, maskI[i], "", irgen.GetBasicBlock());
293   - }
294   - if (!operationStr.compare("-=")){
295   - element = llvm::BinaryOperator::CreateFSub(element, rightop, "", irgen.GetBasicBlock());
296   - storeInst = llvm::InsertElementInst::Create (storeInst, element, maskI[i], "", irgen.GetBasicBlock());
297   - }
298   - if (!operationStr.compare("*=")){
299   - element = llvm::BinaryOperator::CreateFMul(element, rightop, "", irgen.GetBasicBlock());
300   - storeInst = llvm::InsertElementInst::Create (storeInst, element, maskI[i], "", irgen.GetBasicBlock());
301   - }
302   - if (!operationStr.compare("/=")){
303   - element = llvm::BinaryOperator::CreateFDiv(element, rightop, "", irgen.GetBasicBlock());
304   - storeInst = llvm::InsertElementInst::Create (storeInst, element, maskI[i], "", irgen.GetBasicBlock());
305   - }
306   - }
307   - VarExpr * ve = dynamic_cast<VarExpr *>(f->getBase());
308   - ve->AddressStore(storeInst);
309   - if (isFloat){
310   - return llvm::ExtractElementInst::Create (storeInst, maskI.back(), "", irgen.GetBasicBlock());
311   - }
312   - return storeInst;
313   -}
314   -
315 250 llvm::Value * AssignExpr::Emit(){
316 251 llvm::Value * leftval;
317 252 llvm::Value * rightval;
... ... @@ -328,14 +263,7 @@
328 263 VarExpr * vd = dynamic_cast<VarExpr *>(left);
329 264  
330 265 llvm::Value * storeInst = NULL;
331   - if ( operationStr.compare("=") == 0 ){
332   - if (vd){
333   - vd->AddressStore(rightval);
334   - return rightval;
335   - }
336   - return ((VarExpr *) left)->AddressStore(rightval);
337   - }
338   - else if ( operationStr.compare("+=") == 0 ){
  266 + if ( operationStr.compare("+=") == 0 ){
339 267 if (leftval->getType()->isIntegerTy()){
340 268 storeInst = llvm::BinaryOperator::CreateAdd(leftval, rightval, "", irgen.GetBasicBlock());
341 269 if (vd){
... ... @@ -358,6 +286,13 @@
358 286 }
359 287 }
360 288 }
  289 + else if ( operationStr.compare("=") == 0 ){
  290 + if (vd){
  291 + vd->AddressStore(rightval);
  292 + return rightval;
  293 + }
  294 + return ((VarExpr *) left)->AddressStore(rightval);
  295 + }
361 296 else if ( operationStr.compare("-=") == 0 ){
362 297 if (leftval->getType()->isIntegerTy()){
363 298 storeInst = llvm::BinaryOperator::CreateSub(leftval, rightval, "", irgen.GetBasicBlock());
364 299  
365 300  
366 301  
367 302  
368 303  
369 304  
370 305  
... ... @@ -381,46 +316,46 @@
381 316 }
382 317 }
383 318 }
384   - else if ( operationStr.compare("*=") == 0 ){
  319 + else if ( operationStr.compare("/=") == 0 ){
385 320 if (leftval->getType()->isIntegerTy()){
386   - storeInst = llvm::BinaryOperator::CreateMul(leftval, rightval, "", irgen.GetBasicBlock());
  321 + storeInst = llvm::BinaryOperator::CreateSDiv(leftval, rightval, "", irgen.GetBasicBlock());
387 322 if (vd){
388 323 vd->AddressStore(storeInst);
389 324 return storeInst;
390 325 }
391 326 }
392 327 else if (leftval->getType()->isFloatingPointTy() || rightval->getType()->isVectorTy()){
393   - storeInst = llvm::BinaryOperator::CreateFMul(leftval, rightval, "", irgen.GetBasicBlock());
  328 + storeInst = llvm::BinaryOperator::CreateFDiv(leftval, rightval, "", irgen.GetBasicBlock());
394 329 if (vd){
395 330 vd->AddressStore(storeInst);
396 331 return storeInst;
397 332 }
398 333 }
399 334 else{
400   - storeInst = convert(leftval, rightval, 3);
  335 + storeInst = convert(leftval, rightval, 2);
401 336 if (vd){
402 337 vd->AddressStore(storeInst);
403 338 return storeInst;
404 339 }
405 340 }
406 341 }
407   - else if ( operationStr.compare("/=") == 0 ){
  342 + else if ( operationStr.compare("*=") == 0 ){
408 343 if (leftval->getType()->isIntegerTy()){
409   - storeInst = llvm::BinaryOperator::CreateSDiv(leftval, rightval, "", irgen.GetBasicBlock());
  344 + storeInst = llvm::BinaryOperator::CreateMul(leftval, rightval, "", irgen.GetBasicBlock());
410 345 if (vd){
411 346 vd->AddressStore(storeInst);
412 347 return storeInst;
413 348 }
414 349 }
415 350 else if (leftval->getType()->isFloatingPointTy() || rightval->getType()->isVectorTy()){
416   - storeInst = llvm::BinaryOperator::CreateFDiv(leftval, rightval, "", irgen.GetBasicBlock());
  351 + storeInst = llvm::BinaryOperator::CreateFMul(leftval, rightval, "", irgen.GetBasicBlock());
417 352 if (vd){
418 353 vd->AddressStore(storeInst);
419 354 return storeInst;
420 355 }
421 356 }
422 357 else{
423   - storeInst = convert(leftval, rightval, 2);
  358 + storeInst = convert(leftval, rightval, 3);
424 359 if (vd){
425 360 vd->AddressStore(storeInst);
426 361 return storeInst;
... ... @@ -476,5 +411,108 @@
476 411 //value of symbol
477 412 llvm::StoreInst* storeInst = new llvm::StoreInst(store, symbol.second, "",irgen.GetBasicBlock());
478 413 return storeInst;
  414 +}
  415 +
  416 +llvm::Value * AssignExpr::AssignField(){
  417 + FieldAccess * f = (FieldAccess *) left;
  418 + llvm::Value * rightval = right->Emit();
  419 + string operationStr(op->getToken());
  420 + bool isFloat = rightval->getType()->isFloatingPointTy();
  421 + llvm::Type * intTyp = irgen.GetIntType();
  422 + char * ptr = f->getField()->GetName();;
  423 +
  424 + std::vector<llvm::Constant *> maskI;
  425 + for(; *ptr; ptr++){
  426 + if(*ptr =='x'){
  427 + maskI.push_back(llvm::ConstantInt::get(intTyp, 0));
  428 + }
  429 + else if(*ptr='y'){
  430 + maskI.push_back(llvm::ConstantInt::get(intTyp, 1));
  431 + }
  432 + else if(*ptr='z'){
  433 + maskI.push_back(llvm::ConstantInt::get(intTyp, 2));
  434 + }
  435 + else if(*ptr='w'){
  436 + maskI.push_back(llvm::ConstantInt::get(intTyp, 3));
  437 + }
  438 + }
  439 +
  440 + llvm::Value * element;
  441 + llvm::Value * rightop = rightval;
  442 + llvm::Value * baseF = f->getBase()->Emit();
  443 + llvm::Value * storeInst = f->getBase()->Emit();
  444 +
  445 +
  446 + for (int i = 0; i < maskI.size(); i++){
  447 + element = llvm::ExtractElementInst::Create (baseF, maskI[i], "", irgen.GetBasicBlock());
  448 + if (rightval->getType()->isVectorTy()){
  449 + rightop = llvm::ExtractElementInst::Create(rightval, llvm::ConstantInt::get(intTyp, i), "", irgen.GetBasicBlock());
  450 + }
  451 + if (!operationStr.compare("=")){
  452 + storeInst = llvm::InsertElementInst::Create (storeInst, rightop, maskI[i], "", irgen.GetBasicBlock());
  453 + }
  454 + if (!operationStr.compare("+=")){
  455 + element = llvm::BinaryOperator::CreateFAdd(element, rightop, "", irgen.GetBasicBlock());
  456 + storeInst = llvm::InsertElementInst::Create (storeInst, element, maskI[i], "", irgen.GetBasicBlock());
  457 + }
  458 + if (!operationStr.compare("-=")){
  459 + element = llvm::BinaryOperator::CreateFSub(element, rightop, "", irgen.GetBasicBlock());
  460 + storeInst = llvm::InsertElementInst::Create (storeInst, element, maskI[i], "", irgen.GetBasicBlock());
  461 + }
  462 + if (!operationStr.compare("*=")){
  463 + element = llvm::BinaryOperator::CreateFMul(element, rightop, "", irgen.GetBasicBlock());
  464 + storeInst = llvm::InsertElementInst::Create (storeInst, element, maskI[i], "", irgen.GetBasicBlock());
  465 + }
  466 + if (!operationStr.compare("/=")){
  467 + element = llvm::BinaryOperator::CreateFDiv(element, rightop, "", irgen.GetBasicBlock());
  468 + storeInst = llvm::InsertElementInst::Create (storeInst, element, maskI[i], "", irgen.GetBasicBlock());
  469 + }
  470 + }
  471 + VarExpr * ve = dynamic_cast<VarExpr *>(f->getBase());
  472 + ve->AddressStore(storeInst);
  473 + if (isFloat){
  474 + return llvm::ExtractElementInst::Create (storeInst, maskI.back(), "", irgen.GetBasicBlock());
  475 + }
  476 + return storeInst;
  477 +}
  478 +
  479 +
  480 +llvm::Value * FieldAccess::Emit(){
  481 + char * mask = this->getField()->GetName();
  482 + char * ptr = mask;
  483 +
  484 + llvm::Type * intTyp = irgen.GetIntType();
  485 + std::vector<llvm::Constant *> maskI;
  486 +
  487 + int count = 0;
  488 + int valNum = -1;
  489 + for(; *ptr; ptr++){
  490 + if(*ptr =='x'){
  491 + maskI.push_back(llvm::ConstantInt::get(intTyp, 0));
  492 + valNum=0;
  493 + }
  494 + else if(*ptr='y'){
  495 + maskI.push_back(llvm::ConstantInt::get(intTyp, 1));
  496 + valNum=1;
  497 + }
  498 + else if(*ptr='z'){
  499 + maskI.push_back(llvm::ConstantInt::get(intTyp, 2));
  500 + valNum=2;
  501 + }
  502 + else if(*ptr='w'){
  503 + maskI.push_back(llvm::ConstantInt::get(intTyp, 3));
  504 + valNum=3;
  505 + }
  506 + count++;
  507 + }
  508 + llvm::Value * elemt;
  509 + llvm::Value * baseF = base->Emit();
  510 + if (count == 1){
  511 + elemt = llvm::ExtractElementInst::Create (baseF, maskI.back(), "", irgen.GetBasicBlock());
  512 + return elemt;
  513 + }
  514 + llvm::ConstantVector *masky = (llvm::ConstantVector *) llvm::ConstantVector::get(maskI);
  515 + llvm::Value * val = new llvm::ShuffleVectorInst(baseF,llvm::UndefValue::get(baseF->getType()), masky,"",irgen.GetBasicBlock());
  516 + return val;
479 517 }
ast_expr.h View file @ 521d50f
... ... @@ -217,6 +217,7 @@
217 217 void PrintChildren(int indentLevel);
218 218 Expr * getBase(){ return base; }
219 219 Identifier * getField(){return field;}
  220 + llvm::Value *Emit();
220 221 };
221 222  
222 223 /* Like field access, call is used both for qualified base.field()