192101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner//===-- Execution.cpp - Implement code to simulate the program ------------===// 2d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 9d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman// 1092101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner// This file contains the actual instruction interpreter. 1192101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner// 1292101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner//===----------------------------------------------------------------------===// 1392101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 1463438cc9b02d715ef2ef470c5a4a6282c5fef406Brian Gaeke#define DEBUG_TYPE "interpreter" 1592101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner#include "Interpreter.h" 16d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/APInt.h" 17d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/Statistic.h" 18d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/CodeGen/IntrinsicLowering.h" 190b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Constants.h" 200b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/DerivedTypes.h" 210b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instructions.h" 22663ceeb948c526c705b38efd2075b7c80a190e5dChris Lattner#include "llvm/Support/CommandLine.h" 23551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "llvm/Support/Debug.h" 247d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin#include "llvm/Support/ErrorHandling.h" 25d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/GetElementPtrTypeIterator.h" 26a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer#include "llvm/Support/MathExtras.h" 27724441e64ad9dbf41579864d6364501aac8ba7dbGabor Greif#include <algorithm> 28ae9f3a3b7c915f725aef5a7250e88eaeddda03c6Anton Korobeynikov#include <cmath> 294af6de8f0a767a3892ff7682954cbd2ae2ca3de8Chris Lattnerusing namespace llvm; 30fe11a97fcde7c63109c3ad36570657807d0cd6efChris Lattner 31cecf56b0691b1f3e9ff4435b60f9bcbfd79f155aChris LattnerSTATISTIC(NumDynamicInsts, "Number of dynamic instructions executed"); 32d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 33663ceeb948c526c705b38efd2075b7c80a190e5dChris Lattnerstatic cl::opt<bool> PrintVolatile("interpreter-print-volatile", cl::Hidden, 34663ceeb948c526c705b38efd2075b7c80a190e5dChris Lattner cl::desc("make the interpreter print every volatile load and store")); 35663ceeb948c526c705b38efd2075b7c80a190e5dChris Lattner 362e42d3a3060ff0c3d4c419f17493bc6a7683e9d0Chris Lattner//===----------------------------------------------------------------------===// 37e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer// Various Helper Functions 3839bb5b4ee9f7b0b36f3c304a2c813e38fa4db81fChris Lattner//===----------------------------------------------------------------------===// 397301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner 4039bb5b4ee9f7b0b36f3c304a2c813e38fa4db81fChris Lattnerstatic void SetValue(Value *V, GenericValue Val, ExecutionContext &SF) { 4103e43dcfe7a30f01f9ad606d265efd6cb8fe381cBrian Gaeke SF.Values[V] = Val; 4239bb5b4ee9f7b0b36f3c304a2c813e38fa4db81fChris Lattner} 4339bb5b4ee9f7b0b36f3c304a2c813e38fa4db81fChris Lattner 442adcd83b89d1eb38c7118861454b528d5812aad0Chris Lattner//===----------------------------------------------------------------------===// 4592101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner// Binary Instruction Implementations 4692101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner//===----------------------------------------------------------------------===// 4792101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 4892101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner#define IMPLEMENT_BINARY_OPERATOR(OP, TY) \ 49f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Type::TY##TyID: \ 50f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.TY##Val = Src1.TY##Val OP Src2.TY##Val; \ 51f9536330d6271b242572eb1b8011b051b09e128cReid Spencer break 5292101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 53ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohmanstatic void executeFAddInst(GenericValue &Dest, GenericValue Src1, 54db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner GenericValue Src2, Type *Ty) { 55f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner switch (Ty->getTypeID()) { 5692101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner IMPLEMENT_BINARY_OPERATOR(+, Float); 5792101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner IMPLEMENT_BINARY_OPERATOR(+, Double); 5892101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner default: 59ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for FAdd instruction: " << *Ty << "\n"; 60c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 6192101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner } 6292101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner} 6392101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 64ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohmanstatic void executeFSubInst(GenericValue &Dest, GenericValue Src1, 65db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner GenericValue Src2, Type *Ty) { 66f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner switch (Ty->getTypeID()) { 6792101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner IMPLEMENT_BINARY_OPERATOR(-, Float); 6892101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner IMPLEMENT_BINARY_OPERATOR(-, Double); 6992101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner default: 70ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for FSub instruction: " << *Ty << "\n"; 71c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 7292101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner } 7392101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner} 7492101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 75ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohmanstatic void executeFMulInst(GenericValue &Dest, GenericValue Src1, 76db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner GenericValue Src2, Type *Ty) { 77f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner switch (Ty->getTypeID()) { 78c25931673092b1dae646aeeac1d18f75d9640ec7Chris Lattner IMPLEMENT_BINARY_OPERATOR(*, Float); 79c25931673092b1dae646aeeac1d18f75d9640ec7Chris Lattner IMPLEMENT_BINARY_OPERATOR(*, Double); 80c25931673092b1dae646aeeac1d18f75d9640ec7Chris Lattner default: 81ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for FMul instruction: " << *Ty << "\n"; 82c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 83c25931673092b1dae646aeeac1d18f75d9640ec7Chris Lattner } 84c25931673092b1dae646aeeac1d18f75d9640ec7Chris Lattner} 85c25931673092b1dae646aeeac1d18f75d9640ec7Chris Lattner 86e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencerstatic void executeFDivInst(GenericValue &Dest, GenericValue Src1, 87db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner GenericValue Src2, Type *Ty) { 881628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer switch (Ty->getTypeID()) { 89c25931673092b1dae646aeeac1d18f75d9640ec7Chris Lattner IMPLEMENT_BINARY_OPERATOR(/, Float); 90c25931673092b1dae646aeeac1d18f75d9640ec7Chris Lattner IMPLEMENT_BINARY_OPERATOR(/, Double); 91c25931673092b1dae646aeeac1d18f75d9640ec7Chris Lattner default: 92ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for FDiv instruction: " << *Ty << "\n"; 93c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 94bb76f02756dded5d43d1032ac1c8bfcfd4e76e5dChris Lattner } 95bb76f02756dded5d43d1032ac1c8bfcfd4e76e5dChris Lattner} 96bb76f02756dded5d43d1032ac1c8bfcfd4e76e5dChris Lattner 97e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencerstatic void executeFRemInst(GenericValue &Dest, GenericValue Src1, 98db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner GenericValue Src2, Type *Ty) { 99f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner switch (Ty->getTypeID()) { 100bb76f02756dded5d43d1032ac1c8bfcfd4e76e5dChris Lattner case Type::FloatTyID: 101bb76f02756dded5d43d1032ac1c8bfcfd4e76e5dChris Lattner Dest.FloatVal = fmod(Src1.FloatVal, Src2.FloatVal); 102bb76f02756dded5d43d1032ac1c8bfcfd4e76e5dChris Lattner break; 103bb76f02756dded5d43d1032ac1c8bfcfd4e76e5dChris Lattner case Type::DoubleTyID: 104bb76f02756dded5d43d1032ac1c8bfcfd4e76e5dChris Lattner Dest.DoubleVal = fmod(Src1.DoubleVal, Src2.DoubleVal); 105bb76f02756dded5d43d1032ac1c8bfcfd4e76e5dChris Lattner break; 106bb76f02756dded5d43d1032ac1c8bfcfd4e76e5dChris Lattner default: 107ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for Rem instruction: " << *Ty << "\n"; 108c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 109c25931673092b1dae646aeeac1d18f75d9640ec7Chris Lattner } 110c25931673092b1dae646aeeac1d18f75d9640ec7Chris Lattner} 111c25931673092b1dae646aeeac1d18f75d9640ec7Chris Lattner 112f9536330d6271b242572eb1b8011b051b09e128cReid Spencer#define IMPLEMENT_INTEGER_ICMP(OP, TY) \ 113f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Type::IntegerTyID: \ 114f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = APInt(1,Src1.IntVal.OP(Src2.IntVal)); \ 115f9536330d6271b242572eb1b8011b051b09e128cReid Spencer break; 11692101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 117fd506f551d2ca89cb757c75faf87809d9d07548dChris Lattner// Handle pointers specially because they must be compared with only as much 118fd506f551d2ca89cb757c75faf87809d9d07548dChris Lattner// width as the host has. We _do not_ want to be comparing 64 bit values when 119fd506f551d2ca89cb757c75faf87809d9d07548dChris Lattner// running on a 32-bit target, otherwise the upper 32 bits might mess up 120fd506f551d2ca89cb757c75faf87809d9d07548dChris Lattner// comparisons if they contain garbage. 121a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer#define IMPLEMENT_POINTER_ICMP(OP) \ 122fd506f551d2ca89cb757c75faf87809d9d07548dChris Lattner case Type::PointerTyID: \ 123f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = APInt(1,(void*)(intptr_t)Src1.PointerVal OP \ 124f9536330d6271b242572eb1b8011b051b09e128cReid Spencer (void*)(intptr_t)Src2.PointerVal); \ 125f9536330d6271b242572eb1b8011b051b09e128cReid Spencer break; 126fd506f551d2ca89cb757c75faf87809d9d07548dChris Lattner 127e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencerstatic GenericValue executeICMP_EQ(GenericValue Src1, GenericValue Src2, 128db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 129e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer GenericValue Dest; 130e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (Ty->getTypeID()) { 131f9536330d6271b242572eb1b8011b051b09e128cReid Spencer IMPLEMENT_INTEGER_ICMP(eq,Ty); 132a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer IMPLEMENT_POINTER_ICMP(==); 133e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer default: 134ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for ICMP_EQ predicate: " << *Ty << "\n"; 135c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 136e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 137e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return Dest; 138e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer} 139e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 140e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencerstatic GenericValue executeICMP_NE(GenericValue Src1, GenericValue Src2, 141db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 142e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer GenericValue Dest; 143e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (Ty->getTypeID()) { 144f9536330d6271b242572eb1b8011b051b09e128cReid Spencer IMPLEMENT_INTEGER_ICMP(ne,Ty); 145a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer IMPLEMENT_POINTER_ICMP(!=); 146e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer default: 147ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for ICMP_NE predicate: " << *Ty << "\n"; 148c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 149e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 150e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return Dest; 151e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer} 152e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 153e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencerstatic GenericValue executeICMP_ULT(GenericValue Src1, GenericValue Src2, 154db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 155e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer GenericValue Dest; 156e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (Ty->getTypeID()) { 157f9536330d6271b242572eb1b8011b051b09e128cReid Spencer IMPLEMENT_INTEGER_ICMP(ult,Ty); 158a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer IMPLEMENT_POINTER_ICMP(<); 159e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer default: 160ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for ICMP_ULT predicate: " << *Ty << "\n"; 161c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 162e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 163e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return Dest; 164e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer} 165e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 166e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencerstatic GenericValue executeICMP_SLT(GenericValue Src1, GenericValue Src2, 167db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 168e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer GenericValue Dest; 169e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (Ty->getTypeID()) { 170f9536330d6271b242572eb1b8011b051b09e128cReid Spencer IMPLEMENT_INTEGER_ICMP(slt,Ty); 171a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer IMPLEMENT_POINTER_ICMP(<); 172e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer default: 173ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for ICMP_SLT predicate: " << *Ty << "\n"; 174c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 175e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 176e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return Dest; 177e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer} 178e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 179e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencerstatic GenericValue executeICMP_UGT(GenericValue Src1, GenericValue Src2, 180db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 181e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer GenericValue Dest; 182e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (Ty->getTypeID()) { 183f9536330d6271b242572eb1b8011b051b09e128cReid Spencer IMPLEMENT_INTEGER_ICMP(ugt,Ty); 184a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer IMPLEMENT_POINTER_ICMP(>); 185e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer default: 186ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for ICMP_UGT predicate: " << *Ty << "\n"; 187c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 188e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 189e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return Dest; 190e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer} 191e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 192e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencerstatic GenericValue executeICMP_SGT(GenericValue Src1, GenericValue Src2, 193db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 194e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer GenericValue Dest; 195e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (Ty->getTypeID()) { 196f9536330d6271b242572eb1b8011b051b09e128cReid Spencer IMPLEMENT_INTEGER_ICMP(sgt,Ty); 197a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer IMPLEMENT_POINTER_ICMP(>); 198e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer default: 199ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for ICMP_SGT predicate: " << *Ty << "\n"; 200c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 201e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 202e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return Dest; 203e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer} 204e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 205e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencerstatic GenericValue executeICMP_ULE(GenericValue Src1, GenericValue Src2, 206db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 207e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer GenericValue Dest; 208e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (Ty->getTypeID()) { 209f9536330d6271b242572eb1b8011b051b09e128cReid Spencer IMPLEMENT_INTEGER_ICMP(ule,Ty); 210a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer IMPLEMENT_POINTER_ICMP(<=); 211e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer default: 212ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for ICMP_ULE predicate: " << *Ty << "\n"; 213c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 214e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 215e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return Dest; 216e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer} 217e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 218e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencerstatic GenericValue executeICMP_SLE(GenericValue Src1, GenericValue Src2, 219db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 220e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer GenericValue Dest; 221e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (Ty->getTypeID()) { 222f9536330d6271b242572eb1b8011b051b09e128cReid Spencer IMPLEMENT_INTEGER_ICMP(sle,Ty); 223a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer IMPLEMENT_POINTER_ICMP(<=); 224e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer default: 225ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for ICMP_SLE predicate: " << *Ty << "\n"; 226c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 227e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 228e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return Dest; 229e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer} 230e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 231e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencerstatic GenericValue executeICMP_UGE(GenericValue Src1, GenericValue Src2, 232db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 233e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer GenericValue Dest; 234e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (Ty->getTypeID()) { 235f9536330d6271b242572eb1b8011b051b09e128cReid Spencer IMPLEMENT_INTEGER_ICMP(uge,Ty); 236a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer IMPLEMENT_POINTER_ICMP(>=); 237e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer default: 238ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for ICMP_UGE predicate: " << *Ty << "\n"; 239c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 240e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 241e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return Dest; 242e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer} 243e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 244e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencerstatic GenericValue executeICMP_SGE(GenericValue Src1, GenericValue Src2, 245db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 246e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer GenericValue Dest; 247e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (Ty->getTypeID()) { 248f9536330d6271b242572eb1b8011b051b09e128cReid Spencer IMPLEMENT_INTEGER_ICMP(sge,Ty); 249a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer IMPLEMENT_POINTER_ICMP(>=); 250e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer default: 251ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for ICMP_SGE predicate: " << *Ty << "\n"; 252c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 253e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 254e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return Dest; 255e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer} 256e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 257e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencervoid Interpreter::visitICmpInst(ICmpInst &I) { 258e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer ExecutionContext &SF = ECStack.back(); 259db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = I.getOperand(0)->getType(); 260e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer GenericValue Src1 = getOperandValue(I.getOperand(0), SF); 261e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer GenericValue Src2 = getOperandValue(I.getOperand(1), SF); 262e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer GenericValue R; // Result 263e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer 264e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer switch (I.getPredicate()) { 265a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case ICmpInst::ICMP_EQ: R = executeICMP_EQ(Src1, Src2, Ty); break; 266a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case ICmpInst::ICMP_NE: R = executeICMP_NE(Src1, Src2, Ty); break; 267e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer case ICmpInst::ICMP_ULT: R = executeICMP_ULT(Src1, Src2, Ty); break; 268e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer case ICmpInst::ICMP_SLT: R = executeICMP_SLT(Src1, Src2, Ty); break; 269e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer case ICmpInst::ICMP_UGT: R = executeICMP_UGT(Src1, Src2, Ty); break; 270e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer case ICmpInst::ICMP_SGT: R = executeICMP_SGT(Src1, Src2, Ty); break; 271e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer case ICmpInst::ICMP_ULE: R = executeICMP_ULE(Src1, Src2, Ty); break; 272e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer case ICmpInst::ICMP_SLE: R = executeICMP_SLE(Src1, Src2, Ty); break; 273e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer case ICmpInst::ICMP_UGE: R = executeICMP_UGE(Src1, Src2, Ty); break; 274e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer case ICmpInst::ICMP_SGE: R = executeICMP_SGE(Src1, Src2, Ty); break; 275e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer default: 276ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Don't know how to handle this ICmp predicate!\n-->" << I; 277c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 278e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer } 279e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer 280e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer SetValue(&I, R, SF); 281e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer} 282e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer 283e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer#define IMPLEMENT_FCMP(OP, TY) \ 284f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Type::TY##TyID: \ 285f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = APInt(1,Src1.TY##Val OP Src2.TY##Val); \ 286f9536330d6271b242572eb1b8011b051b09e128cReid Spencer break 287e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 288a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencerstatic GenericValue executeFCMP_OEQ(GenericValue Src1, GenericValue Src2, 289db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 29092101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner GenericValue Dest; 291f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner switch (Ty->getTypeID()) { 292e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer IMPLEMENT_FCMP(==, Float); 293e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer IMPLEMENT_FCMP(==, Double); 29492101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner default: 295ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for FCmp EQ instruction: " << *Ty << "\n"; 296c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 29792101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner } 29892101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner return Dest; 29992101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner} 30092101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 301a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencerstatic GenericValue executeFCMP_ONE(GenericValue Src1, GenericValue Src2, 302db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 30392101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner GenericValue Dest; 304f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner switch (Ty->getTypeID()) { 305e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer IMPLEMENT_FCMP(!=, Float); 306e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer IMPLEMENT_FCMP(!=, Double); 307ea38c0e85c29783fdaf3b6c25fe7e3aa43688521Chris Lattner 30892101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner default: 309ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for FCmp NE instruction: " << *Ty << "\n"; 310c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 31192101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner } 31292101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner return Dest; 31392101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner} 31492101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 315a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencerstatic GenericValue executeFCMP_OLE(GenericValue Src1, GenericValue Src2, 316db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 31792101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner GenericValue Dest; 318f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner switch (Ty->getTypeID()) { 319e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer IMPLEMENT_FCMP(<=, Float); 320e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer IMPLEMENT_FCMP(<=, Double); 32192101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner default: 322ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for FCmp LE instruction: " << *Ty << "\n"; 323c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 32492101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner } 32592101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner return Dest; 32692101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner} 32792101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 328a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencerstatic GenericValue executeFCMP_OGE(GenericValue Src1, GenericValue Src2, 329db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 33092101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner GenericValue Dest; 331f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner switch (Ty->getTypeID()) { 332e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer IMPLEMENT_FCMP(>=, Float); 333e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer IMPLEMENT_FCMP(>=, Double); 33492101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner default: 335ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for FCmp GE instruction: " << *Ty << "\n"; 336c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 33792101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner } 33892101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner return Dest; 33992101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner} 34092101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 341a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencerstatic GenericValue executeFCMP_OLT(GenericValue Src1, GenericValue Src2, 342db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 34392101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner GenericValue Dest; 344f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner switch (Ty->getTypeID()) { 345e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer IMPLEMENT_FCMP(<, Float); 346e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer IMPLEMENT_FCMP(<, Double); 34792101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner default: 348ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for FCmp LT instruction: " << *Ty << "\n"; 349c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 35092101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner } 35192101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner return Dest; 35292101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner} 35392101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 354a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencerstatic GenericValue executeFCMP_OGT(GenericValue Src1, GenericValue Src2, 355db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 35692101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner GenericValue Dest; 357f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner switch (Ty->getTypeID()) { 358e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer IMPLEMENT_FCMP(>, Float); 359e49661bdf5b7a913d4e368cf511381e524ae403aReid Spencer IMPLEMENT_FCMP(>, Double); 36092101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner default: 361ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled type for FCmp GT instruction: " << *Ty << "\n"; 362c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 36392101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner } 36492101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner return Dest; 36592101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner} 36692101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 3674c71dfe356716e6bc1993ef5efdced08b68fe612Anton Korobeynikov#define IMPLEMENT_UNORDERED(TY, X,Y) \ 368cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (TY->isFloatTy()) { \ 3694c71dfe356716e6bc1993ef5efdced08b68fe612Anton Korobeynikov if (X.FloatVal != X.FloatVal || Y.FloatVal != Y.FloatVal) { \ 3704c71dfe356716e6bc1993ef5efdced08b68fe612Anton Korobeynikov Dest.IntVal = APInt(1,true); \ 3714c71dfe356716e6bc1993ef5efdced08b68fe612Anton Korobeynikov return Dest; \ 3724c71dfe356716e6bc1993ef5efdced08b68fe612Anton Korobeynikov } \ 3734c71dfe356716e6bc1993ef5efdced08b68fe612Anton Korobeynikov } else if (X.DoubleVal != X.DoubleVal || Y.DoubleVal != Y.DoubleVal) { \ 3744c71dfe356716e6bc1993ef5efdced08b68fe612Anton Korobeynikov Dest.IntVal = APInt(1,true); \ 3754c71dfe356716e6bc1993ef5efdced08b68fe612Anton Korobeynikov return Dest; \ 3764c71dfe356716e6bc1993ef5efdced08b68fe612Anton Korobeynikov } 377a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 378a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 379a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencerstatic GenericValue executeFCMP_UEQ(GenericValue Src1, GenericValue Src2, 380db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 381a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest; 382a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer IMPLEMENT_UNORDERED(Ty, Src1, Src2) 383a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return executeFCMP_OEQ(Src1, Src2, Ty); 384a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 385a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 386a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencerstatic GenericValue executeFCMP_UNE(GenericValue Src1, GenericValue Src2, 387db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 388a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest; 389a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer IMPLEMENT_UNORDERED(Ty, Src1, Src2) 390a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return executeFCMP_ONE(Src1, Src2, Ty); 391a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 392a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 393a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencerstatic GenericValue executeFCMP_ULE(GenericValue Src1, GenericValue Src2, 394db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 395a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest; 396a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer IMPLEMENT_UNORDERED(Ty, Src1, Src2) 397a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return executeFCMP_OLE(Src1, Src2, Ty); 398a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 399a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 400a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencerstatic GenericValue executeFCMP_UGE(GenericValue Src1, GenericValue Src2, 401db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 402a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest; 403a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer IMPLEMENT_UNORDERED(Ty, Src1, Src2) 404a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return executeFCMP_OGE(Src1, Src2, Ty); 405a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 406a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 407a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencerstatic GenericValue executeFCMP_ULT(GenericValue Src1, GenericValue Src2, 408db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 409a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest; 410a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer IMPLEMENT_UNORDERED(Ty, Src1, Src2) 411a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return executeFCMP_OLT(Src1, Src2, Ty); 412a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 413a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 414a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencerstatic GenericValue executeFCMP_UGT(GenericValue Src1, GenericValue Src2, 415db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 416a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest; 417a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer IMPLEMENT_UNORDERED(Ty, Src1, Src2) 418a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return executeFCMP_OGT(Src1, Src2, Ty); 419a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 420a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 421a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencerstatic GenericValue executeFCMP_ORD(GenericValue Src1, GenericValue Src2, 422db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 423a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest; 424cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Ty->isFloatTy()) 425f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = APInt(1,(Src1.FloatVal == Src1.FloatVal && 426f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Src2.FloatVal == Src2.FloatVal)); 427a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer else 428f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = APInt(1,(Src1.DoubleVal == Src1.DoubleVal && 429f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Src2.DoubleVal == Src2.DoubleVal)); 430a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return Dest; 431a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 432a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 433a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencerstatic GenericValue executeFCMP_UNO(GenericValue Src1, GenericValue Src2, 434db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 435a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest; 436cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Ty->isFloatTy()) 437f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = APInt(1,(Src1.FloatVal != Src1.FloatVal || 438f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Src2.FloatVal != Src2.FloatVal)); 439a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer else 440f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = APInt(1,(Src1.DoubleVal != Src1.DoubleVal || 441f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Src2.DoubleVal != Src2.DoubleVal)); 442a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return Dest; 443a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 444a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 445e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencervoid Interpreter::visitFCmpInst(FCmpInst &I) { 446e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer ExecutionContext &SF = ECStack.back(); 447db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = I.getOperand(0)->getType(); 448e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer GenericValue Src1 = getOperandValue(I.getOperand(0), SF); 449e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer GenericValue Src2 = getOperandValue(I.getOperand(1), SF); 450e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer GenericValue R; // Result 451e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 452e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (I.getPredicate()) { 453f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case FCmpInst::FCMP_FALSE: R.IntVal = APInt(1,false); break; 454f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case FCmpInst::FCMP_TRUE: R.IntVal = APInt(1,true); break; 455a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_ORD: R = executeFCMP_ORD(Src1, Src2, Ty); break; 456a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_UNO: R = executeFCMP_UNO(Src1, Src2, Ty); break; 457a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_UEQ: R = executeFCMP_UEQ(Src1, Src2, Ty); break; 458a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_OEQ: R = executeFCMP_OEQ(Src1, Src2, Ty); break; 459a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_UNE: R = executeFCMP_UNE(Src1, Src2, Ty); break; 460a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_ONE: R = executeFCMP_ONE(Src1, Src2, Ty); break; 461a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_ULT: R = executeFCMP_ULT(Src1, Src2, Ty); break; 462a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_OLT: R = executeFCMP_OLT(Src1, Src2, Ty); break; 463a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_UGT: R = executeFCMP_UGT(Src1, Src2, Ty); break; 464a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_OGT: R = executeFCMP_OGT(Src1, Src2, Ty); break; 465a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_ULE: R = executeFCMP_ULE(Src1, Src2, Ty); break; 466a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_OLE: R = executeFCMP_OLE(Src1, Src2, Ty); break; 467a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_UGE: R = executeFCMP_UGE(Src1, Src2, Ty); break; 468a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_OGE: R = executeFCMP_OGE(Src1, Src2, Ty); break; 469e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer default: 470ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Don't know how to handle this FCmp predicate!\n-->" << I; 471c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 472e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 473e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 474e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer SetValue(&I, R, SF); 475e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer} 476e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 477e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencerstatic GenericValue executeCmpInst(unsigned predicate, GenericValue Src1, 478db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner GenericValue Src2, Type *Ty) { 479e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer GenericValue Result; 480e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer switch (predicate) { 481e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_EQ: return executeICMP_EQ(Src1, Src2, Ty); 482e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_NE: return executeICMP_NE(Src1, Src2, Ty); 483e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_UGT: return executeICMP_UGT(Src1, Src2, Ty); 484e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_SGT: return executeICMP_SGT(Src1, Src2, Ty); 485e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_ULT: return executeICMP_ULT(Src1, Src2, Ty); 486e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_SLT: return executeICMP_SLT(Src1, Src2, Ty); 487e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_UGE: return executeICMP_UGE(Src1, Src2, Ty); 488e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_SGE: return executeICMP_SGE(Src1, Src2, Ty); 489e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_ULE: return executeICMP_ULE(Src1, Src2, Ty); 490e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case ICmpInst::ICMP_SLE: return executeICMP_SLE(Src1, Src2, Ty); 491a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_ORD: return executeFCMP_ORD(Src1, Src2, Ty); 492a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_UNO: return executeFCMP_UNO(Src1, Src2, Ty); 493a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_OEQ: return executeFCMP_OEQ(Src1, Src2, Ty); 494a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_UEQ: return executeFCMP_UEQ(Src1, Src2, Ty); 495a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_ONE: return executeFCMP_ONE(Src1, Src2, Ty); 496a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_UNE: return executeFCMP_UNE(Src1, Src2, Ty); 497a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_OLT: return executeFCMP_OLT(Src1, Src2, Ty); 498a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_ULT: return executeFCMP_ULT(Src1, Src2, Ty); 499a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_OGT: return executeFCMP_OGT(Src1, Src2, Ty); 500a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_UGT: return executeFCMP_UGT(Src1, Src2, Ty); 501a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_OLE: return executeFCMP_OLE(Src1, Src2, Ty); 502a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_ULE: return executeFCMP_ULE(Src1, Src2, Ty); 503a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_OGE: return executeFCMP_OGE(Src1, Src2, Ty); 504a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case FCmpInst::FCMP_UGE: return executeFCMP_UGE(Src1, Src2, Ty); 505e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_FALSE: { 506e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer GenericValue Result; 507f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Result.IntVal = APInt(1, false); 508e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return Result; 509e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 510e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case FCmpInst::FCMP_TRUE: { 511e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer GenericValue Result; 512f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Result.IntVal = APInt(1, true); 513e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return Result; 514e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 515e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer default: 516ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled Cmp predicate\n"; 517c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 518e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } 519e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer} 520e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 521d7916e988c544b2ab6af26b723b6bc340ecb78ccChris Lattnervoid Interpreter::visitBinaryOperator(BinaryOperator &I) { 522d7916e988c544b2ab6af26b723b6bc340ecb78ccChris Lattner ExecutionContext &SF = ECStack.back(); 523db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = I.getOperand(0)->getType(); 5240b12b5f50ec77a8bd01b92d287c52d748619bb4bChris Lattner GenericValue Src1 = getOperandValue(I.getOperand(0), SF); 5250b12b5f50ec77a8bd01b92d287c52d748619bb4bChris Lattner GenericValue Src2 = getOperandValue(I.getOperand(1), SF); 52692101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner GenericValue R; // Result 52792101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 5280b12b5f50ec77a8bd01b92d287c52d748619bb4bChris Lattner switch (I.getOpcode()) { 529ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Add: R.IntVal = Src1.IntVal + Src2.IntVal; break; 530ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Sub: R.IntVal = Src1.IntVal - Src2.IntVal; break; 531ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Mul: R.IntVal = Src1.IntVal * Src2.IntVal; break; 532ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FAdd: executeFAddInst(R, Src1, Src2, Ty); break; 533ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FSub: executeFSubInst(R, Src1, Src2, Ty); break; 534ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FMul: executeFMulInst(R, Src1, Src2, Ty); break; 535ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FDiv: executeFDivInst(R, Src1, Src2, Ty); break; 536ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FRem: executeFRemInst(R, Src1, Src2, Ty); break; 537f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Instruction::UDiv: R.IntVal = Src1.IntVal.udiv(Src2.IntVal); break; 538f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Instruction::SDiv: R.IntVal = Src1.IntVal.sdiv(Src2.IntVal); break; 539f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Instruction::URem: R.IntVal = Src1.IntVal.urem(Src2.IntVal); break; 540f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Instruction::SRem: R.IntVal = Src1.IntVal.srem(Src2.IntVal); break; 541f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Instruction::And: R.IntVal = Src1.IntVal & Src2.IntVal; break; 542f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Instruction::Or: R.IntVal = Src1.IntVal | Src2.IntVal; break; 543f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Instruction::Xor: R.IntVal = Src1.IntVal ^ Src2.IntVal; break; 54492101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner default: 545ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Don't know how to handle this binary operator!\n-->" << I; 546c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 54792101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner } 54892101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 5490b12b5f50ec77a8bd01b92d287c52d748619bb4bChris Lattner SetValue(&I, R, SF); 55092101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner} 55192101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 552d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukmanstatic GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2, 553759d34ffb718cf35e97682b5bd541beb82d9a192Chris Lattner GenericValue Src3) { 554f9536330d6271b242572eb1b8011b051b09e128cReid Spencer return Src1.IntVal == 0 ? Src3 : Src2; 555759d34ffb718cf35e97682b5bd541beb82d9a192Chris Lattner} 556759d34ffb718cf35e97682b5bd541beb82d9a192Chris Lattner 557759d34ffb718cf35e97682b5bd541beb82d9a192Chris Lattnervoid Interpreter::visitSelectInst(SelectInst &I) { 558759d34ffb718cf35e97682b5bd541beb82d9a192Chris Lattner ExecutionContext &SF = ECStack.back(); 559759d34ffb718cf35e97682b5bd541beb82d9a192Chris Lattner GenericValue Src1 = getOperandValue(I.getOperand(0), SF); 560759d34ffb718cf35e97682b5bd541beb82d9a192Chris Lattner GenericValue Src2 = getOperandValue(I.getOperand(1), SF); 561759d34ffb718cf35e97682b5bd541beb82d9a192Chris Lattner GenericValue Src3 = getOperandValue(I.getOperand(2), SF); 562f9536330d6271b242572eb1b8011b051b09e128cReid Spencer GenericValue R = executeSelectInst(Src1, Src2, Src3); 563759d34ffb718cf35e97682b5bd541beb82d9a192Chris Lattner SetValue(&I, R, SF); 564759d34ffb718cf35e97682b5bd541beb82d9a192Chris Lattner} 565759d34ffb718cf35e97682b5bd541beb82d9a192Chris Lattner 566759d34ffb718cf35e97682b5bd541beb82d9a192Chris Lattner 56792101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner//===----------------------------------------------------------------------===// 56892101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner// Terminator Instruction Implementations 56992101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner//===----------------------------------------------------------------------===// 57092101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 571e43db88b2d12f2aebbe62aca8465a46c92292fceChris Lattnervoid Interpreter::exitCalled(GenericValue GV) { 572d8400d86dd016ae93b25465dcf3bd5513800293aBrian Gaeke // runAtExitHandlers() assumes there are no stack frames, but 573d8400d86dd016ae93b25465dcf3bd5513800293aBrian Gaeke // if exit() was called, then it had a stack frame. Blow away 574d8400d86dd016ae93b25465dcf3bd5513800293aBrian Gaeke // the stack before interpreting atexit handlers. 575f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner ECStack.clear(); 576f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner runAtExitHandlers(); 577f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner exit(GV.IntVal.zextOrTrunc(32).getZExtValue()); 578e43db88b2d12f2aebbe62aca8465a46c92292fceChris Lattner} 579e43db88b2d12f2aebbe62aca8465a46c92292fceChris Lattner 580af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke/// Pop the last stack frame off of ECStack and then copy the result 581af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke/// back into the result variable if we are not returning void. The 5828c9191c644cf8c3aceac8e0d1ddc72273355588cJeff Cohen/// result variable may be the ExitValue, or the Value of the calling 583dbde1ae7a03cfed13b7abd3a37fa74fbdc2c9551Brian Gaeke/// CallInst if there was a previous stack frame. This method may 584dbde1ae7a03cfed13b7abd3a37fa74fbdc2c9551Brian Gaeke/// invalidate any ECStack iterators you have. This method also takes 585dbde1ae7a03cfed13b7abd3a37fa74fbdc2c9551Brian Gaeke/// care of switching to the normal destination BB, if we are returning 586dbde1ae7a03cfed13b7abd3a37fa74fbdc2c9551Brian Gaeke/// from an invoke. 587af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke/// 588db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnervoid Interpreter::popStackAndReturnValueToCaller(Type *RetTy, 589f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner GenericValue Result) { 590af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke // Pop the current stack frame. 591af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke ECStack.pop_back(); 592af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke 593d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman if (ECStack.empty()) { // Finished main. Put result into exit code... 594963433115a540a4521af8afb9880261dd7742807Dan Gohman if (RetTy && !RetTy->isVoidTy()) { // Nonvoid return type? 5958c9191c644cf8c3aceac8e0d1ddc72273355588cJeff Cohen ExitValue = Result; // Capture the exit value of the program 596d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman } else { 597e770787be101e522425f658f76e4bb3091498f99Reid Spencer memset(&ExitValue.Untyped, 0, sizeof(ExitValue.Untyped)); 598d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman } 599d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman } else { 600d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman // If we have a previous stack frame, and we have a previous call, 601d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman // fill in the return value... 602af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke ExecutionContext &CallingSF = ECStack.back(); 603dbde1ae7a03cfed13b7abd3a37fa74fbdc2c9551Brian Gaeke if (Instruction *I = CallingSF.Caller.getInstruction()) { 6041d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson // Save result... 605f012705c7e4ca8cf90b6b734ce1d5355daca5ba5Benjamin Kramer if (!CallingSF.Caller.getType()->isVoidTy()) 606dbde1ae7a03cfed13b7abd3a37fa74fbdc2c9551Brian Gaeke SetValue(I, Result, CallingSF); 607dbde1ae7a03cfed13b7abd3a37fa74fbdc2c9551Brian Gaeke if (InvokeInst *II = dyn_cast<InvokeInst> (I)) 608dbde1ae7a03cfed13b7abd3a37fa74fbdc2c9551Brian Gaeke SwitchToNewBasicBlock (II->getNormalDest (), CallingSF); 6092cb474c8ad8d9d5fe65e801e19e1d96e2c3128b4Brian Gaeke CallingSF.Caller = CallSite(); // We returned from the call... 610af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke } 611af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke } 612af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke} 613af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke 614d7916e988c544b2ab6af26b723b6bc340ecb78ccChris Lattnervoid Interpreter::visitReturnInst(ReturnInst &I) { 615d7916e988c544b2ab6af26b723b6bc340ecb78ccChris Lattner ExecutionContext &SF = ECStack.back(); 616db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *RetTy = Type::getVoidTy(I.getContext()); 61792101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner GenericValue Result; 61892101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 61992101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner // Save away the return value... (if we are not 'ret void') 6200b12b5f50ec77a8bd01b92d287c52d748619bb4bChris Lattner if (I.getNumOperands()) { 6210b12b5f50ec77a8bd01b92d287c52d748619bb4bChris Lattner RetTy = I.getReturnValue()->getType(); 6220b12b5f50ec77a8bd01b92d287c52d748619bb4bChris Lattner Result = getOperandValue(I.getReturnValue(), SF); 62392101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner } 62492101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 625af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke popStackAndReturnValueToCaller(RetTy, Result); 62692101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner} 62792101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 628ec7c1ab1dafa0fdb383d0e6df4726cecb4c88c70Chris Lattnervoid Interpreter::visitUnreachableInst(UnreachableInst &I) { 62975361b69f3f327842b9dad69fa7f28ae3b688412Chris Lattner report_fatal_error("Program executed an 'unreachable' instruction!"); 630ec7c1ab1dafa0fdb383d0e6df4726cecb4c88c70Chris Lattner} 631ec7c1ab1dafa0fdb383d0e6df4726cecb4c88c70Chris Lattner 632d7916e988c544b2ab6af26b723b6bc340ecb78ccChris Lattnervoid Interpreter::visitBranchInst(BranchInst &I) { 633d7916e988c544b2ab6af26b723b6bc340ecb78ccChris Lattner ExecutionContext &SF = ECStack.back(); 63492101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner BasicBlock *Dest; 63592101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 6360b12b5f50ec77a8bd01b92d287c52d748619bb4bChris Lattner Dest = I.getSuccessor(0); // Uncond branches have a fixed dest... 6370b12b5f50ec77a8bd01b92d287c52d748619bb4bChris Lattner if (!I.isUnconditional()) { 6380b12b5f50ec77a8bd01b92d287c52d748619bb4bChris Lattner Value *Cond = I.getCondition(); 639f9536330d6271b242572eb1b8011b051b09e128cReid Spencer if (getOperandValue(Cond, SF).IntVal == 0) // If false cond... 640d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman Dest = I.getSuccessor(1); 64192101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner } 64277113b627237fe2850676cccd809de1e05f03952Chris Lattner SwitchToNewBasicBlock(Dest, SF); 64392101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner} 64492101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 645d7916e988c544b2ab6af26b723b6bc340ecb78ccChris Lattnervoid Interpreter::visitSwitchInst(SwitchInst &I) { 646d7916e988c544b2ab6af26b723b6bc340ecb78ccChris Lattner ExecutionContext &SF = ECStack.back(); 647bb5a7442e362776621112dc9453e546a55878e79Eli Friedman Value* Cond = I.getCondition(); 648bb5a7442e362776621112dc9453e546a55878e79Eli Friedman Type *ElTy = Cond->getType(); 649bb5a7442e362776621112dc9453e546a55878e79Eli Friedman GenericValue CondVal = getOperandValue(Cond, SF); 65009e9392d636c7f28ccb346d7dbf83d45f28fad9aChris Lattner 65109e9392d636c7f28ccb346d7dbf83d45f28fad9aChris Lattner // Check to see if any of the cases match... 65277113b627237fe2850676cccd809de1e05f03952Chris Lattner BasicBlock *Dest = 0; 6533d3abe0852d5f499bed7ab014519dd582a0a795dStepan Dyatkovskiy for (SwitchInst::CaseIt i = I.case_begin(), e = I.case_end(); i != e; ++i) { 65447cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy IntegersSubset& Case = i.getCaseValueEx(); 65547cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy if (Case.isSingleNumber()) { 656484fc93eff0295b1aa52b9a64d22346580e4b0e2Stepan Dyatkovskiy // FIXME: Currently work with ConstantInt based numbers. 65747cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy const ConstantInt *CI = Case.getSingleNumber(0).toConstantInt(); 65847cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy GenericValue Val = getOperandValue(const_cast<ConstantInt*>(CI), SF); 65947cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy if (executeICMP_EQ(Val, CondVal, ElTy).IntVal != 0) { 6601c8f4b8c34a75e184ec40251225c2699efecedacStepan Dyatkovskiy Dest = cast<BasicBlock>(i.getCaseSuccessor()); 6611c8f4b8c34a75e184ec40251225c2699efecedacStepan Dyatkovskiy break; 6621c8f4b8c34a75e184ec40251225c2699efecedacStepan Dyatkovskiy } 66309e9392d636c7f28ccb346d7dbf83d45f28fad9aChris Lattner } 66447cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy if (Case.isSingleNumbersOnly()) { 66547cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy for (unsigned n = 0, en = Case.getNumItems(); n != en; ++n) { 66647cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy // FIXME: Currently work with ConstantInt based numbers. 66747cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy const ConstantInt *CI = Case.getSingleNumber(n).toConstantInt(); 66847cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy GenericValue Val = getOperandValue(const_cast<ConstantInt*>(CI), SF); 66947cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy if (executeICMP_EQ(Val, CondVal, ElTy).IntVal != 0) { 67047cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy Dest = cast<BasicBlock>(i.getCaseSuccessor()); 67147cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy break; 67247cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy } 67347cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy } 67447cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy } else 67547cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy for (unsigned n = 0, en = Case.getNumItems(); n != en; ++n) { 67647cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy IntegersSubset::Range r = Case.getItem(n); 67747cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy // FIXME: Currently work with ConstantInt based numbers. 67847cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy const ConstantInt *LowCI = r.getLow().toConstantInt(); 67947cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy const ConstantInt *HighCI = r.getHigh().toConstantInt(); 68047cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy GenericValue Low = getOperandValue(const_cast<ConstantInt*>(LowCI), SF); 68147cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy GenericValue High = getOperandValue(const_cast<ConstantInt*>(HighCI), SF); 68247cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy if (executeICMP_ULE(Low, CondVal, ElTy).IntVal != 0 && 68347cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy executeICMP_ULE(CondVal, High, ElTy).IntVal != 0) { 68447cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy Dest = cast<BasicBlock>(i.getCaseSuccessor()); 68547cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy break; 68647cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy } 68747cbc4e0ee6098b7be3c60108000a979f1809949Stepan Dyatkovskiy } 688bb5a7442e362776621112dc9453e546a55878e79Eli Friedman } 68909e9392d636c7f28ccb346d7dbf83d45f28fad9aChris Lattner if (!Dest) Dest = I.getDefaultDest(); // No cases matched: use default 69077113b627237fe2850676cccd809de1e05f03952Chris Lattner SwitchToNewBasicBlock(Dest, SF); 69177113b627237fe2850676cccd809de1e05f03952Chris Lattner} 69277113b627237fe2850676cccd809de1e05f03952Chris Lattner 693f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattnervoid Interpreter::visitIndirectBrInst(IndirectBrInst &I) { 694f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner ExecutionContext &SF = ECStack.back(); 695f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner void *Dest = GVTOP(getOperandValue(I.getAddress(), SF)); 696f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner SwitchToNewBasicBlock((BasicBlock*)Dest, SF); 697f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner} 698f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner 699f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner 70077113b627237fe2850676cccd809de1e05f03952Chris Lattner// SwitchToNewBasicBlock - This method is used to jump to a new basic block. 70177113b627237fe2850676cccd809de1e05f03952Chris Lattner// This function handles the actual updating of block and instruction iterators 70277113b627237fe2850676cccd809de1e05f03952Chris Lattner// as well as execution of all of the PHI nodes in the destination block. 70377113b627237fe2850676cccd809de1e05f03952Chris Lattner// 70477113b627237fe2850676cccd809de1e05f03952Chris Lattner// This method does this because all of the PHI nodes must be executed 70577113b627237fe2850676cccd809de1e05f03952Chris Lattner// atomically, reading their inputs before any of the results are updated. Not 70677113b627237fe2850676cccd809de1e05f03952Chris Lattner// doing this can cause problems if the PHI nodes depend on other PHI nodes for 70777113b627237fe2850676cccd809de1e05f03952Chris Lattner// their inputs. If the input PHI node is updated before it is read, incorrect 70877113b627237fe2850676cccd809de1e05f03952Chris Lattner// results can happen. Thus we use a two phase approach. 70977113b627237fe2850676cccd809de1e05f03952Chris Lattner// 71077113b627237fe2850676cccd809de1e05f03952Chris Lattnervoid Interpreter::SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF){ 71177113b627237fe2850676cccd809de1e05f03952Chris Lattner BasicBlock *PrevBB = SF.CurBB; // Remember where we came from... 71277113b627237fe2850676cccd809de1e05f03952Chris Lattner SF.CurBB = Dest; // Update CurBB to branch destination 71377113b627237fe2850676cccd809de1e05f03952Chris Lattner SF.CurInst = SF.CurBB->begin(); // Update new instruction ptr... 71477113b627237fe2850676cccd809de1e05f03952Chris Lattner 71577113b627237fe2850676cccd809de1e05f03952Chris Lattner if (!isa<PHINode>(SF.CurInst)) return; // Nothing fancy to do 71677113b627237fe2850676cccd809de1e05f03952Chris Lattner 71777113b627237fe2850676cccd809de1e05f03952Chris Lattner // Loop over all of the PHI nodes in the current block, reading their inputs. 71877113b627237fe2850676cccd809de1e05f03952Chris Lattner std::vector<GenericValue> ResultValues; 71977113b627237fe2850676cccd809de1e05f03952Chris Lattner 72077113b627237fe2850676cccd809de1e05f03952Chris Lattner for (; PHINode *PN = dyn_cast<PHINode>(SF.CurInst); ++SF.CurInst) { 72177113b627237fe2850676cccd809de1e05f03952Chris Lattner // Search for the value corresponding to this previous bb... 72277113b627237fe2850676cccd809de1e05f03952Chris Lattner int i = PN->getBasicBlockIndex(PrevBB); 72377113b627237fe2850676cccd809de1e05f03952Chris Lattner assert(i != -1 && "PHINode doesn't contain entry for predecessor??"); 72477113b627237fe2850676cccd809de1e05f03952Chris Lattner Value *IncomingValue = PN->getIncomingValue(i); 725d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman 72677113b627237fe2850676cccd809de1e05f03952Chris Lattner // Save the incoming value for this PHI node... 72777113b627237fe2850676cccd809de1e05f03952Chris Lattner ResultValues.push_back(getOperandValue(IncomingValue, SF)); 72877113b627237fe2850676cccd809de1e05f03952Chris Lattner } 72977113b627237fe2850676cccd809de1e05f03952Chris Lattner 73077113b627237fe2850676cccd809de1e05f03952Chris Lattner // Now loop over all of the PHI nodes setting their values... 73177113b627237fe2850676cccd809de1e05f03952Chris Lattner SF.CurInst = SF.CurBB->begin(); 7322da5c3dda6f5b9c4ec6d55008d33327764364bd4Reid Spencer for (unsigned i = 0; isa<PHINode>(SF.CurInst); ++SF.CurInst, ++i) { 7332da5c3dda6f5b9c4ec6d55008d33327764364bd4Reid Spencer PHINode *PN = cast<PHINode>(SF.CurInst); 73477113b627237fe2850676cccd809de1e05f03952Chris Lattner SetValue(PN, ResultValues[i], SF); 7352da5c3dda6f5b9c4ec6d55008d33327764364bd4Reid Spencer } 73609e9392d636c7f28ccb346d7dbf83d45f28fad9aChris Lattner} 73709e9392d636c7f28ccb346d7dbf83d45f28fad9aChris Lattner 73892101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner//===----------------------------------------------------------------------===// 73986660981e1382f954152b0f029f874aa36de0308Chris Lattner// Memory Instruction Implementations 74086660981e1382f954152b0f029f874aa36de0308Chris Lattner//===----------------------------------------------------------------------===// 74186660981e1382f954152b0f029f874aa36de0308Chris Lattner 7427b929dad59785f62a66f7c58615082f98441e95eVictor Hernandezvoid Interpreter::visitAllocaInst(AllocaInst &I) { 743d7916e988c544b2ab6af26b723b6bc340ecb78ccChris Lattner ExecutionContext &SF = ECStack.back(); 744d7916e988c544b2ab6af26b723b6bc340ecb78ccChris Lattner 745db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = I.getType()->getElementType(); // Type to be allocated 74686660981e1382f954152b0f029f874aa36de0308Chris Lattner 747cc82cc174c4afa974450ac1e32ec85cb4d5324a8Chris Lattner // Get the number of elements being allocated by the array... 748f9536330d6271b242572eb1b8011b051b09e128cReid Spencer unsigned NumElements = 749f9536330d6271b242572eb1b8011b051b09e128cReid Spencer getOperandValue(I.getOperand(0), SF).IntVal.getZExtValue(); 750f9536330d6271b242572eb1b8011b051b09e128cReid Spencer 751777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands unsigned TypeSize = (size_t)TD.getTypeAllocSize(Ty); 752f9536330d6271b242572eb1b8011b051b09e128cReid Spencer 753724441e64ad9dbf41579864d6364501aac8ba7dbGabor Greif // Avoid malloc-ing zero bytes, use max()... 754724441e64ad9dbf41579864d6364501aac8ba7dbGabor Greif unsigned MemToAlloc = std::max(1U, NumElements * TypeSize); 75586660981e1382f954152b0f029f874aa36de0308Chris Lattner 75686660981e1382f954152b0f029f874aa36de0308Chris Lattner // Allocate enough memory to hold the type... 757f9536330d6271b242572eb1b8011b051b09e128cReid Spencer void *Memory = malloc(MemToAlloc); 758f9536330d6271b242572eb1b8011b051b09e128cReid Spencer 759ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene DEBUG(dbgs() << "Allocated Type: " << *Ty << " (" << TypeSize << " bytes) x " 76079c5d3f9717756dc3ff56cfcaa3ae1a5930c457aChris Lattner << NumElements << " (Total: " << MemToAlloc << ") at " 76179c5d3f9717756dc3ff56cfcaa3ae1a5930c457aChris Lattner << uintptr_t(Memory) << '\n'); 7629bffa73530b3712b42f6e6bddf21f22b8aba276dChris Lattner 763fe11a97fcde7c63109c3ad36570657807d0cd6efChris Lattner GenericValue Result = PTOGV(Memory); 764ea38c0e85c29783fdaf3b6c25fe7e3aa43688521Chris Lattner assert(Result.PointerVal != 0 && "Null pointer returned by malloc!"); 7650b12b5f50ec77a8bd01b92d287c52d748619bb4bChris Lattner SetValue(&I, Result, SF); 76686660981e1382f954152b0f029f874aa36de0308Chris Lattner 7670b12b5f50ec77a8bd01b92d287c52d748619bb4bChris Lattner if (I.getOpcode() == Instruction::Alloca) 7689bffa73530b3712b42f6e6bddf21f22b8aba276dChris Lattner ECStack.back().Allocas.add(Memory); 76986660981e1382f954152b0f029f874aa36de0308Chris Lattner} 77086660981e1382f954152b0f029f874aa36de0308Chris Lattner 771a34c5689dd38a56ad33dfdfd6b951eb4d6d421adChris Lattner// getElementOffset - The workhorse for getelementptr. 77295c3af584fda818ee7ae80c8ec7201e64e1f5e43Chris Lattner// 7734af6de8f0a767a3892ff7682954cbd2ae2ca3de8Chris LattnerGenericValue Interpreter::executeGEPOperation(Value *Ptr, gep_type_iterator I, 774d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman gep_type_iterator E, 775d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman ExecutionContext &SF) { 7761df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands assert(Ptr->getType()->isPointerTy() && 77795c3af584fda818ee7ae80c8ec7201e64e1f5e43Chris Lattner "Cannot getElementOffset of a nonpointer type!"); 77895c3af584fda818ee7ae80c8ec7201e64e1f5e43Chris Lattner 779f9536330d6271b242572eb1b8011b051b09e128cReid Spencer uint64_t Total = 0; 780a34c5689dd38a56ad33dfdfd6b951eb4d6d421adChris Lattner 781a34c5689dd38a56ad33dfdfd6b951eb4d6d421adChris Lattner for (; I != E; ++I) { 782db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *STy = dyn_cast<StructType>(*I)) { 783782b939db105c1ead1ee9420d95fae8c341dbf47Chris Lattner const StructLayout *SLO = TD.getStructLayout(STy); 784d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman 785b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer const ConstantInt *CPU = cast<ConstantInt>(I.getOperand()); 786b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer unsigned Index = unsigned(CPU->getZExtValue()); 787d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman 788f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Total += SLO->getElementOffset(Index); 7894af6de8f0a767a3892ff7682954cbd2ae2ca3de8Chris Lattner } else { 790db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner SequentialType *ST = cast<SequentialType>(*I); 791006a4a59905fd1d32bca5cc0426d1754a92746faChris Lattner // Get the index number for the array... which must be long type... 7924af6de8f0a767a3892ff7682954cbd2ae2ca3de8Chris Lattner GenericValue IdxGV = getOperandValue(I.getOperand(), SF); 7934af6de8f0a767a3892ff7682954cbd2ae2ca3de8Chris Lattner 794a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer int64_t Idx; 795a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer unsigned BitWidth = 796a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer cast<IntegerType>(I.getOperand()->getType())->getBitWidth(); 79723e28836edaa6750a48dc318c8e2bbe6dc1529c8Reid Spencer if (BitWidth == 32) 798f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Idx = (int64_t)(int32_t)IdxGV.IntVal.getZExtValue(); 799aee7f21c47e0d726328f179697684088748f03a8Chris Lattner else { 800aee7f21c47e0d726328f179697684088748f03a8Chris Lattner assert(BitWidth == 64 && "Invalid index type for getelementptr"); 801f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Idx = (int64_t)IdxGV.IntVal.getZExtValue(); 802aee7f21c47e0d726328f179697684088748f03a8Chris Lattner } 803777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands Total += TD.getTypeAllocSize(ST->getElementType())*Idx; 80403e43dcfe7a30f01f9ad606d265efd6cb8fe381cBrian Gaeke } 80595c3af584fda818ee7ae80c8ec7201e64e1f5e43Chris Lattner } 80695c3af584fda818ee7ae80c8ec7201e64e1f5e43Chris Lattner 807a34c5689dd38a56ad33dfdfd6b951eb4d6d421adChris Lattner GenericValue Result; 808f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Result.PointerVal = ((char*)getOperandValue(Ptr, SF).PointerVal) + Total; 809ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene DEBUG(dbgs() << "GEP Index " << Total << " bytes.\n"); 810a34c5689dd38a56ad33dfdfd6b951eb4d6d421adChris Lattner return Result; 81195c3af584fda818ee7ae80c8ec7201e64e1f5e43Chris Lattner} 81295c3af584fda818ee7ae80c8ec7201e64e1f5e43Chris Lattner 813d7916e988c544b2ab6af26b723b6bc340ecb78ccChris Lattnervoid Interpreter::visitGetElementPtrInst(GetElementPtrInst &I) { 814d7916e988c544b2ab6af26b723b6bc340ecb78ccChris Lattner ExecutionContext &SF = ECStack.back(); 815fdca74c5671e01447be0f1bac3c0c7aa1727690bOwen Anderson SetValue(&I, executeGEPOperation(I.getPointerOperand(), 8164af6de8f0a767a3892ff7682954cbd2ae2ca3de8Chris Lattner gep_type_begin(I), gep_type_end(I), SF), SF); 81795c3af584fda818ee7ae80c8ec7201e64e1f5e43Chris Lattner} 81895c3af584fda818ee7ae80c8ec7201e64e1f5e43Chris Lattner 819d7916e988c544b2ab6af26b723b6bc340ecb78ccChris Lattnervoid Interpreter::visitLoadInst(LoadInst &I) { 820d7916e988c544b2ab6af26b723b6bc340ecb78ccChris Lattner ExecutionContext &SF = ECStack.back(); 8210b12b5f50ec77a8bd01b92d287c52d748619bb4bChris Lattner GenericValue SRC = getOperandValue(I.getPointerOperand(), SF); 822fe11a97fcde7c63109c3ad36570657807d0cd6efChris Lattner GenericValue *Ptr = (GenericValue*)GVTOP(SRC); 823e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer GenericValue Result; 824e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer LoadValueFromMemory(Result, Ptr, I.getType()); 8250b12b5f50ec77a8bd01b92d287c52d748619bb4bChris Lattner SetValue(&I, Result, SF); 826663ceeb948c526c705b38efd2075b7c80a190e5dChris Lattner if (I.isVolatile() && PrintVolatile) 827ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Volatile load " << I; 82886660981e1382f954152b0f029f874aa36de0308Chris Lattner} 82986660981e1382f954152b0f029f874aa36de0308Chris Lattner 830d7916e988c544b2ab6af26b723b6bc340ecb78ccChris Lattnervoid Interpreter::visitStoreInst(StoreInst &I) { 831d7916e988c544b2ab6af26b723b6bc340ecb78ccChris Lattner ExecutionContext &SF = ECStack.back(); 8320b12b5f50ec77a8bd01b92d287c52d748619bb4bChris Lattner GenericValue Val = getOperandValue(I.getOperand(0), SF); 833fddc755a6f6042457b04d1c070e2a032add56b39Chris Lattner GenericValue SRC = getOperandValue(I.getPointerOperand(), SF); 834fe11a97fcde7c63109c3ad36570657807d0cd6efChris Lattner StoreValueToMemory(Val, (GenericValue *)GVTOP(SRC), 835683d5da9fbb68be46c8ad2c8e9f1f94cbdf7b71cChris Lattner I.getOperand(0)->getType()); 836663ceeb948c526c705b38efd2075b7c80a190e5dChris Lattner if (I.isVolatile() && PrintVolatile) 837ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Volatile store: " << I; 83886660981e1382f954152b0f029f874aa36de0308Chris Lattner} 83986660981e1382f954152b0f029f874aa36de0308Chris Lattner 84086660981e1382f954152b0f029f874aa36de0308Chris Lattner//===----------------------------------------------------------------------===// 84192101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner// Miscellaneous Instruction Implementations 84292101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner//===----------------------------------------------------------------------===// 84392101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 844fea483d7c027c595101dce825bdf3f512bf9aacaBrian Gaekevoid Interpreter::visitCallSite(CallSite CS) { 845d7916e988c544b2ab6af26b723b6bc340ecb78ccChris Lattner ExecutionContext &SF = ECStack.back(); 8467301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner 8477301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner // Check to see if this is an intrinsic function call... 8484ccf462b999d66b46e155eaa8c2d0e7ac91ecdfcReid Spencer Function *F = CS.getCalledFunction(); 849f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner if (F && F->isDeclaration()) 8507301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner switch (F->getIntrinsicID()) { 85134562bab046cc091f95ae5333b57ea2538f18336Brian Gaeke case Intrinsic::not_intrinsic: 85234562bab046cc091f95ae5333b57ea2538f18336Brian Gaeke break; 853317201d77354e6fc9547468ce827e1a7c30761d7Chris Lattner case Intrinsic::vastart: { // va_start 8549d20b71ecaffbda5311dfc486b0143d4a94cc502Brian Gaeke GenericValue ArgIndex; 8559d20b71ecaffbda5311dfc486b0143d4a94cc502Brian Gaeke ArgIndex.UIntPairVal.first = ECStack.size() - 1; 8569d20b71ecaffbda5311dfc486b0143d4a94cc502Brian Gaeke ArgIndex.UIntPairVal.second = 0; 8579d20b71ecaffbda5311dfc486b0143d4a94cc502Brian Gaeke SetValue(CS.getInstruction(), ArgIndex, SF); 8587301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner return; 8599d20b71ecaffbda5311dfc486b0143d4a94cc502Brian Gaeke } 860317201d77354e6fc9547468ce827e1a7c30761d7Chris Lattner case Intrinsic::vaend: // va_end is a noop for the interpreter 8617301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner return; 862317201d77354e6fc9547468ce827e1a7c30761d7Chris Lattner case Intrinsic::vacopy: // va_copy: dest = src 8637301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner SetValue(CS.getInstruction(), getOperandValue(*CS.arg_begin(), SF), SF); 8647301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner return; 8657301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner default: 86634562bab046cc091f95ae5333b57ea2538f18336Brian Gaeke // If it is an unknown intrinsic function, use the intrinsic lowering 8677301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner // class to transform it into hopefully tasty LLVM code. 8687301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner // 869b8e237bb86cf810deba0bd0d11c12312978667beChris Lattner BasicBlock::iterator me(CS.getInstruction()); 8707301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner BasicBlock *Parent = CS.getInstruction()->getParent(); 871b8e237bb86cf810deba0bd0d11c12312978667beChris Lattner bool atBegin(Parent->begin() == me); 872b8e237bb86cf810deba0bd0d11c12312978667beChris Lattner if (!atBegin) 873b8e237bb86cf810deba0bd0d11c12312978667beChris Lattner --me; 8747301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner IL->LowerIntrinsicCall(cast<CallInst>(CS.getInstruction())); 8757301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner 8767301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner // Restore the CurInst pointer to the first instruction newly inserted, if 8777301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner // any. 878b8e237bb86cf810deba0bd0d11c12312978667beChris Lattner if (atBegin) { 8797301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner SF.CurInst = Parent->begin(); 8807301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner } else { 881b8e237bb86cf810deba0bd0d11c12312978667beChris Lattner SF.CurInst = me; 8827301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner ++SF.CurInst; 8837301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner } 884b440dea57b4680f78e5eca9fb83dc26951a1d1e0Brian Gaeke return; 8857301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner } 8867301178aac1baf1cc334e7c7a66bfe50a65fbf49Chris Lattner 8874ccf462b999d66b46e155eaa8c2d0e7ac91ecdfcReid Spencer 888fea483d7c027c595101dce825bdf3f512bf9aacaBrian Gaeke SF.Caller = CS; 8890286835685cfd718af98ad6e1e61998eeb60942fChris Lattner std::vector<GenericValue> ArgVals; 890ae2495a9210257a9d4c430df20952c34034828c8Brian Gaeke const unsigned NumArgs = SF.Caller.arg_size(); 891ae2495a9210257a9d4c430df20952c34034828c8Brian Gaeke ArgVals.reserve(NumArgs); 8924ccf462b999d66b46e155eaa8c2d0e7ac91ecdfcReid Spencer uint16_t pNum = 1; 893ae2495a9210257a9d4c430df20952c34034828c8Brian Gaeke for (CallSite::arg_iterator i = SF.Caller.arg_begin(), 8944ccf462b999d66b46e155eaa8c2d0e7ac91ecdfcReid Spencer e = SF.Caller.arg_end(); i != e; ++i, ++pNum) { 895ae2495a9210257a9d4c430df20952c34034828c8Brian Gaeke Value *V = *i; 896ae2495a9210257a9d4c430df20952c34034828c8Brian Gaeke ArgVals.push_back(getOperandValue(V, SF)); 89793780132a702df8b47f259014aea4cc4e54e69c5Chris Lattner } 898365a76e46e7b22ee2cd7881d0a7055fc20930fd5Chris Lattner 899d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman // To handle indirect calls, we must get the pointer value from the argument 9002fbfdcffd3e0cf41422aaa6c526c37cb02b81341Chris Lattner // and treat it as a function pointer. 901d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman GenericValue SRC = getOperandValue(SF.Caller.getCalledValue(), SF); 902da82ed52ac02497d343b898cca0bb2cf303f062dChris Lattner callFunction((Function*)GVTOP(SRC), ArgVals); 90392101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner} 90492101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 905832254e1c2387c0cbeb0a820b8315fbe85cb003aReid Spencervoid Interpreter::visitShl(BinaryOperator &I) { 90663438cc9b02d715ef2ef470c5a4a6282c5fef406Brian Gaeke ExecutionContext &SF = ECStack.back(); 90763438cc9b02d715ef2ef470c5a4a6282c5fef406Brian Gaeke GenericValue Src1 = getOperandValue(I.getOperand(0), SF); 90863438cc9b02d715ef2ef470c5a4a6282c5fef406Brian Gaeke GenericValue Src2 = getOperandValue(I.getOperand(1), SF); 90963438cc9b02d715ef2ef470c5a4a6282c5fef406Brian Gaeke GenericValue Dest; 9109029cb836304cd2848f589dc79373d9b67eb48e0Chris Lattner if (Src2.IntVal.getZExtValue() < Src1.IntVal.getBitWidth()) 9119029cb836304cd2848f589dc79373d9b67eb48e0Chris Lattner Dest.IntVal = Src1.IntVal.shl(Src2.IntVal.getZExtValue()); 9129029cb836304cd2848f589dc79373d9b67eb48e0Chris Lattner else 9139029cb836304cd2848f589dc79373d9b67eb48e0Chris Lattner Dest.IntVal = Src1.IntVal; 9149029cb836304cd2848f589dc79373d9b67eb48e0Chris Lattner 91563438cc9b02d715ef2ef470c5a4a6282c5fef406Brian Gaeke SetValue(&I, Dest, SF); 91663438cc9b02d715ef2ef470c5a4a6282c5fef406Brian Gaeke} 91763438cc9b02d715ef2ef470c5a4a6282c5fef406Brian Gaeke 918832254e1c2387c0cbeb0a820b8315fbe85cb003aReid Spencervoid Interpreter::visitLShr(BinaryOperator &I) { 9193822ff5c71478c7c90a50ca57045fb676fcb5005Reid Spencer ExecutionContext &SF = ECStack.back(); 9203822ff5c71478c7c90a50ca57045fb676fcb5005Reid Spencer GenericValue Src1 = getOperandValue(I.getOperand(0), SF); 9213822ff5c71478c7c90a50ca57045fb676fcb5005Reid Spencer GenericValue Src2 = getOperandValue(I.getOperand(1), SF); 9223822ff5c71478c7c90a50ca57045fb676fcb5005Reid Spencer GenericValue Dest; 9239029cb836304cd2848f589dc79373d9b67eb48e0Chris Lattner if (Src2.IntVal.getZExtValue() < Src1.IntVal.getBitWidth()) 9249029cb836304cd2848f589dc79373d9b67eb48e0Chris Lattner Dest.IntVal = Src1.IntVal.lshr(Src2.IntVal.getZExtValue()); 9259029cb836304cd2848f589dc79373d9b67eb48e0Chris Lattner else 9269029cb836304cd2848f589dc79373d9b67eb48e0Chris Lattner Dest.IntVal = Src1.IntVal; 9279029cb836304cd2848f589dc79373d9b67eb48e0Chris Lattner 9283822ff5c71478c7c90a50ca57045fb676fcb5005Reid Spencer SetValue(&I, Dest, SF); 9293822ff5c71478c7c90a50ca57045fb676fcb5005Reid Spencer} 9303822ff5c71478c7c90a50ca57045fb676fcb5005Reid Spencer 931832254e1c2387c0cbeb0a820b8315fbe85cb003aReid Spencervoid Interpreter::visitAShr(BinaryOperator &I) { 93263438cc9b02d715ef2ef470c5a4a6282c5fef406Brian Gaeke ExecutionContext &SF = ECStack.back(); 93363438cc9b02d715ef2ef470c5a4a6282c5fef406Brian Gaeke GenericValue Src1 = getOperandValue(I.getOperand(0), SF); 93463438cc9b02d715ef2ef470c5a4a6282c5fef406Brian Gaeke GenericValue Src2 = getOperandValue(I.getOperand(1), SF); 9359029cb836304cd2848f589dc79373d9b67eb48e0Chris Lattner GenericValue Dest; 9369029cb836304cd2848f589dc79373d9b67eb48e0Chris Lattner if (Src2.IntVal.getZExtValue() < Src1.IntVal.getBitWidth()) 9379029cb836304cd2848f589dc79373d9b67eb48e0Chris Lattner Dest.IntVal = Src1.IntVal.ashr(Src2.IntVal.getZExtValue()); 9389029cb836304cd2848f589dc79373d9b67eb48e0Chris Lattner else 9399029cb836304cd2848f589dc79373d9b67eb48e0Chris Lattner Dest.IntVal = Src1.IntVal; 9409029cb836304cd2848f589dc79373d9b67eb48e0Chris Lattner 9410b12b5f50ec77a8bd01b92d287c52d748619bb4bChris Lattner SetValue(&I, Dest, SF); 94286660981e1382f954152b0f029f874aa36de0308Chris Lattner} 94386660981e1382f954152b0f029f874aa36de0308Chris Lattner 944db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerGenericValue Interpreter::executeTruncInst(Value *SrcVal, Type *DstTy, 945a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF) { 946a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest, Src = getOperandValue(SrcVal, SF); 947db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *DITy = cast<IntegerType>(DstTy); 948a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer unsigned DBitWidth = DITy->getBitWidth(); 949f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = Src.IntVal.trunc(DBitWidth); 950a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return Dest; 951a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 95286660981e1382f954152b0f029f874aa36de0308Chris Lattner 953db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerGenericValue Interpreter::executeSExtInst(Value *SrcVal, Type *DstTy, 954a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF) { 955a34c5689dd38a56ad33dfdfd6b951eb4d6d421adChris Lattner GenericValue Dest, Src = getOperandValue(SrcVal, SF); 956db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *DITy = cast<IntegerType>(DstTy); 957a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer unsigned DBitWidth = DITy->getBitWidth(); 958f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = Src.IntVal.sext(DBitWidth); 959a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return Dest; 960a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 96186660981e1382f954152b0f029f874aa36de0308Chris Lattner 962db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerGenericValue Interpreter::executeZExtInst(Value *SrcVal, Type *DstTy, 963a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF) { 964a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest, Src = getOperandValue(SrcVal, SF); 965db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *DITy = cast<IntegerType>(DstTy); 966a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer unsigned DBitWidth = DITy->getBitWidth(); 967f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = Src.IntVal.zext(DBitWidth); 968a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return Dest; 969a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 970a34c5689dd38a56ad33dfdfd6b951eb4d6d421adChris Lattner 971db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerGenericValue Interpreter::executeFPTruncInst(Value *SrcVal, Type *DstTy, 972a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF) { 973a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest, Src = getOperandValue(SrcVal, SF); 974cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner assert(SrcVal->getType()->isDoubleTy() && DstTy->isFloatTy() && 975a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer "Invalid FPTrunc instruction"); 976a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer Dest.FloatVal = (float) Src.DoubleVal; 977a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return Dest; 978a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 979a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 980db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerGenericValue Interpreter::executeFPExtInst(Value *SrcVal, Type *DstTy, 981a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF) { 982a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest, Src = getOperandValue(SrcVal, SF); 983cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner assert(SrcVal->getType()->isFloatTy() && DstTy->isDoubleTy() && 984a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer "Invalid FPTrunc instruction"); 985a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer Dest.DoubleVal = (double) Src.FloatVal; 986a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return Dest; 987a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 988a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 989db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerGenericValue Interpreter::executeFPToUIInst(Value *SrcVal, Type *DstTy, 990a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF) { 991db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = SrcVal->getType(); 992f9536330d6271b242572eb1b8011b051b09e128cReid Spencer uint32_t DBitWidth = cast<IntegerType>(DstTy)->getBitWidth(); 993a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest, Src = getOperandValue(SrcVal, SF); 994b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(SrcTy->isFloatingPointTy() && "Invalid FPToUI instruction"); 995e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer 996a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer if (SrcTy->getTypeID() == Type::FloatTyID) 997f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = APIntOps::RoundFloatToAPInt(Src.FloatVal, DBitWidth); 998a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer else 999f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = APIntOps::RoundDoubleToAPInt(Src.DoubleVal, DBitWidth); 1000a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return Dest; 1001a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 1002a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1003db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerGenericValue Interpreter::executeFPToSIInst(Value *SrcVal, Type *DstTy, 1004a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF) { 1005db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = SrcVal->getType(); 1006f9536330d6271b242572eb1b8011b051b09e128cReid Spencer uint32_t DBitWidth = cast<IntegerType>(DstTy)->getBitWidth(); 1007a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest, Src = getOperandValue(SrcVal, SF); 1008b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(SrcTy->isFloatingPointTy() && "Invalid FPToSI instruction"); 1009e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer 1010a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer if (SrcTy->getTypeID() == Type::FloatTyID) 1011f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = APIntOps::RoundFloatToAPInt(Src.FloatVal, DBitWidth); 1012a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer else 1013f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = APIntOps::RoundDoubleToAPInt(Src.DoubleVal, DBitWidth); 1014a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return Dest; 1015a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 1016a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1017db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerGenericValue Interpreter::executeUIToFPInst(Value *SrcVal, Type *DstTy, 1018a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF) { 1019a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest, Src = getOperandValue(SrcVal, SF); 1020b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(DstTy->isFloatingPointTy() && "Invalid UIToFP instruction"); 1021e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer 1022a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer if (DstTy->getTypeID() == Type::FloatTyID) 1023f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.FloatVal = APIntOps::RoundAPIntToFloat(Src.IntVal); 1024a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer else 1025f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.DoubleVal = APIntOps::RoundAPIntToDouble(Src.IntVal); 1026a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return Dest; 1027a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 1028a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1029db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerGenericValue Interpreter::executeSIToFPInst(Value *SrcVal, Type *DstTy, 1030a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF) { 1031a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest, Src = getOperandValue(SrcVal, SF); 1032b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(DstTy->isFloatingPointTy() && "Invalid SIToFP instruction"); 1033e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer 1034a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer if (DstTy->getTypeID() == Type::FloatTyID) 1035f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.FloatVal = APIntOps::RoundSignedAPIntToFloat(Src.IntVal); 1036a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer else 1037f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.DoubleVal = APIntOps::RoundSignedAPIntToDouble(Src.IntVal); 1038a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return Dest; 1039f9536330d6271b242572eb1b8011b051b09e128cReid Spencer 1040a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 1041a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1042db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerGenericValue Interpreter::executePtrToIntInst(Value *SrcVal, Type *DstTy, 1043a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF) { 1044f9536330d6271b242572eb1b8011b051b09e128cReid Spencer uint32_t DBitWidth = cast<IntegerType>(DstTy)->getBitWidth(); 1045a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest, Src = getOperandValue(SrcVal, SF); 10461df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands assert(SrcVal->getType()->isPointerTy() && "Invalid PtrToInt instruction"); 1047e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer 1048f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = APInt(DBitWidth, (intptr_t) Src.PointerVal); 1049a34c5689dd38a56ad33dfdfd6b951eb4d6d421adChris Lattner return Dest; 105086660981e1382f954152b0f029f874aa36de0308Chris Lattner} 105192101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 1052db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerGenericValue Interpreter::executeIntToPtrInst(Value *SrcVal, Type *DstTy, 1053a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF) { 1054a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest, Src = getOperandValue(SrcVal, SF); 10551df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands assert(DstTy->isPointerTy() && "Invalid PtrToInt instruction"); 1056e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer 1057426c2bf5cdd2173e4a33aea8cb92cf684a724f4bChandler Carruth uint32_t PtrSize = TD.getPointerSizeInBits(); 10587553c341354c7790cebda40ea0d647f9d204544bReid Spencer if (PtrSize != Src.IntVal.getBitWidth()) 1059576310512118071393e3f216e1fd4108b0823e56Reid Spencer Src.IntVal = Src.IntVal.zextOrTrunc(PtrSize); 10607553c341354c7790cebda40ea0d647f9d204544bReid Spencer 10616bc6333a1059b0ee9b3b7c2685f4daf370ae67bdReid Spencer Dest.PointerVal = PointerTy(intptr_t(Src.IntVal.getZExtValue())); 1062a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return Dest; 1063a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 1064a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1065db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerGenericValue Interpreter::executeBitCastInst(Value *SrcVal, Type *DstTy, 1066a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF) { 1067a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1068db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = SrcVal->getType(); 1069a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer GenericValue Dest, Src = getOperandValue(SrcVal, SF); 10701df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands if (DstTy->isPointerTy()) { 10711df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands assert(SrcTy->isPointerTy() && "Invalid BitCast"); 1072a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer Dest.PointerVal = Src.PointerVal; 1073b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands } else if (DstTy->isIntegerTy()) { 1074cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (SrcTy->isFloatTy()) { 1075e4d19c9eb22899c9a555395d446a9ceef3bea7ebJay Foad Dest.IntVal = APInt::floatToBits(Src.FloatVal); 1076cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner } else if (SrcTy->isDoubleTy()) { 1077e4d19c9eb22899c9a555395d446a9ceef3bea7ebJay Foad Dest.IntVal = APInt::doubleToBits(Src.DoubleVal); 1078b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands } else if (SrcTy->isIntegerTy()) { 1079f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = Src.IntVal; 1080a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer } else 1081c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Invalid BitCast"); 1082cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner } else if (DstTy->isFloatTy()) { 1083b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands if (SrcTy->isIntegerTy()) 1084f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.FloatVal = Src.IntVal.bitsToFloat(); 1085a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer else 1086a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer Dest.FloatVal = Src.FloatVal; 1087cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner } else if (DstTy->isDoubleTy()) { 1088b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands if (SrcTy->isIntegerTy()) 1089f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.DoubleVal = Src.IntVal.bitsToDouble(); 1090a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer else 1091a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer Dest.DoubleVal = Src.DoubleVal; 1092a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer } else 1093c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Invalid Bitcast"); 1094a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1095a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return Dest; 1096a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 1097a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1098a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencervoid Interpreter::visitTruncInst(TruncInst &I) { 1099a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF = ECStack.back(); 1100a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer SetValue(&I, executeTruncInst(I.getOperand(0), I.getType(), SF), SF); 1101a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 1102a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1103a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencervoid Interpreter::visitSExtInst(SExtInst &I) { 1104a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF = ECStack.back(); 1105a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer SetValue(&I, executeSExtInst(I.getOperand(0), I.getType(), SF), SF); 1106a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 1107a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1108a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencervoid Interpreter::visitZExtInst(ZExtInst &I) { 1109a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF = ECStack.back(); 1110a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer SetValue(&I, executeZExtInst(I.getOperand(0), I.getType(), SF), SF); 1111a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 1112a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1113a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencervoid Interpreter::visitFPTruncInst(FPTruncInst &I) { 1114a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF = ECStack.back(); 1115a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer SetValue(&I, executeFPTruncInst(I.getOperand(0), I.getType(), SF), SF); 1116a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 1117a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1118a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencervoid Interpreter::visitFPExtInst(FPExtInst &I) { 1119d7916e988c544b2ab6af26b723b6bc340ecb78ccChris Lattner ExecutionContext &SF = ECStack.back(); 1120a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer SetValue(&I, executeFPExtInst(I.getOperand(0), I.getType(), SF), SF); 1121a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 1122a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1123a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencervoid Interpreter::visitUIToFPInst(UIToFPInst &I) { 1124a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF = ECStack.back(); 1125a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer SetValue(&I, executeUIToFPInst(I.getOperand(0), I.getType(), SF), SF); 1126a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 1127a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1128a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencervoid Interpreter::visitSIToFPInst(SIToFPInst &I) { 1129a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF = ECStack.back(); 1130a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer SetValue(&I, executeSIToFPInst(I.getOperand(0), I.getType(), SF), SF); 1131a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 1132a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1133a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencervoid Interpreter::visitFPToUIInst(FPToUIInst &I) { 1134a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF = ECStack.back(); 1135a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer SetValue(&I, executeFPToUIInst(I.getOperand(0), I.getType(), SF), SF); 1136a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 1137a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1138a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencervoid Interpreter::visitFPToSIInst(FPToSIInst &I) { 1139a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF = ECStack.back(); 1140a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer SetValue(&I, executeFPToSIInst(I.getOperand(0), I.getType(), SF), SF); 1141a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 1142a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1143a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencervoid Interpreter::visitPtrToIntInst(PtrToIntInst &I) { 1144a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF = ECStack.back(); 1145a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer SetValue(&I, executePtrToIntInst(I.getOperand(0), I.getType(), SF), SF); 1146a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 1147a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1148a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencervoid Interpreter::visitIntToPtrInst(IntToPtrInst &I) { 1149a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF = ECStack.back(); 1150a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer SetValue(&I, executeIntToPtrInst(I.getOperand(0), I.getType(), SF), SF); 1151a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer} 1152a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer 1153a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencervoid Interpreter::visitBitCastInst(BitCastInst &I) { 1154a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer ExecutionContext &SF = ECStack.back(); 1155a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer SetValue(&I, executeBitCastInst(I.getOperand(0), I.getType(), SF), SF); 1156a34c5689dd38a56ad33dfdfd6b951eb4d6d421adChris Lattner} 115792101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 1158c1a2be18eaf1e9862af973126be1f1ef975185f1Brian Gaeke#define IMPLEMENT_VAARG(TY) \ 1159c1a2be18eaf1e9862af973126be1f1ef975185f1Brian Gaeke case Type::TY##TyID: Dest.TY##Val = Src.TY##Val; break 1160c1a2be18eaf1e9862af973126be1f1ef975185f1Brian Gaeke 1161c1a2be18eaf1e9862af973126be1f1ef975185f1Brian Gaekevoid Interpreter::visitVAArgInst(VAArgInst &I) { 1162c1a2be18eaf1e9862af973126be1f1ef975185f1Brian Gaeke ExecutionContext &SF = ECStack.back(); 1163c1a2be18eaf1e9862af973126be1f1ef975185f1Brian Gaeke 11649d20b71ecaffbda5311dfc486b0143d4a94cc502Brian Gaeke // Get the incoming valist parameter. LLI treats the valist as a 11659d20b71ecaffbda5311dfc486b0143d4a94cc502Brian Gaeke // (ec-stack-depth var-arg-index) pair. 1166c1a2be18eaf1e9862af973126be1f1ef975185f1Brian Gaeke GenericValue VAList = getOperandValue(I.getOperand(0), SF); 11679d20b71ecaffbda5311dfc486b0143d4a94cc502Brian Gaeke GenericValue Dest; 11689d20b71ecaffbda5311dfc486b0143d4a94cc502Brian Gaeke GenericValue Src = ECStack[VAList.UIntPairVal.first] 1169f9536330d6271b242572eb1b8011b051b09e128cReid Spencer .VarArgs[VAList.UIntPairVal.second]; 1170db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = I.getType(); 1171f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner switch (Ty->getTypeID()) { 1172cce07c9b3162acc756535e813e6ae818ad61564bJim Grosbach case Type::IntegerTyID: 1173cce07c9b3162acc756535e813e6ae818ad61564bJim Grosbach Dest.IntVal = Src.IntVal; 1174cce07c9b3162acc756535e813e6ae818ad61564bJim Grosbach break; 11759f285c6c31019f9db237932a56eff95d307fce06Jim Grosbach IMPLEMENT_VAARG(Pointer); 11769f285c6c31019f9db237932a56eff95d307fce06Jim Grosbach IMPLEMENT_VAARG(Float); 11779f285c6c31019f9db237932a56eff95d307fce06Jim Grosbach IMPLEMENT_VAARG(Double); 1178c1a2be18eaf1e9862af973126be1f1ef975185f1Brian Gaeke default: 1179ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled dest type for vaarg instruction: " << *Ty << "\n"; 1180c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 1181c1a2be18eaf1e9862af973126be1f1ef975185f1Brian Gaeke } 1182d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman 1183c1a2be18eaf1e9862af973126be1f1ef975185f1Brian Gaeke // Set the Value of this Instruction. 1184c1a2be18eaf1e9862af973126be1f1ef975185f1Brian Gaeke SetValue(&I, Dest, SF); 1185558bc88a00930fce283b240b7c9555f649a18f1bAndrew Lenharth 1186558bc88a00930fce283b240b7c9555f649a18f1bAndrew Lenharth // Move the pointer to the next vararg. 1187558bc88a00930fce283b240b7c9555f649a18f1bAndrew Lenharth ++VAList.UIntPairVal.second; 1188c1a2be18eaf1e9862af973126be1f1ef975185f1Brian Gaeke} 1189c1a2be18eaf1e9862af973126be1f1ef975185f1Brian Gaeke 1190e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid SpencerGenericValue Interpreter::getConstantExprValue (ConstantExpr *CE, 1191e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer ExecutionContext &SF) { 1192e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer switch (CE->getOpcode()) { 1193e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer case Instruction::Trunc: 1194e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer return executeTruncInst(CE->getOperand(0), CE->getType(), SF); 1195e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer case Instruction::ZExt: 1196e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer return executeZExtInst(CE->getOperand(0), CE->getType(), SF); 1197e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer case Instruction::SExt: 1198e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer return executeSExtInst(CE->getOperand(0), CE->getType(), SF); 1199e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer case Instruction::FPTrunc: 1200e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer return executeFPTruncInst(CE->getOperand(0), CE->getType(), SF); 1201e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer case Instruction::FPExt: 1202e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer return executeFPExtInst(CE->getOperand(0), CE->getType(), SF); 1203e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer case Instruction::UIToFP: 1204e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer return executeUIToFPInst(CE->getOperand(0), CE->getType(), SF); 1205e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer case Instruction::SIToFP: 1206e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer return executeSIToFPInst(CE->getOperand(0), CE->getType(), SF); 1207e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer case Instruction::FPToUI: 1208e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer return executeFPToUIInst(CE->getOperand(0), CE->getType(), SF); 1209e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer case Instruction::FPToSI: 1210e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer return executeFPToSIInst(CE->getOperand(0), CE->getType(), SF); 1211e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer case Instruction::PtrToInt: 1212e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer return executePtrToIntInst(CE->getOperand(0), CE->getType(), SF); 1213e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer case Instruction::IntToPtr: 1214e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer return executeIntToPtrInst(CE->getOperand(0), CE->getType(), SF); 1215e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer case Instruction::BitCast: 1216e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer return executeBitCastInst(CE->getOperand(0), CE->getType(), SF); 1217e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer case Instruction::GetElementPtr: 1218e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer return executeGEPOperation(CE->getOperand(0), gep_type_begin(CE), 1219e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer gep_type_end(CE), SF); 1220e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer case Instruction::FCmp: 1221e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer case Instruction::ICmp: 1222e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer return executeCmpInst(CE->getPredicate(), 1223e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer getOperandValue(CE->getOperand(0), SF), 1224e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer getOperandValue(CE->getOperand(1), SF), 1225e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer CE->getOperand(0)->getType()); 1226e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer case Instruction::Select: 1227e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer return executeSelectInst(getOperandValue(CE->getOperand(0), SF), 1228e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer getOperandValue(CE->getOperand(1), SF), 1229e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer getOperandValue(CE->getOperand(2), SF)); 1230e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer default : 1231e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer break; 1232e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer } 1233e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer 1234e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer // The cases below here require a GenericValue parameter for the result 1235e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer // so we initialize one, compute it and then return it. 1236f9536330d6271b242572eb1b8011b051b09e128cReid Spencer GenericValue Op0 = getOperandValue(CE->getOperand(0), SF); 1237f9536330d6271b242572eb1b8011b051b09e128cReid Spencer GenericValue Op1 = getOperandValue(CE->getOperand(1), SF); 1238e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer GenericValue Dest; 1239db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type * Ty = CE->getOperand(0)->getType(); 1240e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer switch (CE->getOpcode()) { 1241ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Add: Dest.IntVal = Op0.IntVal + Op1.IntVal; break; 1242ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Sub: Dest.IntVal = Op0.IntVal - Op1.IntVal; break; 1243ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Mul: Dest.IntVal = Op0.IntVal * Op1.IntVal; break; 1244ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FAdd: executeFAddInst(Dest, Op0, Op1, Ty); break; 1245ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FSub: executeFSubInst(Dest, Op0, Op1, Ty); break; 1246ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FMul: executeFMulInst(Dest, Op0, Op1, Ty); break; 1247f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Instruction::FDiv: executeFDivInst(Dest, Op0, Op1, Ty); break; 1248f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Instruction::FRem: executeFRemInst(Dest, Op0, Op1, Ty); break; 1249f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Instruction::SDiv: Dest.IntVal = Op0.IntVal.sdiv(Op1.IntVal); break; 1250f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Instruction::UDiv: Dest.IntVal = Op0.IntVal.udiv(Op1.IntVal); break; 1251f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Instruction::URem: Dest.IntVal = Op0.IntVal.urem(Op1.IntVal); break; 1252f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Instruction::SRem: Dest.IntVal = Op0.IntVal.srem(Op1.IntVal); break; 1253ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::And: Dest.IntVal = Op0.IntVal & Op1.IntVal; break; 1254ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Or: Dest.IntVal = Op0.IntVal | Op1.IntVal; break; 1255ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Xor: Dest.IntVal = Op0.IntVal ^ Op1.IntVal; break; 1256f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Instruction::Shl: 1257f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = Op0.IntVal.shl(Op1.IntVal.getZExtValue()); 1258f9536330d6271b242572eb1b8011b051b09e128cReid Spencer break; 1259f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Instruction::LShr: 1260f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = Op0.IntVal.lshr(Op1.IntVal.getZExtValue()); 1261f9536330d6271b242572eb1b8011b051b09e128cReid Spencer break; 1262f9536330d6271b242572eb1b8011b051b09e128cReid Spencer case Instruction::AShr: 1263f9536330d6271b242572eb1b8011b051b09e128cReid Spencer Dest.IntVal = Op0.IntVal.ashr(Op1.IntVal.getZExtValue()); 1264f9536330d6271b242572eb1b8011b051b09e128cReid Spencer break; 1265e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer default: 1266ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "Unhandled ConstantExpr: " << *CE << "\n"; 1267b0934ab7d811e23bf530371976b8b35f3242169cAhmed Charles llvm_unreachable("Unhandled ConstantExpr"); 1268e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer } 1269e0929364e8b263f8c090e88e2bf66e2e7bf566e4Reid Spencer return Dest; 1270e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer} 1271e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer 1272e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid SpencerGenericValue Interpreter::getOperandValue(Value *V, ExecutionContext &SF) { 1273e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) { 1274e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer return getConstantExprValue(CE, SF); 1275e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer } else if (Constant *CPV = dyn_cast<Constant>(V)) { 1276e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer return getConstantValue(CPV); 1277e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer } else if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) { 1278e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer return PTOGV(getPointerToGlobal(GV)); 1279e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer } else { 1280e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer return SF.Values[V]; 1281e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer } 1282e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer} 1283e1aa0662162a891b5eb7c4e847e5332adf5e2b86Reid Spencer 128492101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner//===----------------------------------------------------------------------===// 128592101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner// Dispatch and Execution Code 128692101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner//===----------------------------------------------------------------------===// 128792101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 128892101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner//===----------------------------------------------------------------------===// 1289da82ed52ac02497d343b898cca0bb2cf303f062dChris Lattner// callFunction - Execute the specified function... 129092101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner// 1291da82ed52ac02497d343b898cca0bb2cf303f062dChris Lattnervoid Interpreter::callFunction(Function *F, 1292da82ed52ac02497d343b898cca0bb2cf303f062dChris Lattner const std::vector<GenericValue> &ArgVals) { 1293d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman assert((ECStack.empty() || ECStack.back().Caller.getInstruction() == 0 || 1294d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman ECStack.back().Caller.arg_size() == ArgVals.size()) && 1295d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman "Incorrect number of arguments passed into function call!"); 129663bd61330b89afc669b17a08a25b97ba911e1c96Chris Lattner // Make a new stack frame... and fill it in. 129763bd61330b89afc669b17a08a25b97ba911e1c96Chris Lattner ECStack.push_back(ExecutionContext()); 129863bd61330b89afc669b17a08a25b97ba911e1c96Chris Lattner ExecutionContext &StackFrame = ECStack.back(); 1299da82ed52ac02497d343b898cca0bb2cf303f062dChris Lattner StackFrame.CurFunction = F; 1300af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke 1301af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke // Special handling for external functions. 13025cbf985dcbc89fba3208e7baf8b6f488b06d3ec9Reid Spencer if (F->isDeclaration()) { 1303af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke GenericValue Result = callExternalFunction (F, ArgVals); 1304af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke // Simulate a 'ret' instruction of the appropriate type. 1305af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke popStackAndReturnValueToCaller (F->getReturnType (), Result); 1306af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke return; 1307af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke } 1308af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke 1309af955ba503e37c3e1efb694a01bce84b7e5d05a7Brian Gaeke // Get pointers to first LLVM BB & Instruction in function. 1310cdf5178f8362b0b415a4e1c1378a5b76638826beChris Lattner StackFrame.CurBB = F->begin(); 131192101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner StackFrame.CurInst = StackFrame.CurBB->begin(); 1312365a76e46e7b22ee2cd7881d0a7055fc20930fd5Chris Lattner 13132fbfdcffd3e0cf41422aaa6c526c37cb02b81341Chris Lattner // Run through the function arguments and initialize their values... 1314e4d5c441e04bdc00ccf1804744af670655123b07Chris Lattner assert((ArgVals.size() == F->arg_size() || 1315d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman (ArgVals.size() > F->arg_size() && F->getFunctionType()->isVarArg()))&& 13162fbfdcffd3e0cf41422aaa6c526c37cb02b81341Chris Lattner "Invalid number of values passed to function invocation!"); 1317cdf5178f8362b0b415a4e1c1378a5b76638826beChris Lattner 1318cdf5178f8362b0b415a4e1c1378a5b76638826beChris Lattner // Handle non-varargs arguments... 1319365a76e46e7b22ee2cd7881d0a7055fc20930fd5Chris Lattner unsigned i = 0; 13204ccf462b999d66b46e155eaa8c2d0e7ac91ecdfcReid Spencer for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end(); 13214ccf462b999d66b46e155eaa8c2d0e7ac91ecdfcReid Spencer AI != E; ++AI, ++i) 13220b12b5f50ec77a8bd01b92d287c52d748619bb4bChris Lattner SetValue(AI, ArgVals[i], StackFrame); 1323cdf5178f8362b0b415a4e1c1378a5b76638826beChris Lattner 1324cdf5178f8362b0b415a4e1c1378a5b76638826beChris Lattner // Handle varargs arguments... 1325cdf5178f8362b0b415a4e1c1378a5b76638826beChris Lattner StackFrame.VarArgs.assign(ArgVals.begin()+i, ArgVals.end()); 132692101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner} 132792101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 1328951418b7e9e109bb4330d2e901a553aad69637c8Reid Spencer 132992101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattnervoid Interpreter::run() { 13309ad671d54092464b0f385aa5447711eeaf03b17eBrian Gaeke while (!ECStack.empty()) { 133103e43dcfe7a30f01f9ad606d265efd6cb8fe381cBrian Gaeke // Interpret a single instruction & increment the "PC". 133203e43dcfe7a30f01f9ad606d265efd6cb8fe381cBrian Gaeke ExecutionContext &SF = ECStack.back(); // Current stack frame 133303e43dcfe7a30f01f9ad606d265efd6cb8fe381cBrian Gaeke Instruction &I = *SF.CurInst++; // Increment before execute 1334d1c881a8d4da8b4d99c2a40512fbcca652ab445eMisha Brukman 133503e43dcfe7a30f01f9ad606d265efd6cb8fe381cBrian Gaeke // Track the number of dynamic instructions executed. 133603e43dcfe7a30f01f9ad606d265efd6cb8fe381cBrian Gaeke ++NumDynamicInsts; 133792101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner 1338ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene DEBUG(dbgs() << "About to interpret: " << I); 133903e43dcfe7a30f01f9ad606d265efd6cb8fe381cBrian Gaeke visit(I); // Dispatch to one of the visit* methods... 134027725bf13f188c2b46b0211fca0eb9d2bcbcafedChris Lattner#if 0 134127725bf13f188c2b46b0211fca0eb9d2bcbcafedChris Lattner // This is not safe, as visiting the instruction could lower it and free I. 1342bdff548e4dd577a72094d57b282de4e765643b96Chris LattnerDEBUG( 1343951418b7e9e109bb4330d2e901a553aad69637c8Reid Spencer if (!isa<CallInst>(I) && !isa<InvokeInst>(I) && 1344951418b7e9e109bb4330d2e901a553aad69637c8Reid Spencer I.getType() != Type::VoidTy) { 1345ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << " --> "; 134627725bf13f188c2b46b0211fca0eb9d2bcbcafedChris Lattner const GenericValue &Val = SF.Values[&I]; 134727725bf13f188c2b46b0211fca0eb9d2bcbcafedChris Lattner switch (I.getType()->getTypeID()) { 1348c23197a26f34f559ea9797de51e187087c039c42Torok Edwin default: llvm_unreachable("Invalid GenericValue Type"); 1349ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene case Type::VoidTyID: dbgs() << "void"; break; 1350ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene case Type::FloatTyID: dbgs() << "float " << Val.FloatVal; break; 1351ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene case Type::DoubleTyID: dbgs() << "double " << Val.DoubleVal; break; 1352ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene case Type::PointerTyID: dbgs() << "void* " << intptr_t(Val.PointerVal); 135327725bf13f188c2b46b0211fca0eb9d2bcbcafedChris Lattner break; 135427725bf13f188c2b46b0211fca0eb9d2bcbcafedChris Lattner case Type::IntegerTyID: 1355ef573a3a75557b35dd639bc44d5a3fcbe050cdcfDavid Greene dbgs() << "i" << Val.IntVal.getBitWidth() << " " 1356bdff548e4dd577a72094d57b282de4e765643b96Chris Lattner << Val.IntVal.toStringUnsigned(10) 1357bdff548e4dd577a72094d57b282de4e765643b96Chris Lattner << " (0x" << Val.IntVal.toStringUnsigned(16) << ")\n"; 135827725bf13f188c2b46b0211fca0eb9d2bcbcafedChris Lattner break; 135927725bf13f188c2b46b0211fca0eb9d2bcbcafedChris Lattner } 1360bdff548e4dd577a72094d57b282de4e765643b96Chris Lattner }); 136127725bf13f188c2b46b0211fca0eb9d2bcbcafedChris Lattner#endif 136292101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner } 136392101acd7fd44fd467fbeb974ae6c042289c74f9Chris Lattner} 1364