int32* axis) {

TF_RETURN_IF_ERROR(c->GetAttr("axis", axis));

if (*axis < -1 * rank_after_pack || *axis >= rank_after_pack) {

return errors::InvalidArgument("Invalid axis: ", *axis, "; must be in [",

-1 * rank_after_pack, ",", rank_after_pack,

")");

}

if (*axis < 0) *axis = (rank_after_pack + *axis);

return Status::OK();

std::vector<int64> ret(num_elements);

auto data = tensor->vec<T>();

for (int i = 0; i < num_elements; ++i) {

ret[i] = data(i);

}

return ret;

const Tensor* paddings_t, int32 num_dims) {

// paddings_t is known.

std::vector<DimensionHandle> dims(num_dims);

auto paddings_data = paddings_t->matrix<T>();

for (int i = 0; i < num_dims; ++i) {

const T pad0 = paddings_data(i, 0);

const T pad1 = paddings_data(i, 1);

if (pad0 < 0 || pad1 < 0) {

return errors::InvalidArgument("Paddings must be non-negative");

}

TF_RETURN_IF_ERROR(c->Add(c->Dim(input, i), pad0 + pad1, &dims[i]));

}

c->set_output(0, c->MakeShape(dims));

return Status::OK();

// Paddings is a matrix of [input_rank, 2].

ShapeHandle paddings;

TF_RETURN_IF_ERROR(c->WithRank(c->input(1), 2, &paddings));

DimensionHandle unused;

TF_RETURN_IF_ERROR(c->WithValue(c->Dim(paddings, 1), 2, &unused));

// n_dim and input.rank are equivalent.

ShapeHandle input = c->input(0);

DimensionHandle n_dim = c->Dim(paddings, 0);

if (c->ValueKnown(n_dim)) {

TF_RETURN_IF_ERROR(c->WithRank(input, c->Value(n_dim), &input));

} else if (c->RankKnown(input)) {

TF_RETURN_IF_ERROR(c->WithValue(n_dim, c->Rank(input), &n_dim));

}

const Tensor* paddings_t = c->input_tensor(1);

// paddings_t is unknown

if (paddings_t == nullptr) {

if (c->ValueKnown(n_dim)) {

// Make output with n_dim unknown dims.

c->set_output(0, c->UnknownShapeOfRank(c->Value(n_dim)));

} else {

c->set_output(0, c->UnknownShape());

}

return Status::OK();

}

const int64 num_dims = paddings_t->shape().dim_size(0);

TF_RETURN_IF_ERROR(c->WithRank(input, num_dims, &input));

TF_RETURN_IF_ERROR(c->WithValue(n_dim, num_dims, &n_dim));

if (paddings_t->dtype() == DT_INT32) {

return PadKnown<int32>(c, input, paddings_t, num_dims);

} else {

return PadKnown<int64>(c, input, paddings_t, num_dims);

}

ShapeHandle in = c->input(0);

ShapeHandle out;

TF_RETURN_IF_ERROR(c->MakeShapeFromShapeTensor(1, &out));

if (!c->RankKnown(out)) {

// We have no information about the shape of the output.

c->set_output(0, out);

return Status::OK();

}

DimensionHandle num_in_elems = c->NumElements(in);

if (c->FullyDefined(out)) {

DimensionHandle num_out_elems = c->NumElements(out);

if (c->ValueKnown(num_in_elems) &&

c->Value(num_in_elems) != c->Value(num_out_elems)) {

return errors::InvalidArgument(

"Cannot reshape a tensor with ", c->DebugString(num_in_elems),

" elements to shape ", c->DebugString(out), " (",

c->DebugString(num_out_elems), " elements)");

}

c->set_output(0, out);

return Status::OK();

}

if (c->ValueKnown(num_in_elems)) {

// We don't know the number of output elements, but we can try to infer

// the missing dimension.

int32 unknown_idx = -1;

bool too_many_unknown = false;

DimensionHandle known_elems = c->MakeDim(1);

for (int32 i = 0; i < c->Rank(out); ++i) {

DimensionHandle dim = c->Dim(out, i);

if (!c->ValueKnown(dim)) {

if (unknown_idx >= 0) {

too_many_unknown = true;

break;

}

unknown_idx = i;

} else {

TF_RETURN_IF_ERROR(c->Multiply(known_elems, dim, &known_elems));

}

}

if (!too_many_unknown && c->Value(known_elems) != 0) {

DimensionHandle inferred_dim;

TF_RETURN_IF_ERROR(c->Divide(num_in_elems, c->Value(known_elems),

true /* evenly_divisible */, &inferred_dim));

TF_RETURN_IF_ERROR(c->ReplaceDim(out, unknown_idx, inferred_dim, &out));

}

}

c->set_output(0, out);

return Status::OK();